From 40d3650e26af91fefa3092b0b96b1340cfb193a6 Mon Sep 17 00:00:00 2001 From: Nikolas Siccha Date: Tue, 3 Mar 2026 13:56:52 +0100 Subject: [PATCH 1/7] add mock macro --- Project.toml | 2 +- scripts/macro.jl | 22 ++++++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) create mode 100644 scripts/macro.jl diff --git a/Project.toml b/Project.toml index dc40b51..c6fb26c 100644 --- a/Project.toml +++ b/Project.toml @@ -24,5 +24,5 @@ FlexiChains = "0.3" LinearAlgebra = "1.10" PDMats = "0.11" Random = "1.10" -Turing = "0.40" +Turing = "0.40, 0.41, 0.42" julia = "1.10" diff --git a/scripts/macro.jl b/scripts/macro.jl new file mode 100644 index 0000000..edef810 --- /dev/null +++ b/scripts/macro.jl @@ -0,0 +1,22 @@ +macro brm(x) + dump(x) +end +# The example BRM model is supposed to work with three dataframes (dBMI, dpmean, dpsd), which IIUC, have to have the same numbers of rows in this example and could have been merged into one. +@brm model(dBMI, dpmean, dpsd) = begin + # BMI will be a model parameter + BMI ~ Normal(dBMI.BMI_measured, 1) # equivalently: BMI ~ Normal(BMI_measured, 1) |> (data=dBMI) + # Age_first, Age_second are functions of data, and would be computed/updated exactly once + Age_first, Age_second = ploynomial_expand(dpmean.Age; order=2) # equivalently: Age_first, Age_second = ploynomial_expand(Age; order=2) |> (data=dpmean) + # I'm assuming performance_mean is a function of data and model parameters - I think it kind of has to be + performance_mean ~ 1 + Age_first * Treatment + Age_second + (1 + Treatment | Subject) + (1 + Age_first | Experimenter) |> (data=dpmean) + # I'm assuming performance_sd is a function of data and model parameters - I think it kind of has to be + log(performance_sd) ~ 1 + AGE * BMI + max(Age, BMI) + (1 + Age * BMI | Subject) |> (data=dpsd) + # Peter didn't specify data here - but I think it would have to be specified? Or would it be added to the model via conditioning syntax? + Performance ~ Normal(performance_mean, performance_sd) # |> (data=observations_df) as an example + @defaults begin + gr(Subject, by=ClinicalGroup, + Block1=>[Treatment, Age:BMI], + Block2=>[Age, BMI] + ) + end +end \ No newline at end of file From 1d2ec14542b78258c719756f020f510375d65b53 Mon Sep 17 00:00:00 2001 From: Nikolas Siccha Date: Tue, 3 Mar 2026 14:33:07 +0100 Subject: [PATCH 2/7] add single dataframe version --- scripts/macro.jl | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/scripts/macro.jl b/scripts/macro.jl index edef810..c053c3f 100644 --- a/scripts/macro.jl +++ b/scripts/macro.jl @@ -19,4 +19,19 @@ end Block2=>[Age, BMI] ) end -end \ No newline at end of file +end + +# With a single dataframe, the model definition could look as follows (which would lower to the "obvious" syntax): +model = @brm begin + BMI ~ Normal(BMI_measured, 1) + Age_first, Age_second = ploynomial_expand(Age; order=2) + performance_mean ~ 1 + Age_first * Treatment + Age_second + (1 + Treatment | Subject) + (1 + Age_first | Experimenter) + log(performance_sd) ~ 1 + AGE * BMI + max(Age, BMI) + (1 + Age * BMI | Subject) + Performance ~ Normal(performance_mean, performance_sd) + @defaults begin + gr(Subject, by=ClinicalGroup, + Block1=>[Treatment, Age:BMI], + Block2=>[Age, BMI] + ) + end +end \ No newline at end of file From 6baf94f58950c9380de51ae88ba64bfc2f32ba95 Mon Sep 17 00:00:00 2001 From: Nikolas Siccha Date: Wed, 4 Mar 2026 13:12:51 +0100 Subject: [PATCH 3/7] first parsing prototype --- scripts/macro.jl | 132 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 130 insertions(+), 2 deletions(-) diff --git a/scripts/macro.jl b/scripts/macro.jl index c053c3f..dd9bc50 100644 --- a/scripts/macro.jl +++ b/scripts/macro.jl @@ -23,7 +23,7 @@ end # With a single dataframe, the model definition could look as follows (which would lower to the "obvious" syntax): model = @brm begin - BMI ~ Normal(BMI_measured, 1) + # BMI ~ Normal(BMI_measured, 1) Age_first, Age_second = ploynomial_expand(Age; order=2) performance_mean ~ 1 + Age_first * Treatment + Age_second + (1 + Treatment | Subject) + (1 + Age_first | Experimenter) log(performance_sd) ~ 1 + AGE * BMI + max(Age, BMI) + (1 + Age * BMI | Subject) @@ -34,4 +34,132 @@ model = @brm begin Block2=>[Age, BMI] ) end -end \ No newline at end of file +end + + +macro brm(x) + esc(_brm(x)) +end +begin +function ensurecols end +function maybedists end +# isxcall(x) = Meta.isexpr(x, :call) +isxcall(x, f) = Meta.isexpr(x, :call) && x.args[1] == f +fixcall(x) = x +fixcall(x::Expr) = if Meta.isexpr(x, :call) + f = x.args[1] + pargs = [] + args = [] + for arg in fixcall.(x.args[2:end]) + if Meta.isexpr(arg, :parameters) + append!(pargs, arg.args) + else + push!(args, arg) + end + end + if length(pargs) > 0 + Expr(x.head, f, Expr(:parameters, pargs...), args...) + else + Expr(x.head, f, args...) + end +else + Expr(x.head, fixcall.(x.args)...) +end +xensurecols(x::Expr) = if x.head == :call + Expr(:call, ensurecols, x.args...) |> fixcall +else + dump(x) + error("Don't know how to handle xensurecols($x)!") +end + parse!(x::LineNumberNode; info) = x +parse!(x::Expr; info) = if x.head == :block + Expr(:block, parse!.(x.args; info)...) +elseif x.head == :(=) + lhs, rhs = x.args + lhs = parse_assignment_lhs!(lhs; info) + rhs = parse_assignment_rhs!(rhs; info) + Expr(:(=), lhs, xensurecols(rhs)) +elseif isxcall(x, :~) + _, lhs, rhs = x.args + lhs = parse_sampling_lhs!(lhs; info) + rhs = parse_sampling_rhs!(rhs; info) + if isxcall(rhs, ensurecols) + :($lhs = $maybedists(;force=isdata($lhs))($(rhs.args[2:end]...))) + else + :($lhs = $maybedists(;force=isdata($lhs))($(rhs))) + end +else + dump(x) + error("Don't know how to handle parse!($x)!") +end +parse_assignment_lhs!(x::Symbol; info) = (get!(info.alllocals, x, :local); x) +parse_assignment_lhs!(x::Expr; info) = begin + @assert Meta.isexpr(x, (:tuple, :vect)) + args = parse_assignment_lhs!.(x.args; info) + Expr(x.head, args...) +end +parse_assignment_rhs!(x::Symbol; info) = (get!(info.alllocals, x, :nonlocal); x) +parse_assignment_rhs!(x::Expr; info) = if x.head == :call + Expr(:call, x.args[1], parse_assignment_rhs!.(x.args[2:end]; info)...) +elseif Meta.isexpr(x, :parameters) + x +else + dump(x) + error("Don't know how to handle parse_assignment_rhs!($x)!") +end +parse_sampling_lhs!(x::Symbol; info) = (get!(info.alllocals, x, :maybelocal); x) +parse_sampling_lhs!(x::Expr; info) = if x.head == :call + Expr(:call, x.args[1], parse_sampling_lhs!.(x.args[2:end]; info)...) +else + @assert Meta.isexpr(x, (:tuple, :vect)) + args = parse_sampling_lhs!.(x.args; info) + Expr(x.head, args...) +end +parse_sampling_rhs!(x::Number; info) = x +parse_sampling_rhs!(x::Symbol; info) = (get!(info.alllocals, x, :nonlocal); x) +parse_sampling_rhs!(x::Expr; info) = if x.head == :call + if x.args[1] in (:+, :*, :|) + Expr(:call, x.args[1], parse_sampling_rhs!.(x.args[2:end]; info)...) + else + xensurecols(parse_assignment_rhs!(x; info)) + end +elseif Meta.isexpr(x, :parameters) + x +else + dump(x) + error("Don't know how to handle parse_sampling_rhs!($x)!") +end +using OrderedCollections +_brm(x::Expr) = begin + @assert x.head == :block + alllocals = OrderedDict{Symbol,Symbol}() + info = (;alllocals) + x = parse!(x; info) + nonlocals = [key for (key, value) in pairs(alllocals) if value == :nonlocal] + maybelocals = [key for (key, value) in pairs(alllocals) if value == :maybelocal] + locals = [key for (key, value) in pairs(alllocals) if value == :local] + init = quote + (;$(nonlocals...)) = data(__df__) + (;$(maybelocals...)) = maybedata(__df__) + end + finalize = :(BRM(;$(keys(alllocals)...))) + Expr(:(=), :(model(__df__)), Expr(:block, init, x.args..., finalize)) +end +end +@macroexpand @brm begin + Age_first, Age_second = ploynomial_expand(Age; order=2) + performance_mean ~ 1 + Age_first * Treatment + Age_second + (1 + Treatment | Subject) + (1 + Age_first | Experimenter) + log(performance_sd) ~ 1 + Age * BMI + max(Age, BMI) + (1 + Age * BMI | Subject) + Performance ~ Normal(performance_mean, performance_sd) +end + + +# model(__df__) = begin +# (; Age, Treatment, Subject, Experimenter, BMI) = data(__df__) +# (; performance_mean, performance_sd, Performance) = maybedata(__df__) +# (Age_first, Age_second) = (ensurecols)(ploynomial_expand, Age; order=2) +# performance_mean = ((maybedists)(; force=isdata(performance_mean)))(1 + Age_first * Treatment + Age_second + ((1 + Treatment) | Subject) + ((1 + Age_first) | Experimenter)) +# log(performance_sd) = ((maybedists)(; force=isdata(log(performance_sd))))(1 + Age * BMI + (ensurecols)(max, Age, BMI) + ((1 + Age * BMI) | Subject)) +# Performance = ((maybedists)(; force=isdata(Performance)))(Normal, performance_mean, performance_sd) +# BRM(; Age_first, Age_second, Age, performance_mean, Treatment, Subject, Experimenter, performance_sd, BMI, Performance) +# end \ No newline at end of file From 799de284eba1791212fd915d087a979175bc5d8c Mon Sep 17 00:00:00 2001 From: Nikolas Siccha Date: Wed, 11 Mar 2026 11:27:10 +0100 Subject: [PATCH 4/7] add version which isn't doing the right thing and is 10 times slower than brms for the primal computation and 20 times (Enzyme) or 30 times (Mooncake) slower for the gradient computation --- scripts/Benchmarking/Project.toml | 6 + scripts/Benchmarking/main.jl | 90 ++++++++++ scripts/Project.toml | 11 +- scripts/examples/database.jl | 12 ++ scripts/macro.jl | 290 ++++++++++++++++++------------ scripts/vimpl.jl | 198 ++++++++++++++++++++ 6 files changed, 489 insertions(+), 118 deletions(-) create mode 100644 scripts/Benchmarking/Project.toml create mode 100644 scripts/Benchmarking/main.jl create mode 100644 scripts/examples/database.jl create mode 100644 scripts/vimpl.jl diff --git a/scripts/Benchmarking/Project.toml b/scripts/Benchmarking/Project.toml new file mode 100644 index 0000000..ddcc5ec --- /dev/null +++ b/scripts/Benchmarking/Project.toml @@ -0,0 +1,6 @@ +[deps] +Chairmarks = "0ca39b1e-fe0b-4e98-acfc-b1656634c4de" +DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" +Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" +Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" +Reactant = "3c362404-f566-11ee-1572-e11a4b42c853" diff --git a/scripts/Benchmarking/main.jl b/scripts/Benchmarking/main.jl new file mode 100644 index 0000000..ef892d1 --- /dev/null +++ b/scripts/Benchmarking/main.jl @@ -0,0 +1,90 @@ +# Gemini claims you can do this! +using Pkg +Pkg.activate(@__DIR__) +insert!(LOAD_PATH, 2, joinpath(@__DIR__, "..")) + +include("../macro.jl") +include("../vimpl.jl") +include("../examples/database.jl") + +using Chairmarks, Random + +db = Database() +df = db.dataset(:bambi, :escs) +fdf = map(Vector{Float64}, (;df.drugs, df.o, df.c, df.e, df.a, df.n)) +# Using fdf is considerably faster than using df +tmp = @brm fdf """ + loc ~ o + c + e + a + n + log(err_scale) ~ 1 + drugs ~ Normal(loc, err_scale) +""" +display(@brm """ + loc ~ o + c + e + a + n + log(err_scale) ~ 1 + drugs ~ Normal(loc, err_scale) +""") +vtmp = VBRMI(tmp) +display(vtmp) +display(@be randn(LogDensityProblems.dimension(vtmp)) LogDensityProblems.logdensity($vtmp, _)) + +# import Reactant + +# rx = Reactant.to_rarray(randn(LogDensityProblems.dimension(vtmp))) +# errors: NoFieldMatchError(...) +# _rtmp = Reactant.to_rarray(vtmp) +# errors: MethodError: no method matching _copyto!(::SubArray{…}, ::Base.Broadcast.Broadcasted{…}) +# rtmp = Reactant.@compile LogDensityProblems.logdensity(vtmp, rx) +# display(@be randn(LogDensityProblems.dimension(vtmp)) LogDensityProblems.logdensity($rtmp, _)) +# error() + +using LogDensityProblemsAD, Mooncake, Enzyme, DifferentiationInterface +struct ADLogDensity{F, B, E} + f::F + backend::B + extras::E +end + +ADLogDensity(f, backend) = ADLogDensity( + f, + backend, + DifferentiationInterface.prepare_gradient( + Base.Fix1(LogDensityProblems.logdensity, f), + backend, + zeros(LogDensityProblems.dimension(f)) + ) +) + +LogDensityProblems.capabilities(::ADLogDensity) = LogDensityProblems.LogDensityOrder{1}() +LogDensityProblems.dimension(p::ADLogDensity) = LogDensityProblems.dimension(p.f) +LogDensityProblems.logdensity(p::ADLogDensity, x) = LogDensityProblems.logdensity(p.f, x) +LogDensityProblems.logdensity_and_gradient( + p::ADLogDensity, x +) = DifferentiationInterface.value_and_gradient( + Base.Fix1(LogDensityProblems.logdensity, p.f), p.extras, p.backend, x +) + + + +mvtmp1 = ADgradient(AutoMooncake(), vtmp) +mvtmp2 = ADLogDensity(vtmp, AutoMooncake()) +evtmp1 = ADgradient(AutoEnzyme(; mode = Enzyme.set_runtime_activity(Enzyme.Reverse)), vtmp) +evtmp2 = ADLogDensity(vtmp, AutoEnzyme(; + mode=Enzyme.set_runtime_activity(Enzyme.Reverse), + function_annotation=Enzyme.Duplicated +)) + +x = randn(LogDensityProblems.dimension(vtmp)) +display(mapreduce(hcat, (mvtmp1, mvtmp2, evtmp1, evtmp2)) do b + LogDensityProblems.logdensity_and_gradient(b, copy(x))[2] +end) + +@info "Primal" +display(@be randn(LogDensityProblems.dimension(vtmp)) LogDensityProblems.logdensity($vtmp, _)) +@info "Inefficient Mooncake skipped..." +# display(@be randn(LogDensityProblems.dimension(vtmp)) LogDensityProblems.logdensity_and_gradient($mvtmp1, _)) +@info "Mooncake" +display(@be randn(LogDensityProblems.dimension(vtmp)) LogDensityProblems.logdensity_and_gradient($mvtmp2, _)) +@warn "wrong Enzyme skipped..." +# display(@be randn(LogDensityProblems.dimension(vtmp)) LogDensityProblems.logdensity_and_gradient($evtmp1, _)) +@info "correct Enzyme" +display(@be randn(LogDensityProblems.dimension(vtmp)) LogDensityProblems.logdensity_and_gradient($evtmp2, _)) \ No newline at end of file diff --git a/scripts/Project.toml b/scripts/Project.toml index 4a3f7db..d5ac59f 100644 --- a/scripts/Project.toml +++ b/scripts/Project.toml @@ -1,9 +1,16 @@ [deps] BayesianRegressionModels = "cdd3e328-398d-47a6-a87b-6047aaf4b4bc" -CatalogServer = "a1b2c3d4-0000-0000-0000-000000000001" CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" +Chairmarks = "0ca39b1e-fe0b-4e98-acfc-b1656634c4de" DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" +DynamicObjects = "23d02862-63fe-4c6e-8fdb-1d52cbbd39d5" +ElasticArrays = "fdbdab4c-e67f-52f5-8c3f-e7b388dad3d4" FlexiChains = "4a37a8b9-6e57-4b92-8664-298d46e639f7" +InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" +LogDensityProblems = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c" +LogDensityProblemsAD = "996a588d-648d-4e1f-a8f0-a84b347e47b1" +LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +OrderedCollections = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" Oxygen = "df9a0d86-3283-4920-82dc-4555fc0d1d8b" -YAML = "ddb6d928-2868-570f-bddf-ab3f9cf99eb6" +Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" diff --git a/scripts/examples/database.jl b/scripts/examples/database.jl new file mode 100644 index 0000000..a98f505 --- /dev/null +++ b/scripts/examples/database.jl @@ -0,0 +1,12 @@ +include("all.jl") +using DynamicObjects + +@dynamicstruct "" serial struct Database + mod(m::Symbol) = _SOURCE_MODULES[m] + @cached dataset(m::Symbol, name::Symbol) = getproperty(mod(m), :load)(Val(name)) + # formula(m::Symbol, name::Symbol) = getproperty(mod(m), :examples)(Val(name))[1] + # example(m::Symbol, name::Symbol) = begin + # _formula, datakey = getproperty(mod(m), :examples)(Val(name)) + # brm(dataset(m, datakey), _formula) + # end +end \ No newline at end of file diff --git a/scripts/macro.jl b/scripts/macro.jl index dd9bc50..d6baf3c 100644 --- a/scripts/macro.jl +++ b/scripts/macro.jl @@ -1,49 +1,26 @@ +using OrderedCollections macro brm(x) - dump(x) + esc(_brm(x)) end -# The example BRM model is supposed to work with three dataframes (dBMI, dpmean, dpsd), which IIUC, have to have the same numbers of rows in this example and could have been merged into one. -@brm model(dBMI, dpmean, dpsd) = begin - # BMI will be a model parameter - BMI ~ Normal(dBMI.BMI_measured, 1) # equivalently: BMI ~ Normal(BMI_measured, 1) |> (data=dBMI) - # Age_first, Age_second are functions of data, and would be computed/updated exactly once - Age_first, Age_second = ploynomial_expand(dpmean.Age; order=2) # equivalently: Age_first, Age_second = ploynomial_expand(Age; order=2) |> (data=dpmean) - # I'm assuming performance_mean is a function of data and model parameters - I think it kind of has to be - performance_mean ~ 1 + Age_first * Treatment + Age_second + (1 + Treatment | Subject) + (1 + Age_first | Experimenter) |> (data=dpmean) - # I'm assuming performance_sd is a function of data and model parameters - I think it kind of has to be - log(performance_sd) ~ 1 + AGE * BMI + max(Age, BMI) + (1 + Age * BMI | Subject) |> (data=dpsd) - # Peter didn't specify data here - but I think it would have to be specified? Or would it be added to the model via conditioning syntax? - Performance ~ Normal(performance_mean, performance_sd) # |> (data=observations_df) as an example - @defaults begin - gr(Subject, by=ClinicalGroup, - Block1=>[Treatment, Age:BMI], - Block2=>[Age, BMI] - ) - end +macro brm(df, x) + esc(Expr(:call, _brm(x), df)) end - -# With a single dataframe, the model definition could look as follows (which would lower to the "obvious" syntax): -model = @brm begin - # BMI ~ Normal(BMI_measured, 1) - Age_first, Age_second = ploynomial_expand(Age; order=2) - performance_mean ~ 1 + Age_first * Treatment + Age_second + (1 + Treatment | Subject) + (1 + Age_first | Experimenter) - log(performance_sd) ~ 1 + AGE * BMI + max(Age, BMI) + (1 + Age * BMI | Subject) - Performance ~ Normal(performance_mean, performance_sd) - @defaults begin - gr(Subject, by=ClinicalGroup, - Block1=>[Treatment, Age:BMI], - Block2=>[Age, BMI] - ) - end +macro n(x) + esc(_n(x)) end - - -macro brm(x) - esc(_brm(x)) +macro x(x) + esc(_x(x)) +end +macro getproperty(x) + esc(_getproperty(x)) +end +_getproperty(x::Expr) = begin + @assert x.head == :(.) + @assert length(x.args) == 2 + lhs, qrhs = x.args + :(hasproperty($lhs, $qrhs) ? $x : $(qrhs.value)) end begin -function ensurecols end -function maybedists end -# isxcall(x) = Meta.isexpr(x, :call) isxcall(x, f) = Meta.isexpr(x, :call) && x.args[1] == f fixcall(x) = x fixcall(x::Expr) = if Meta.isexpr(x, :call) @@ -65,101 +42,182 @@ fixcall(x::Expr) = if Meta.isexpr(x, :call) else Expr(x.head, fixcall.(x.args)...) end -xensurecols(x::Expr) = if x.head == :call - Expr(:call, ensurecols, x.args...) |> fixcall -else - dump(x) - error("Don't know how to handle xensurecols($x)!") +function assign end +function doublepipe end +function gr end +_brm(x::AbstractString; kwargs...) = _brm(Meta.parse(""" +begin + $x end - parse!(x::LineNumberNode; info) = x +"""); kwargs...) +_brm(x::Expr; df=nothing) = begin + lhs, x = x.head == :(=) ? x.args : (:($(gensym("model"))(__df__)), x) + alllocals = OrderedDict{Symbol,Symbol}() + info = (;alllocals) + x = parse!(x; info) + nonlocals = [key for (key, value) in pairs(alllocals) if value == :nonlocal] + maybelocals = [key for (key, value) in pairs(alllocals) if value == :maybelocal] + init = quote + (;$(nonlocals...)) = data(__df__) + (;$(maybelocals...)) = maybedata(__df__) + end + finalize = quote + $BRMI(;$(keys(alllocals)...)) + end + if isnothing(df) + Expr(:(=), lhs, Expr(:block, init, x, finalize)) + else + Expr(:let, + Expr(:block, :(__df__ = $df), :(__ddf__ = $data(__df__)), [:($nonlocal = @getproperty __ddf__.$nonlocal) for nonlocal in nonlocals]...), + Expr(:block, :((;$(maybelocals...)) = maybedata(__df__)), x, finalize) + ) + end +end +brm(df, formula::AbstractString) = eval(_brm(formula; df)) +parse!(x; info) = x parse!(x::Expr; info) = if x.head == :block Expr(:block, parse!.(x.args; info)...) elseif x.head == :(=) lhs, rhs = x.args - lhs = parse_assignment_lhs!(lhs; info) - rhs = parse_assignment_rhs!(rhs; info) - Expr(:(=), lhs, xensurecols(rhs)) + parselocals!(rhs; info, val=:nonlocal) + parselocals!(lhs; info, val=:local) + :(@n $lhs = @x $assign($(xname(lhs)), $rhs)) elseif isxcall(x, :~) _, lhs, rhs = x.args - lhs = parse_sampling_lhs!(lhs; info) - rhs = parse_sampling_rhs!(rhs; info) - if isxcall(rhs, ensurecols) - :($lhs = $maybedists(;force=isdata($lhs))($(rhs.args[2:end]...))) - else - :($lhs = $maybedists(;force=isdata($lhs))($(rhs))) - end + parselocals!(rhs; info, val=:nonlocal) + parselocals!(lhs; info, val=:maybelocal) + :(@n $lhs = @x $x) else dump(x) error("Don't know how to handle parse!($x)!") end -parse_assignment_lhs!(x::Symbol; info) = (get!(info.alllocals, x, :local); x) -parse_assignment_lhs!(x::Expr; info) = begin - @assert Meta.isexpr(x, (:tuple, :vect)) - args = parse_assignment_lhs!.(x.args; info) - Expr(x.head, args...) -end -parse_assignment_rhs!(x::Symbol; info) = (get!(info.alllocals, x, :nonlocal); x) -parse_assignment_rhs!(x::Expr; info) = if x.head == :call - Expr(:call, x.args[1], parse_assignment_rhs!.(x.args[2:end]; info)...) -elseif Meta.isexpr(x, :parameters) - x +parselocals!(x; kwargs...) = x +parselocals!(x::Symbol; info, val) = get!(info.alllocals, x, val) +parselocals!(x::Expr; info, val) = if Meta.isexpr(x, (:call, :kw)) + parselocals!.(x.args[2:end]; info, val) else - dump(x) - error("Don't know how to handle parse_assignment_rhs!($x)!") -end -parse_sampling_lhs!(x::Symbol; info) = (get!(info.alllocals, x, :maybelocal); x) -parse_sampling_lhs!(x::Expr; info) = if x.head == :call - Expr(:call, x.args[1], parse_sampling_lhs!.(x.args[2:end]; info)...) -else - @assert Meta.isexpr(x, (:tuple, :vect)) - args = parse_sampling_lhs!.(x.args; info) - Expr(x.head, args...) -end -parse_sampling_rhs!(x::Number; info) = x -parse_sampling_rhs!(x::Symbol; info) = (get!(info.alllocals, x, :nonlocal); x) -parse_sampling_rhs!(x::Expr; info) = if x.head == :call - if x.args[1] in (:+, :*, :|) - Expr(:call, x.args[1], parse_sampling_rhs!.(x.args[2:end]; info)...) + parselocals!.(x.args; info, val) +end +_n(x::Expr) = begin + @assert x.head == :(=) + lhs, rhs = x.args + alhs = xassignable(lhs) + nlhs = xname(alhs) + :($alhs = $NamedColumn($nlhs, $rhs)) +end +xassignable(x::Symbol) = x +xassignable(x::Expr) = if Meta.isexpr(x, (:tuple, :vect)) + Expr(x.head, xassignable.(x.args)...) +elseif x.head == :call + if length(x.args) == 2 + xassignable(x.args[2]) else - xensurecols(parse_assignment_rhs!(x; info)) + @warn "Don't know how to handle xassignable($x)!" + Symbol(x) end -elseif Meta.isexpr(x, :parameters) - x else dump(x) - error("Don't know how to handle parse_sampling_rhs!($x)!") + error("Don't know how to handle xassignable($x)!") end -using OrderedCollections -_brm(x::Expr) = begin - @assert x.head == :block - alllocals = OrderedDict{Symbol,Symbol}() - info = (;alllocals) - x = parse!(x; info) - nonlocals = [key for (key, value) in pairs(alllocals) if value == :nonlocal] - maybelocals = [key for (key, value) in pairs(alllocals) if value == :maybelocal] - locals = [key for (key, value) in pairs(alllocals) if value == :local] - init = quote - (;$(nonlocals...)) = data(__df__) - (;$(maybelocals...)) = maybedata(__df__) - end - finalize = :(BRM(;$(keys(alllocals)...))) - Expr(:(=), :(model(__df__)), Expr(:block, init, x.args..., finalize)) +xname(x::Symbol) = Meta.quot(x) +xname(x::Expr) = if Meta.isexpr(x, (:tuple, :vect)) + Expr(x.head, xname.(x.args)...) +else + @warn "Don't know how to handle xassignable($x)!" + Symbol(x) + # dump(x) + # error("Don't know how to handle xname($x)!") end +_x(x) = x +_x(x::Symbol) = x +_x(x::Expr) = if x.head == :call + Expr(:call, ExprColumn, _x.(x.args)...) |> fixcall +elseif x.head == :|| + Expr(:call, ExprColumn, doublepipe, _x.(x.args)...) +else + Expr(x.head, _x.(x.args)...) +end +struct Data{P} + parent::P +end +Base.parent(d::Data) = getfield(d, :parent) +Base.hasproperty(d::Data, x::Symbol) = hasproperty(parent(d), x) +Base.getproperty(d::Data, x::Symbol) = NamedColumn(x, DataColumn(getproperty(parent(d), x))) +data(x) = Data(x) +struct MaybeData{P} + parent::P +end +Base.parent(d::MaybeData) = getfield(d, :parent) +Base.hasproperty(d::MaybeData, x::Symbol) = hasproperty(parent(d), x) +Base.getproperty(d::MaybeData, x::Symbol) = NamedColumn(x, hasproperty(d, x) ? DataColumn(getproperty(parent(d), x)) : MissingColumn()) +maybedata(x) = MaybeData(x) +abstract type AbstractColumn end +struct MissingColumn <: AbstractColumn end +struct DataColumn{P} <: AbstractColumn + parent::P end -@macroexpand @brm begin - Age_first, Age_second = ploynomial_expand(Age; order=2) - performance_mean ~ 1 + Age_first * Treatment + Age_second + (1 + Treatment | Subject) + (1 + Age_first | Experimenter) - log(performance_sd) ~ 1 + Age * BMI + max(Age, BMI) + (1 + Age * BMI | Subject) - Performance ~ Normal(performance_mean, performance_sd) +Base.parent(d::DataColumn) = getfield(d, :parent) +struct NamedColumn{N,P} <: AbstractColumn + name::N + parent::P +end +name(x::NamedColumn) = getfield(x, :name) +Base.parent(x::NamedColumn) = getfield(x, :parent) + +struct ExprColumn{F,A<:Tuple,K<:NamedTuple} <: AbstractColumn + f::F + args::A + kwargs::K + ExprColumn(f, args...; kwargs...) = new{typeof(f),typeof(args),typeof((;kwargs...))}(f,args,(;kwargs...)) + ExprColumn(f::Type, args...; kwargs...) = new{Type{f},typeof(args),typeof((;kwargs...))}(f,args,(;kwargs...)) +end +getf(x::ExprColumn) = getfield(x, :f) +getargs(x::ExprColumn) = getfield(x, :args) +getargs(x::ExprColumn, n) = (rv = getargs(x); @assert length(rv) == n; rv) +getargs(::typeof(+), x::ExprColumn{typeof(+)}) = getargs(x) +getargs(::typeof(+), x::ExprColumn) = (x,) +getargs(::typeof(+), x) = (x,) +getkwargs(x::ExprColumn) = getfield(x, :kwargs) +getop(x) = getf(x) +getop(::ExprColumn{typeof(doublepipe)}) = :|| +getop(::ExprColumn{typeof(assign)}) = :(=) + +struct LikelihoodColumn{P,R} <: AbstractColumn + parent::P + rhs::R end +Base.parent(d::LikelihoodColumn) = getfield(d, :parent) +rhs(d::LikelihoodColumn) = getfield(d, :rhs) +maybedists(lhs::AbstractColumn, x::AbstractColumn) = LikelihoodColumn(lhs, x) +struct BRMI{O<:NamedTuple} + operations::O +end +BRMI(;kwargs...) = BRMI((;kwargs...)) +Base.show(io::IO, (;operations)::BRMI) = begin + print(io, "BRMI:\n") + for (key, value::NamedColumn) in pairs(operations) + print(io, " ", key, ": ", parent(value), "\n") + end +end +Base.show(io::IO, d::DataColumn) = begin + print(io, "data (eltype=", eltype(parent(d)), ")") +end +Base.show(io::IO, x::ExprColumn{<:Union{typeof.((~,*,+,|,doublepipe,assign))...}}) = begin + print(io, "(", ) + join(io, getargs(x), " $(getop(x)) ") + print(io, ")") +end +nonemptyjoin(io::IO, iterator, args...; first) = if length(iterator) > 0 + print(io, first) + join(io, iterator, args...) +end +Base.show(io::IO, x::ExprColumn) = begin + print(io, getf(x), "(", ) + join(io, getargs(x), ", ") + nonemptyjoin(io, ["$key=$value" for (key, value) in pairs(getkwargs(x))], ", "; first="; ") + print(io, ")") +end +Base.show(io::IO, x::NamedColumn) = print(io, name(x)) -# model(__df__) = begin -# (; Age, Treatment, Subject, Experimenter, BMI) = data(__df__) -# (; performance_mean, performance_sd, Performance) = maybedata(__df__) -# (Age_first, Age_second) = (ensurecols)(ploynomial_expand, Age; order=2) -# performance_mean = ((maybedists)(; force=isdata(performance_mean)))(1 + Age_first * Treatment + Age_second + ((1 + Treatment) | Subject) + ((1 + Age_first) | Experimenter)) -# log(performance_sd) = ((maybedists)(; force=isdata(log(performance_sd))))(1 + Age * BMI + (ensurecols)(max, Age, BMI) + ((1 + Age * BMI) | Subject)) -# Performance = ((maybedists)(; force=isdata(Performance)))(Normal, performance_mean, performance_sd) -# BRM(; Age_first, Age_second, Age, performance_mean, Treatment, Subject, Experimenter, performance_sd, BMI, Performance) -# end \ No newline at end of file +end \ No newline at end of file diff --git a/scripts/vimpl.jl b/scripts/vimpl.jl new file mode 100644 index 0000000..9c5bceb --- /dev/null +++ b/scripts/vimpl.jl @@ -0,0 +1,198 @@ +using LogExpFunctions, InverseFunctions, Distributions, ElasticArrays, LogDensityProblems, LinearAlgebra + +struct VBRMI{P<:BRMI,M<:NamedTuple} + parent::P + meta::M +end +VBRMI(p::BRMI) = VBRMI(p, finalize(foldl(vmeta, p.operations; init=(;materialized=(;), blocks=(;))))) +finalize(x) = merge(x, (;block_data=map(x.blocks) do values + m, n = size(values) + (;L=zeros(n, n)) +end)) +rmerge(x::NamedTuple, y::NamedTuple) = begin + xykeys = (intersect(keys(x), keys(y))...,) + merge(x, y, map(rmerge, NamedTuple{xykeys}(x), NamedTuple{xykeys}(y))) +end +rmerge(::AbstractDict, ::AbstractDict) = error("Can only rmerge NamedTuples for now!") +rmerge(x, y) = y +vmeta(meta, x::NamedColumn) = begin + meta, m = vmeta(meta, parent(x))::Tuple + rmerge(meta, (;materialized=(;name(x)=>m))) +end +vmeta(meta, x::DataColumn) = meta, x +vmeta(meta, x::ExprColumn{typeof(assign)}) = vmeta_assignment(meta, getargs(x)...; getkwargs(x)...) +vmeta(meta, x::ExprColumn{typeof(~)}) = vmeta_sampling(meta, getargs(x)...; getkwargs(x)...) + +vmeta_assignment(meta, ::Symbol, x) = meta, vmaterialize(vbroadcasted(x; meta)) +vbroadcasted(;kwargs...) = (args...)->vbroadcasted(args...; kwargs...) +vbroadcasted(x::NamedColumn{<:Any,<:DataColumn}; meta) = parent(meta.materialized[name(x)]) +vbroadcasted(x::NamedColumn; meta) = meta.materialized[name(x)] +vbroadcasted(x::ExprColumn; meta) = Base.broadcasted(getf(x), map(vbroadcasted(;meta), getargs(x))...) +getinverse(x::ExprColumn{<:Any,<:Tuple{<:Any}}) = inverse(getf(x)) +getinverse(x::ExprColumn{<:Any,<:Tuple{<:ExprColumn}}) = inverse(getf(x)) ∘ getinverse(getargs(x, 1)[1]) +vmeta_sampling(meta, lhs::ExprColumn, rhs) = begin + meta, o = vmeta_sampling_rhs(meta, rhs; group=:__population__) + meta, vmaterialize(Base.broadcasted(getinverse(lhs), o)) +end +vmeta_sampling(meta, ::NamedColumn{<:Any,MissingColumn}, rhs) = begin + meta, o = vmeta_sampling_rhs(meta, rhs; group=:__population__) + meta, vmaterialize(o) +end +vmeta_sampling(meta, lhs::NamedColumn{<:Any,<:DataColumn}, rhs) = begin + meta, o = vmeta_sampling_rhs(meta, rhs; group=:__population__) + meta, LikelihoodColumn(parent(parent(lhs)), o) +end +vmeta_sampling_rhs(;kwargs...) = (args...)->vmeta_sampling_rhs(args...; kwargs...) +vmeta_sampling_rhs(meta, x::ExprColumn{typeof(+)}; kwargs...) = begin + meta, args = foldl(getargs(x); init=(meta, ())) do (_meta, _args), _arg + _meta, _arg = vmeta_sampling_rhs(_meta, _arg; kwargs...) + _meta, (_args..., _arg) + end + meta, Base.broadcasted(+, args...) +end +vmeta_sampling_rhs(meta, x::ExprColumn; kwargs...) = vmeta_sampling_rhs(meta, vbroadcasted(x; meta); kwargs...) +vmeta_sampling_rhs(meta, x::ExprColumn{typeof(*)}; kwargs...) = error("NOT IMPLEMENTED") +vmeta_sampling_rhs(meta, x::ExprColumn{typeof(&)}; kwargs...) = error("NOT IMPLEMENTED") +vmeta_sampling_rhs(meta, x::ExprColumn{typeof(|)}; kwargs...) = begin + lhs, rhs = getargs(x, 2) + vmeta_sampling_rhs(meta, lhs; group=rhs) +end +vmeta_sampling_rhs(meta, ::Int; group) = begin + meta, p = growblock!!(meta, group, 1) + meta, p +end +vmeta_sampling_rhs(meta, x::NamedColumn; kwargs...) = vmeta_sampling_rhs(meta, meta.materialized[name(x)]; kwargs...) +vmeta_sampling_rhs(meta, x::DataColumn; kwargs...) = vmeta_sampling_rhs(meta, parent(x); kwargs...) +vmeta_sampling_rhs(meta, x::AbstractVector{<:AbstractFloat}; group) = begin + meta, p = growblock!!(meta, group, 1) + meta, Base.broadcasted(*, x, p) +end +FBroadcasted{F,Style<:Union{Nothing, Base.Broadcast.BroadcastStyle},Axes} = Base.Broadcast.Broadcasted{Style,Axes,F} +vmeta_sampling_rhs(meta, x::FBroadcasted; group) = begin + meta, p = growblock!!(meta, group, 1) + meta, Base.broadcasted(*, x, p) +end +vmeta_sampling_rhs(meta, x::AbstractVector{<:Integer}; group) = begin + meta, p = growblock!!(meta, group, 1) + meta, Base.broadcasted(*, x, p) + # meta, p = growblock!!(meta, group, length(unique(parent(x)))-1) + # Base.broadcasted(*, x, p) +end +vmeta_sampling_rhs(meta, x::FBroadcasted{<:Type{<:Distribution}}; group) = meta, x +vmaterialize(x) = MaterializedColumn(Base.materialize(x), x) +struct MaterializedColumn{P,B} <: AbstractColumn + parent::P + broadcast::B +end +Base.parent(x::MaterializedColumn) = getfield(x, :parent) +getbroadcast(x::MaterializedColumn) = getfield(x, :broadcast) +Base.broadcastable(x::MaterializedColumn) = Base.broadcastable(parent(x)) + +n_levels(group::NamedColumn) = length(unique(parent(parent(group)))) +growblock!!(meta, group::Symbol, n) = growblock!!(meta, group, 1, n) +growblock!!(meta, group::Symbol, m, n) = begin + g = get(meta.blocks, group) do + ElasticMatrix(zeros(m, 0)) + end + idxs = (size(g, 2)+1):(size(g, 2)+n) + append!(g, zeros(m, n)) + rmerge(meta, (;blocks=(;group=>g))), view(g, :, 1)#idxs) +end +growblock!!(meta, group::NamedColumn, n) = growblock!!(meta, name(group), n_levels(group), n) + +Base.show(io::IO, (;parent, broadcast)::MaterializedColumn) = print(io, eltype(parent), "[...] .= ", broadcast) +Base.show(io::IO, (;parent, rhs)::LikelihoodColumn) = print(io, eltype(parent), "[...] .~ ", rhs) +Base.show(io::IO, vbrm::VBRMI) = begin + (;parent, meta) = vbrm + print(io, parent) + print(io, "dim: ", LogDensityProblems.dimension(vbrm), "\n") + print(io, "materialized:\n") + for (key, value) in pairs(meta.materialized) + print(io, " ", key, ": ", value, "\n") + end + print(io, "blocks (n_levels, n_params):\n") + for (key, value) in pairs(meta.blocks) + print(io, " ", key, ": ", size(value), "\n") + end +end +LogDensityProblems.dimension(vbrm::VBRMI) = hyperdim(vbrm) + directdim(vbrm) +hyperdim(vbrm::VBRMI) = sum(pairs(vbrm.meta.blocks)) do (k, v) + n = size(v, 2) + k == :__population__ ? 0 : n * (n+1) ÷ 2 +end +directdim(vbrm::VBRMI) = sum(length, vbrm.meta.blocks) +advance!!(x, pos) = x[pos+1], pos+1 +advance!!(x, pos, n) = view(x, pos+1:pos+n), pos+n +lprior!((;meta)::VBRMI, x::AbstractVector; init=(0., 0)) = foldl(pairs(meta.blocks); init) do (lprior, pos), (key, values) + m, n = size(values) + if key == :__population__ + xi, pos = advance!!(x, pos, n) + values[1, :] .= xi + lprior += sum(Base.Fix1(logpdf, Normal()), xi) + else + C = LinearAlgebra.Cholesky(meta.block_data[key].L, :L, 0) + lprior, pos = lprior!(C, x; init=(lprior, pos)) + for vi in eachrow(values) + xi, pos = advance!!(x, pos, n) + mul!(vi, C.L, xi) + lprior += sum(Base.Fix1(logpdf, Normal()), xi) + end + end + lprior, pos +end |> first +log_abs_tanh(x) = begin + z = -2*abs(x) + (log1mexp(z) - log1pexp(z)) +end +log_square_tanh(x) = 2 * log_abs_tanh(x) +"Either wrong or better LKJCholesky unconstraining + prior" +lprior!((;L)::Cholesky, x; init, eta=1.) = begin + lprior, pos = init + n = LinearAlgebra.checksquare(L) + log_scale, pos = advance!!(x, pos) + lprior += logpdf(Normal(), log_scale) + L[1, 1] = exp(log_scale) + for i in 2:n + log_scale, pos = advance!!(x, pos) + lprior += logpdf(Normal(), log_scale) + xi, pos = advance!!(x, pos) + tmp = log_abs_tanh(xi / sqrt(n-1)) + L[i, 1] = sign(xi) * exp(log_scale + tmp) + log_sos = 2 * tmp + lprior += log1mexp(log_sos) + for j in 2:i-1 + xi, pos = advance!!(x, pos) + tmp1 = .5 * log1mexp(log_sos) + lprior += tmp1 + tmp2 = log_abs_tanh(xi / sqrt(n-j)) + lprior += log1mexp(2*tmp2) + tmp = tmp1 + tmp2 + L[i, j] = sign(xi) * exp(log_scale + tmp) + log_sos = logaddexp(log_sos, 2*tmp) + end + L[i, i] = exp(log_scale + .5 * log1mexp(log_sos)) + lprior += (n - i + 2*eta-2) * .5 * log1mexp(log_sos) + end + lprior, pos +end +llikelihood!((;meta)::VBRMI) = foldl(meta.materialized; init=0.) do llikelihood, m + llikelihood + llikelihood!(m) +end +llikelihood!(::DataColumn) = 0. +llikelihood!(x::MaterializedColumn) = (Base.materialize!(parent(x), getbroadcast(x)); 0.) +# llikelihood!(x::LikelihoodColumn) = sum(Base.broadcasted(logpdf, rhs(x), parent(x)); init=0.) +# The below is faster for some reason? +llikelihood!(x::LikelihoodColumn) = ssum(Base.broadcasted(logpdf, rhs(x), parent(x)); init=0.) +llikelihood!(x) = error(typeof(x)) + +ssum(args...; kwargs...) = sum(args...; kwargs...) +ssum(x::Base.Broadcast.Broadcasted; init) = begin + rv = init + for xi in x + rv += xi + end + rv +end + +Distributions.logpdf(vbrmi::VBRMI, x::AbstractVector) = lprior!(vbrmi, x) + llikelihood!(vbrmi) +LogDensityProblems.logdensity(vbrmi::VBRMI, x::AbstractVector) = lprior!(vbrmi, x) + llikelihood!(vbrmi) \ No newline at end of file From 31b5d9bf47626359fe875ca327d89d276f1a9dc9 Mon Sep 17 00:00:00 2001 From: Nikolas Siccha Date: Wed, 11 Mar 2026 11:45:25 +0100 Subject: [PATCH 5/7] remove Reactant because it always errors... --- scripts/Benchmarking/Project.toml | 1 - 1 file changed, 1 deletion(-) diff --git a/scripts/Benchmarking/Project.toml b/scripts/Benchmarking/Project.toml index ddcc5ec..529e53a 100644 --- a/scripts/Benchmarking/Project.toml +++ b/scripts/Benchmarking/Project.toml @@ -3,4 +3,3 @@ Chairmarks = "0ca39b1e-fe0b-4e98-acfc-b1656634c4de" DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" -Reactant = "3c362404-f566-11ee-1572-e11a4b42c853" From f873603dd555fd838a57c13304fdcf9bbee56f6a Mon Sep 17 00:00:00 2001 From: Nikolas Siccha Date: Tue, 24 Mar 2026 13:58:59 +0100 Subject: [PATCH 6/7] Add multi-backend benchmark comparing brms/Stan, hand-written Julia, and Turing with gradient performance analysis Co-Authored-By: Claude Sonnet 4.6 --- .gitignore | 1 + scripts/Benchmarking/.CondaPkg/.gitattributes | 2 + scripts/Benchmarking/.CondaPkg/.gitignore | 4 + scripts/Benchmarking/.CondaPkg/pixi.lock | 3197 +++++++++++++++++ scripts/Benchmarking/.CondaPkg/pixi.toml | 18 + scripts/Benchmarking/CondaPkg.toml | 4 + scripts/Benchmarking/Manifest.toml | 2011 +++++++++++ scripts/Benchmarking/Project.toml | 14 + scripts/Benchmarking/README.md | 119 + scripts/Benchmarking/benchmark.jl | 1085 ++++++ .../bambi/escs/drugs_o_c_e_a_n/data.json | 1 + .../bambi/escs/drugs_o_c_e_a_n/model.stan | 43 + .../drugs_o_c_e_a_n/model_loop_inline.stan | 39 + .../model_loop_precompute.stan | 39 + .../bambi/escs/drugs_o_c_e_a_n/model_model.so | Bin 0 -> 864280 bytes scripts/Benchmarking/run_benchmark.jl | 160 + 16 files changed, 6737 insertions(+) create mode 100644 scripts/Benchmarking/.CondaPkg/.gitattributes create mode 100644 scripts/Benchmarking/.CondaPkg/.gitignore create mode 100644 scripts/Benchmarking/.CondaPkg/pixi.lock create mode 100644 scripts/Benchmarking/.CondaPkg/pixi.toml create mode 100644 scripts/Benchmarking/CondaPkg.toml create mode 100644 scripts/Benchmarking/Manifest.toml create mode 100644 scripts/Benchmarking/README.md create mode 100644 scripts/Benchmarking/benchmark.jl create mode 100644 scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/data.json create mode 100644 scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model.stan create mode 100644 scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_loop_inline.stan create mode 100644 scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_loop_precompute.stan create mode 100755 scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_model.so create mode 100644 scripts/Benchmarking/run_benchmark.jl diff --git a/.gitignore b/.gitignore index 25770c7..8682600 100644 --- a/.gitignore +++ b/.gitignore @@ -23,6 +23,7 @@ docs/site/ # environment. Manifest*.toml !scripts/render_env/Manifest.toml +!scripts/Benchmarking/Manifest.toml # File generated by the Preferences package to store local preferences LocalPreferences.toml diff --git a/scripts/Benchmarking/.CondaPkg/.gitattributes b/scripts/Benchmarking/.CondaPkg/.gitattributes new file mode 100644 index 0000000..887a2c1 --- /dev/null +++ b/scripts/Benchmarking/.CondaPkg/.gitattributes @@ -0,0 +1,2 @@ +# SCM syntax highlighting & preventing 3-way merges +pixi.lock merge=binary linguist-language=YAML linguist-generated=true diff --git a/scripts/Benchmarking/.CondaPkg/.gitignore b/scripts/Benchmarking/.CondaPkg/.gitignore new file mode 100644 index 0000000..740bb7d --- /dev/null +++ b/scripts/Benchmarking/.CondaPkg/.gitignore @@ -0,0 +1,4 @@ + +# pixi environments +.pixi +*.egg-info diff --git a/scripts/Benchmarking/.CondaPkg/pixi.lock b/scripts/Benchmarking/.CondaPkg/pixi.lock new file mode 100644 index 0000000..dc28703 --- /dev/null +++ b/scripts/Benchmarking/.CondaPkg/pixi.lock @@ -0,0 +1,3197 @@ +version: 6 +environments: + default: + channels: + - url: https://conda.anaconda.org/conda-forge/ + packages: + linux-64: + - conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-7_kmp_llvm.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.14-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arviz-1.0.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arviz-base-1.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arviz-plots-1.0.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arviz-stats-1.0.0-pyh5442c79_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/arviz-stats-core-1.0.0-pyhc364b38_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-atk-2.38.0-h0630a04_3.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-core-2.40.3-h0630a04_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/atk-1.0-2.38.0-h04ea711_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/bambi-0.15.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.45.1-default_h4852527_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/blas-2.139-blis.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/blas-devel-3.9.0-39_hdec4247_blis.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/blis-0.9.0-h4ab18f5_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.1.0-hb9d3cd8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.1.0-hb9d3cd8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-hbd8a1cb_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cachetools-7.0.5-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.4-h3394656_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cloudpickle-3.1.2-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-13.4.0-h109b0d3_18.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cons-0.4.7-pyhd8ed1ab_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.2-py313h33d0bda_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.28-hd9c7081_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h3c4dab8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.3.1-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/epoxy-1.5.10-h166bdaf_1.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/etuples-0.3.10-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.25.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.15.0-h7e30c49_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.58.5-py313h8060acc_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/formulae-0.6.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.13.3-ha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.10-h36c2ea0_0.tar.bz2 + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.4.0-h0dff253_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.4.0-he2fa53e_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.4.0-h0a5b801_21.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.42.12-hb9ae30d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/glib-tools-2.84.2-h4833e2c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.14-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/graphviz-13.1.0-hcae58fd_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gtk3-3.24.43-h0c6a113_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gts-0.7.6-h977cf35_4.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.4.0-h76987e4_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.4.0-h6a38259_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.4.0-h587059e_21.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-11.2.1-h3beb420_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/hicolor-icon-theme-0.17-ha770c72_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.6.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/jaxlib-0.6.0-cpu_py313h8f0a827_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.4.8-py313h33d0bda_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.17-h717163a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.0.0-h0aef613_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20250127.1-cxx17_hbbce691_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-39_h91f140b_blis.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.1.0-hb9d3cd8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.1.0-hb9d3cd8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.1.0-hb9d3cd8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-39_h3c44731_blis.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp20.1-20.1.7-default_h1df26ce_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-20.1.7-default_he06ed0a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-hb8b1518_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.24-h86f0d12_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.125-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.13.3-ha770c72_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.13.3-h48d6fc4_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-13.4.0-he0feb66_18.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.4.0-hd1d28cc_118.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.4.0-h69a702a_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgd-2.3.3-h6f5c62b_11.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-13.4.0-h69a702a_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.4.0-hd358419_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.84.2-h3618099_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.4.0-he0feb66_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.71.0-h8e591d7_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.2-default_h0d58e46_1001.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-12_hd37a5e2_netlib.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblapacke-3.9.0-12_hce4cc19_netlib.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm20-20.1.7-he9d0ab4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libntlm-1.8-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.50-h943b412_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-17.5-h27ae623_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-5.29.3-h501fc15_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2025.06.26-hba17884_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.58.4-he92a37e_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.4.0-h2a15e64_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h2f26a44_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-13.4.0-h934c35e_18.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.4.0-h6963c3b_118.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.4.0-hdf11a46_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.0-hf01ce69_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.5.0-h851e524_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.10.0-h65c71a3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.13.8-h4bc477f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.43-h7a3aeb2_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-22.1.0-h4922eb0_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/logical-unification-0.4.7-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.0.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.10.3-py313h78bf25f_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.10.3-py313h129903b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/minikanren-1.0.5-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mkl-2024.2.2-ha770c72_17.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/mkl-service-2.5.2-py313hae39701_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.1-py313ha87cce1_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/multipledispatch-0.6.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py313h17eae1a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.3-h5fbd93e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openldap-2.6.10-he970967_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.1-h7b32b05_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.4.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-2.3.0-py313ha87cce1_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.56.4-hadf4263_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.3.0-py313h8db990d_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.46.2-h29eaf8c_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pymc-5.24.1-hd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pymc-base-5.24.1-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.9.1-py313h7dabd7a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pytensor-2.31.6-py313ha6381f5_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/pytensor-base-2.31.6-np2py313hfea535a_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.13.5-hec9711d_102_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-graphviz-0.21-pyhbacfb6d_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2025.3-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.13-8_cp313.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2026.1.post1-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.9.1-h0384650_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2025.06.26-h9925aae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/rich-14.3.3-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py313h86fcf2b_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2021.13.0-hceb3a55_1.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/threadpoolctl-3.6.0-pyhecae5ae_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_ha0e22de_103.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/toolz-1.1.0-pyhd8ed1ab_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.5.1-py313h536fd9c_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.24.0-h3e06ad9_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/xarray-2026.2.0-pyhcf101f3_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/xarray-einstats-0.10.0-pyhd8ed1ab_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-h4f16b4b_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.5-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.45-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.6-he73a12e_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.12-h4f16b4b_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.6-hb9d3cd8_2.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.1-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.2-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h5888daf_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.4-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.6-hb9d3cd8_0.conda + - conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda + - conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda +packages: +- conda: https://conda.anaconda.org/conda-forge/linux-64/_openmp_mutex-4.5-7_kmp_llvm.conda + build_number: 7 + sha256: c0cddb66070dd6355311f7667ce2acccf70d1013edaa6e97f22859502fefdb22 + md5: 887b70e1d607fba7957aa02f9ee0d939 + depends: + - llvm-openmp >=9.0.1 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 8244 + timestamp: 1764092331208 +- conda: https://conda.anaconda.org/conda-forge/noarch/adwaita-icon-theme-49.0-unix_0.conda + sha256: a362b4f5c96a0bf4def96be1a77317e2730af38915eb9bec85e2a92836501ed7 + md5: b3f0179590f3c0637b7eb5309898f79e + depends: + - __unix + - hicolor-icon-theme + - librsvg + license: LGPL-3.0-or-later OR CC-BY-SA-3.0 + license_family: LGPL + size: 631452 + timestamp: 1758743294412 +- conda: https://conda.anaconda.org/conda-forge/linux-64/alsa-lib-1.2.14-hb9d3cd8_0.conda + sha256: b9214bc17e89bf2b691fad50d952b7f029f6148f4ac4fe7c60c08f093efdf745 + md5: 76df83c2a9035c54df5d04ff81bcc02d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + license_family: GPL + size: 566531 + timestamp: 1744668655747 +- conda: https://conda.anaconda.org/conda-forge/noarch/arviz-1.0.0-pyhc364b38_0.conda + sha256: a23a874173bd8006396fe6e8d5a94a88210652fda022836f7819acdc0f735b0a + md5: f443320529c68a2c730d9b52ec70aa4a + depends: + - python >=3.12 + - arviz-base >=1.0.0,<1.1.0 + - arviz-stats >=1.0.0,<1.1.0 + - arviz-plots >=1.0.0,<1.1.0 + - matplotlib >=3.9 + - python + license: Apache-2.0 + license_family: APACHE + size: 20091 + timestamp: 1773850004502 +- conda: https://conda.anaconda.org/conda-forge/noarch/arviz-base-1.0.0-pyhd8ed1ab_0.conda + sha256: 654fae10a2cd0618d52b414b7db9938944d7802f007a8ec6eacc5713462a248f + md5: b409caab0b67edbaedf0350fb6437ff8 + depends: + - numpy >=2 + - python >=3.12 + - typing_extensions >=3.10 + - xarray >=2024.11.0 + license: Apache-2.0 + license_family: Apache + size: 1375527 + timestamp: 1772461322923 +- conda: https://conda.anaconda.org/conda-forge/noarch/arviz-plots-1.0.0-pyhc364b38_0.conda + sha256: e0834eac1c0d2c073e6b9ecc6cd1485add53b9cb349e55c23e1b6e5cf6aa70c6 + md5: 6e3808d41a8db413122c13e92869527d + depends: + - python >=3.12 + - arviz-base >=1.0.0,<1.1.0 + - arviz-stats >=1.0.0,<1.1.0 + - python + license: Apache-2.0 + license_family: APACHE + size: 130116 + timestamp: 1773827817751 +- conda: https://conda.anaconda.org/conda-forge/noarch/arviz-stats-1.0.0-pyh5442c79_0.conda + sha256: b2e594c52ce95e4e77ce19882663889c665a8f39ae6db037947773637c2bc075 + md5: d134120c02d781eb01f14570426e0c54 + depends: + - python >=3.12 + - arviz-stats-core ==1.0.0 pyhc364b38_0 + - arviz-base >=1.0.0,<1.1.0 + - xarray-einstats + - xarray >=2024.11.0 + - python + license: Apache-2.0 + license_family: APACHE + size: 136583 + timestamp: 1773747716818 +- conda: https://conda.anaconda.org/conda-forge/noarch/arviz-stats-core-1.0.0-pyhc364b38_0.conda + sha256: e35092a9e99bcb52784723e07116cab83ae361812cf95004cdc1f499480b7fd7 + md5: 6dbde5213451b7b721a58909e296ac70 + depends: + - python >=3.12 + - numpy >=2 + - scipy >=1.13 + - python + license: Apache-2.0 + license_family: APACHE + size: 136507 + timestamp: 1773747716818 +- conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-atk-2.38.0-h0630a04_3.tar.bz2 + sha256: 26ab9386e80bf196e51ebe005da77d57decf6d989b4f34d96130560bc133479c + md5: 6b889f174df1e0f816276ae69281af4d + depends: + - at-spi2-core >=2.40.0,<2.41.0a0 + - atk-1.0 >=2.36.0 + - dbus >=1.13.6,<2.0a0 + - libgcc-ng >=9.3.0 + - libglib >=2.68.1,<3.0a0 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + license_family: LGPL + size: 339899 + timestamp: 1619122953439 +- conda: https://conda.anaconda.org/conda-forge/linux-64/at-spi2-core-2.40.3-h0630a04_0.tar.bz2 + sha256: c4f9b66bd94c40d8f1ce1fad2d8b46534bdefda0c86e3337b28f6c25779f258d + md5: 8cb2fc4cd6cc63f1369cfa318f581cc3 + depends: + - dbus >=1.13.6,<2.0a0 + - libgcc-ng >=9.3.0 + - libglib >=2.68.3,<3.0a0 + - xorg-libx11 + - xorg-libxi + - xorg-libxtst + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + license_family: LGPL + size: 658390 + timestamp: 1625848454791 +- conda: https://conda.anaconda.org/conda-forge/linux-64/atk-1.0-2.38.0-h04ea711_2.conda + sha256: df682395d05050cd1222740a42a551281210726a67447e5258968dd55854302e + md5: f730d54ba9cd543666d7220c9f7ed563 + depends: + - libgcc-ng >=12 + - libglib >=2.80.0,<3.0a0 + - libstdcxx-ng >=12 + constrains: + - atk-1.0 2.38.0 + arch: x86_64 + platform: linux + license: LGPL-2.0-or-later + license_family: LGPL + size: 355900 + timestamp: 1713896169874 +- conda: https://conda.anaconda.org/conda-forge/noarch/bambi-0.15.0-pyhd8ed1ab_0.conda + sha256: 4739559782aeeff15e990b2be0a662d60b9947e163d290ce30110c061d621a84 + md5: 46301e2722f2cd1f17f51588fff5c2a6 + depends: + - arviz >=0.12.0 + - formulae >=0.5.3 + - numpy >1.22 + - pandas >=1.0.0 + - pymc >=5.18.0 + - pytensor >=2.12.3 + - python >=3.10 + - python-graphviz + - scipy >=1.7.0 + - setuptools >47.1.0 + license: MIT + license_family: MIT + size: 86615 + timestamp: 1734959534579 +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_impl_linux-64-2.45.1-default_hfdba357_102.conda + sha256: 0a7d405064f53b9d91d92515f1460f7906ee5e8523f3cd8973430e81219f4917 + md5: 8165352fdce2d2025bf884dc0ee85700 + depends: + - ld_impl_linux-64 2.45.1 default_hbd61a6d_102 + - sysroot_linux-64 + - zstd >=1.5.7,<1.6.0a0 + arch: x86_64 + platform: linux + license: GPL-3.0-only + size: 3661455 + timestamp: 1774197460085 +- conda: https://conda.anaconda.org/conda-forge/linux-64/binutils_linux-64-2.45.1-default_h4852527_102.conda + sha256: 78a58d523d072b7f8e591b8f8572822e044b31764ed7e8d170392e7bc6d58339 + md5: 2a307a17309d358c9b42afdd3199ddcc + depends: + - binutils_impl_linux-64 2.45.1 default_hfdba357_102 + arch: x86_64 + platform: linux + license: GPL-3.0-only + size: 36304 + timestamp: 1774197485247 +- conda: https://conda.anaconda.org/conda-forge/linux-64/blas-2.139-blis.conda + build_number: 39 + sha256: eb062025cc724a2071c1e3d1b369a1c5dee167be6f99676d1df52cb41fbe905a + md5: 9e1e7138f9aaf95be8c83608d248dc6f + depends: + - blas-devel 3.9.0 39*_blis + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 17437 + timestamp: 1763189507286 +- conda: https://conda.anaconda.org/conda-forge/linux-64/blas-devel-3.9.0-39_hdec4247_blis.conda + build_number: 39 + sha256: 9a65dac01cc1a52723a6590a4a31486cb4e68b2c12133791923801eafd9791f0 + md5: e5d43240309fa5bceb1323209043c05c + depends: + - blis 0.9.0.* + - libblas 3.9.0 39_h91f140b_blis + - libcblas 3.9.0 39_h3c44731_blis + - liblapack 3.9.0 *_netlib + - liblapacke 3.9.0 *_netlib + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 17180 + timestamp: 1763189417006 +- conda: https://conda.anaconda.org/conda-forge/linux-64/blis-0.9.0-h4ab18f5_2.conda + sha256: 3e501cbf98ccb69210e6145d38295dc14ca11417e9c86fec988f06adea8456fd + md5: 6f77ba1352b69c4a6f8a6d20def30e4e + depends: + - libgcc-ng >=12 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 3547115 + timestamp: 1713877874618 +- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-1.1.0-hb9d3cd8_3.conda + sha256: c969baaa5d7a21afb5ed4b8dd830f82b78e425caaa13d717766ed07a61630bec + md5: 5d08a0ac29e6a5a984817584775d4131 + depends: + - __glibc >=2.17,<3.0.a0 + - brotli-bin 1.1.0 hb9d3cd8_3 + - libbrotlidec 1.1.0 hb9d3cd8_3 + - libbrotlienc 1.1.0 hb9d3cd8_3 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 19810 + timestamp: 1749230148642 +- conda: https://conda.anaconda.org/conda-forge/linux-64/brotli-bin-1.1.0-hb9d3cd8_3.conda + sha256: ab74fa8c3d1ca0a055226be89e99d6798c65053e2d2d3c6cb380c574972cd4a7 + md5: 58178ef8ba927229fba6d84abf62c108 + depends: + - __glibc >=2.17,<3.0.a0 + - libbrotlidec 1.1.0 hb9d3cd8_3 + - libbrotlienc 1.1.0 hb9d3cd8_3 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 19390 + timestamp: 1749230137037 +- conda: https://conda.anaconda.org/conda-forge/linux-64/bzip2-1.0.8-h4bc722e_7.conda + sha256: 5ced96500d945fb286c9c838e54fa759aa04a7129c59800f0846b4335cee770d + md5: 62ee74e96c5ebb0af99386de58cf9553 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc-ng >=12 + license: bzip2-1.0.6 + license_family: BSD + size: 252783 + timestamp: 1720974456583 +- conda: https://conda.anaconda.org/conda-forge/linux-64/c-ares-1.34.5-hb9d3cd8_0.conda + sha256: f8003bef369f57396593ccd03d08a8e21966157269426f71e943f96e4b579aeb + md5: f7f0d6cc2dc986d42ac2689ec88192be + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 206884 + timestamp: 1744127994291 +- conda: https://conda.anaconda.org/conda-forge/noarch/ca-certificates-2026.2.25-hbd8a1cb_0.conda + sha256: 67cc7101b36421c5913a1687ef1b99f85b5d6868da3abbf6ec1a4181e79782fc + md5: 4492fd26db29495f0ba23f146cd5638d + depends: + - __unix + license: ISC + size: 147413 + timestamp: 1772006283803 +- conda: https://conda.anaconda.org/conda-forge/noarch/cachetools-7.0.5-pyhd8ed1ab_0.conda + sha256: edfecb626da69607f926f51ad0d24942bfe9f7a29391d55d4ac62403e878605b + md5: a66a1542c3ed584ca4fdb23955d81e91 + depends: + - python >=3.10 + license: MIT + license_family: MIT + size: 19034 + timestamp: 1773120473852 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cairo-1.18.4-h3394656_0.conda + sha256: 3bd6a391ad60e471de76c0e9db34986c4b5058587fbf2efa5a7f54645e28c2c7 + md5: 09262e66b19567aff4f592fb53b28760 + depends: + - __glibc >=2.17,<3.0.a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - freetype >=2.12.1,<3.0a0 + - icu >=75.1,<76.0a0 + - libexpat >=2.6.4,<3.0a0 + - libgcc >=13 + - libglib >=2.82.2,<3.0a0 + - libpng >=1.6.47,<1.7.0a0 + - libstdcxx >=13 + - libxcb >=1.17.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - pixman >=0.44.2,<1.0a0 + - xorg-libice >=1.1.2,<2.0a0 + - xorg-libsm >=1.2.5,<2.0a0 + - xorg-libx11 >=1.8.11,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxrender >=0.9.12,<0.10.0a0 + arch: x86_64 + platform: linux + license: LGPL-2.1-only or MPL-1.1 + size: 978114 + timestamp: 1741554591855 +- conda: https://conda.anaconda.org/conda-forge/noarch/cloudpickle-3.1.2-pyhcf101f3_1.conda + sha256: 4c287c2721d8a34c94928be8fe0e9a85754e90189dd4384a31b1806856b50a67 + md5: 61b8078a0905b12529abc622406cb62c + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + size: 27353 + timestamp: 1765303462831 +- conda: https://conda.anaconda.org/conda-forge/linux-64/conda-gcc-specs-13.4.0-h109b0d3_18.conda + sha256: c941e26b0898c85e5b4fdbc08d55f5b57d30a7008fcabe3a701f9ba008b79e45 + md5: fa7ecb1bad14085f74246ebcca368fec + depends: + - gcc_impl_linux-64 >=13.4.0,<13.4.1.0a0 + arch: x86_64 + platform: linux + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 31538 + timestamp: 1771377555764 +- conda: https://conda.anaconda.org/conda-forge/noarch/cons-0.4.7-pyhd8ed1ab_2.conda + sha256: 2edb605f79d96a2e05bc86bd153c6f03239981f68b25e129429640ebaf316d3b + md5: 31b1db820db9a562fb374ed9339d844c + depends: + - logical-unification >=0.4.0 + - python >=3.9 + license: LGPL-3.0-only + license_family: LGPL + size: 14816 + timestamp: 1752393486187 +- conda: https://conda.anaconda.org/conda-forge/linux-64/contourpy-1.3.2-py313h33d0bda_0.conda + sha256: 8e6e7c9644fa4841909f46b8136b6fad540c9c7b2688bfc15e8f9ce5eef0aabe + md5: 5dc81fffe102f63045225007a33d6199 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - numpy >=1.23 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 278576 + timestamp: 1744743243839 +- conda: https://conda.anaconda.org/conda-forge/noarch/cycler-0.12.1-pyhcf101f3_2.conda + sha256: bb47aec5338695ff8efbddbc669064a3b10fe34ad881fb8ad5d64fbfa6910ed1 + md5: 4c2a8fef270f6c69591889b93f9f55c1 + depends: + - python >=3.10 + - python + license: BSD-3-Clause + license_family: BSD + size: 14778 + timestamp: 1764466758386 +- conda: https://conda.anaconda.org/conda-forge/linux-64/cyrus-sasl-2.1.28-hd9c7081_0.conda + sha256: ee09ad7610c12c7008262d713416d0b58bf365bc38584dce48950025850bdf3f + md5: cae723309a49399d2949362f4ab5c9e4 + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.21.3,<1.22.0a0 + - libgcc >=13 + - libntlm >=1.8,<2.0a0 + - libstdcxx >=13 + - libxcrypt >=4.4.36 + - openssl >=3.5.0,<4.0a0 + arch: x86_64 + platform: linux + license: BSD-3-Clause-Attribution + license_family: BSD + size: 209774 + timestamp: 1750239039316 +- conda: https://conda.anaconda.org/conda-forge/linux-64/dbus-1.16.2-h3c4dab8_0.conda + sha256: 3b988146a50e165f0fa4e839545c679af88e4782ec284cc7b6d07dd226d6a068 + md5: 679616eb5ad4e521c83da4650860aba7 + depends: + - libstdcxx >=13 + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libexpat >=2.7.0,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - libglib >=2.84.2,<3.0a0 + arch: x86_64 + platform: linux + license: GPL-2.0-or-later + license_family: GPL + size: 437860 + timestamp: 1747855126005 +- conda: https://conda.anaconda.org/conda-forge/linux-64/double-conversion-3.3.1-h5888daf_0.conda + sha256: 1bcc132fbcc13f9ad69da7aa87f60ea41de7ed4d09f3a00ff6e0e70e1c690bc2 + md5: bfd56492d8346d669010eccafe0ba058 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 69544 + timestamp: 1739569648873 +- conda: https://conda.anaconda.org/conda-forge/linux-64/epoxy-1.5.10-h166bdaf_1.tar.bz2 + sha256: 1e58ee2ed0f4699be202f23d49b9644b499836230da7dd5b2f63e6766acff89e + md5: a089d06164afd2d511347d3f87214e0b + depends: + - libgcc-ng >=10.3.0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 1440699 + timestamp: 1648505042260 +- conda: https://conda.anaconda.org/conda-forge/noarch/etuples-0.3.10-pyhd8ed1ab_1.conda + sha256: 92b79c5f79eefcee3dc604a96f5546f52bb65329eea043ccb541b692956c8fb5 + md5: 315e9d823f7763da48e072e59bfd0e8e + depends: + - cons + - multipledispatch + - python >=3.9 + license: Apache-2.0 + license_family: APACHE + size: 18084 + timestamp: 1752608449672 +- conda: https://conda.anaconda.org/conda-forge/noarch/filelock-3.25.2-pyhd8ed1ab_0.conda + sha256: dddea9ec53d5e179de82c24569d41198f98db93314f0adae6b15195085d5567f + md5: f58064cec97b12a7136ebb8a6f8a129b + depends: + - python >=3.10 + license: Unlicense + size: 25845 + timestamp: 1773314012590 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-dejavu-sans-mono-2.37-hab24e00_0.tar.bz2 + sha256: 58d7f40d2940dd0a8aa28651239adbf5613254df0f75789919c4e6762054403b + md5: 0c96522c6bdaed4b1566d11387caaf45 + license: BSD-3-Clause + license_family: BSD + size: 397370 + timestamp: 1566932522327 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-inconsolata-3.000-h77eed37_0.tar.bz2 + sha256: c52a29fdac682c20d252facc50f01e7c2e7ceac52aa9817aaf0bb83f7559ec5c + md5: 34893075a5c9e55cdafac56607368fc6 + license: OFL-1.1 + license_family: Other + size: 96530 + timestamp: 1620479909603 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-source-code-pro-2.038-h77eed37_0.tar.bz2 + sha256: 00925c8c055a2275614b4d983e1df637245e19058d79fc7dd1a93b8d9fb4b139 + md5: 4d59c254e01d9cde7957100457e2d5fb + license: OFL-1.1 + license_family: Other + size: 700814 + timestamp: 1620479612257 +- conda: https://conda.anaconda.org/conda-forge/noarch/font-ttf-ubuntu-0.83-h77eed37_3.conda + sha256: 2821ec1dc454bd8b9a31d0ed22a7ce22422c0aef163c59f49dfdf915d0f0ca14 + md5: 49023d73832ef61042f6a237cb2687e7 + license: LicenseRef-Ubuntu-Font-Licence-Version-1.0 + license_family: Other + size: 1620504 + timestamp: 1727511233259 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fontconfig-2.15.0-h7e30c49_1.conda + sha256: 7093aa19d6df5ccb6ca50329ef8510c6acb6b0d8001191909397368b65b02113 + md5: 8f5b0b297b59e1ac160ad4beec99dbee + depends: + - __glibc >=2.17,<3.0.a0 + - freetype >=2.12.1,<3.0a0 + - libexpat >=2.6.3,<3.0a0 + - libgcc >=13 + - libuuid >=2.38.1,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 265599 + timestamp: 1730283881107 +- conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-ecosystem-1-0.tar.bz2 + sha256: a997f2f1921bb9c9d76e6fa2f6b408b7fa549edd349a77639c9fe7a23ea93e61 + md5: fee5683a3f04bd15cbd8318b096a27ab + depends: + - fonts-conda-forge + license: BSD-3-Clause + license_family: BSD + size: 3667 + timestamp: 1566974674465 +- conda: https://conda.anaconda.org/conda-forge/noarch/fonts-conda-forge-1-hc364b38_1.conda + sha256: 54eea8469786bc2291cc40bca5f46438d3e062a399e8f53f013b6a9f50e98333 + md5: a7970cd949a077b7cb9696379d338681 + depends: + - font-ttf-ubuntu + - font-ttf-inconsolata + - font-ttf-dejavu-sans-mono + - font-ttf-source-code-pro + license: BSD-3-Clause + license_family: BSD + size: 4059 + timestamp: 1762351264405 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fonttools-4.58.5-py313h8060acc_0.conda + sha256: 30a61fd3c6aa8b38a0ef123b893daa4cb3bcee3c9d6386f583bab79fc2bdbe43 + md5: c078f338a3e09800a3b621b1942ba5b5 + depends: + - __glibc >=2.17,<3.0.a0 + - brotli + - libgcc >=13 + - munkres + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 2852512 + timestamp: 1751573485242 +- conda: https://conda.anaconda.org/conda-forge/noarch/formulae-0.6.2-pyhd8ed1ab_0.conda + sha256: 7cde6877045cf03b6cfd39238ecdcd4072dfb45d743140237c21e4fa0c942fe2 + md5: 6a991241077b421e7cd632ddd0981cc2 + depends: + - numpy >=1.16 + - packaging + - pandas >=1.0.0 + - python >=3.10 + - scipy >=1.5.4 + license: MIT + license_family: MIT + size: 48655 + timestamp: 1770399957184 +- conda: https://conda.anaconda.org/conda-forge/linux-64/freetype-2.13.3-ha770c72_1.conda + sha256: 7ef7d477c43c12a5b4cddcf048a83277414512d1116aba62ebadfa7056a7d84f + md5: 9ccd736d31e0c6e41f54e704e5312811 + depends: + - libfreetype 2.13.3 ha770c72_1 + - libfreetype6 2.13.3 h48d6fc4_1 + arch: x86_64 + platform: linux + license: GPL-2.0-only OR FTL + size: 172450 + timestamp: 1745369996765 +- conda: https://conda.anaconda.org/conda-forge/linux-64/fribidi-1.0.10-h36c2ea0_0.tar.bz2 + sha256: 5d7b6c0ee7743ba41399e9e05a58ccc1cfc903942e49ff6f677f6e423ea7a627 + md5: ac7bc6a654f8f41b352b38f4051135f8 + depends: + - libgcc-ng >=7.5.0 + arch: x86_64 + platform: linux + license: LGPL-2.1 + size: 114383 + timestamp: 1604416621168 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc-13.4.0-h0dff253_18.conda + sha256: 3eaad231033739335f2b0dfebd000b2203891f198082d774a6fe8f3cbef6a81c + md5: 39a519bbdc9c56d4790d7f15f2da4cd7 + depends: + - conda-gcc-specs + - gcc_impl_linux-64 13.4.0 he2fa53e_18 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 29388 + timestamp: 1771377704762 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_impl_linux-64-13.4.0-he2fa53e_18.conda + sha256: a72fc88869a522547c33aa80f8e9ab9a925636f074c3688be561b36a30504dd0 + md5: 1a034b3bff9d06e2858ad7afbc3089f4 + depends: + - binutils_impl_linux-64 >=2.45 + - libgcc >=13.4.0 + - libgcc-devel_linux-64 13.4.0 hd1d28cc_118 + - libgomp >=13.4.0 + - libsanitizer 13.4.0 h2a15e64_18 + - libstdcxx >=13.4.0 + - libstdcxx-devel_linux-64 13.4.0 h6963c3b_118 + - sysroot_linux-64 + arch: x86_64 + platform: linux + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 70043430 + timestamp: 1771377466052 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gcc_linux-64-13.4.0-h0a5b801_21.conda + sha256: 52679edb80e5dc0ad4eeedb55170fc39b2fb44850b613f18474ab69a7d5f1161 + md5: b3d6552b131695f0104a81e56f09af08 + depends: + - gcc_impl_linux-64 13.4.0.* + - binutils_linux-64 + - sysroot_linux-64 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 28950 + timestamp: 1770908248344 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gdk-pixbuf-2.42.12-hb9ae30d_0.conda + sha256: d5283b95a8d49dcd88d29b360d8b38694aaa905d968d156d72ab71d32b38facb + md5: 201db6c2d9a3c5e46573ac4cb2e92f4f + depends: + - libgcc-ng >=12 + - libglib >=2.80.2,<3.0a0 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libpng >=1.6.43,<1.7.0a0 + - libtiff >=4.6.0,<4.8.0a0 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + license_family: LGPL + size: 528149 + timestamp: 1715782983957 +- conda: https://conda.anaconda.org/conda-forge/linux-64/glib-tools-2.84.2-h4833e2c_0.conda + sha256: eee7655422577df78386513322ea2aa691e7638947584faa715a20488ef6cc4e + md5: f2ec1facec64147850b7674633978050 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libglib 2.84.2 h3618099_0 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + size: 116819 + timestamp: 1747836718327 +- conda: https://conda.anaconda.org/conda-forge/linux-64/graphite2-1.3.14-h5888daf_0.conda + sha256: cac69f3ff7756912bbed4c28363de94f545856b35033c0b86193366b95f5317d + md5: 951ff8d9e5536896408e89d63230b8d5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + arch: x86_64 + platform: linux + license: LGPL-2.0-or-later + license_family: LGPL + size: 98419 + timestamp: 1750079957535 +- conda: https://conda.anaconda.org/conda-forge/linux-64/graphviz-13.1.0-hcae58fd_0.conda + sha256: 692f544be3868c590b4db177d39c552e3eeb1631f66a10f5b27982a0e1b0c984 + md5: aa7e2fbfb1f5878d6cee930c43af2200 + depends: + - __glibc >=2.17,<3.0.a0 + - adwaita-icon-theme + - cairo >=1.18.4,<2.0a0 + - fonts-conda-ecosystem + - gdk-pixbuf >=2.42.12,<3.0a0 + - gtk3 >=3.24.43,<4.0a0 + - gts >=0.7.6,<0.8.0a0 + - libexpat >=2.7.0,<3.0a0 + - libgcc >=13 + - libgd >=2.3.3,<2.4.0a0 + - libglib >=2.84.2,<3.0a0 + - librsvg >=2.58.4,<3.0a0 + - libstdcxx >=13 + - libwebp-base >=1.5.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - pango >=1.56.4,<2.0a0 + arch: x86_64 + platform: linux + license: EPL-1.0 + license_family: Other + size: 2426873 + timestamp: 1751389810326 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gtk3-3.24.43-h0c6a113_5.conda + sha256: d36263cbcbce34ec463ce92bd72efa198b55d987959eab6210cc256a0e79573b + md5: 67d00e9cfe751cfe581726c5eff7c184 + depends: + - __glibc >=2.17,<3.0.a0 + - at-spi2-atk >=2.38.0,<3.0a0 + - atk-1.0 >=2.38.0 + - cairo >=1.18.4,<2.0a0 + - epoxy >=1.5.10,<1.6.0a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - fribidi >=1.0.10,<2.0a0 + - gdk-pixbuf >=2.42.12,<3.0a0 + - glib-tools + - harfbuzz >=11.0.0,<12.0a0 + - hicolor-icon-theme + - libcups >=2.3.3,<2.4.0a0 + - libcups >=2.3.3,<3.0a0 + - libexpat >=2.6.4,<3.0a0 + - libgcc >=13 + - libglib >=2.84.0,<3.0a0 + - liblzma >=5.6.4,<6.0a0 + - libxkbcommon >=1.8.1,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - pango >=1.56.3,<2.0a0 + - wayland >=1.23.1,<2.0a0 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxcomposite >=0.4.6,<1.0a0 + - xorg-libxcursor >=1.2.3,<2.0a0 + - xorg-libxdamage >=1.1.6,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + - xorg-libxi >=1.8.2,<2.0a0 + - xorg-libxinerama >=1.1.5,<1.2.0a0 + - xorg-libxrandr >=1.5.4,<2.0a0 + - xorg-libxrender >=0.9.12,<0.10.0a0 + arch: x86_64 + platform: linux + license: LGPL-2.0-or-later + license_family: LGPL + size: 5585389 + timestamp: 1743405684985 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gts-0.7.6-h977cf35_4.conda + sha256: b5cd16262fefb836f69dc26d879b6508d29f8a5c5948a966c47fe99e2e19c99b + md5: 4d8df0b0db060d33c9a702ada998a8fe + depends: + - libgcc-ng >=12 + - libglib >=2.76.3,<3.0a0 + - libstdcxx-ng >=12 + arch: x86_64 + platform: linux + license: LGPL-2.0-or-later + license_family: LGPL + size: 318312 + timestamp: 1686545244763 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx-13.4.0-h76987e4_18.conda + sha256: 8c876de9409991e197eb6d723fc502a88012f60da38612166c403794392edc74 + md5: 7713811d62bfe17c9ba66136ce9abd01 + depends: + - gcc 13.4.0 h0dff253_18 + - gxx_impl_linux-64 13.4.0 h6a38259_18 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 28838 + timestamp: 1771377738188 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_impl_linux-64-13.4.0-h6a38259_18.conda + sha256: 95676e274926fe9081205661db1a87169d9cf487bdb17072a63c1d907dfe7f8f + md5: 39904d74f923c52a10700e5804920932 + depends: + - gcc_impl_linux-64 13.4.0 he2fa53e_18 + - libstdcxx-devel_linux-64 13.4.0 h6963c3b_118 + - sysroot_linux-64 + - tzdata + arch: x86_64 + platform: linux + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 13997423 + timestamp: 1771377656949 +- conda: https://conda.anaconda.org/conda-forge/linux-64/gxx_linux-64-13.4.0-h587059e_21.conda + sha256: 39ba0fbe004490fe9efcfa360f092f272e4e89ff8246d04587d7c5218edc9e6e + md5: b3b53c1b7730cc5cb21994002fa6d768 + depends: + - gxx_impl_linux-64 13.4.0.* + - gcc_linux-64 ==13.4.0 h0a5b801_21 + - binutils_linux-64 + - sysroot_linux-64 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 27485 + timestamp: 1770908248348 +- conda: https://conda.anaconda.org/conda-forge/linux-64/harfbuzz-11.2.1-h3beb420_0.conda + sha256: 5bd0f3674808862838d6e2efc0b3075e561c34309c5c2f4c976f7f1f57c91112 + md5: 0e6e192d4b3d95708ad192d957cf3163 + depends: + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.4,<2.0a0 + - freetype + - graphite2 + - icu >=75.1,<76.0a0 + - libexpat >=2.7.0,<3.0a0 + - libfreetype >=2.13.3 + - libfreetype6 >=2.13.3 + - libgcc >=13 + - libglib >=2.84.1,<3.0a0 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 1730226 + timestamp: 1747091044218 +- conda: https://conda.anaconda.org/conda-forge/linux-64/hicolor-icon-theme-0.17-ha770c72_3.conda + sha256: 6d7e6e1286cb521059fe69696705100a03b006efb914ffe82a2ae97ecbae66b7 + md5: 129e404c5b001f3ef5581316971e3ea0 + arch: x86_64 + platform: linux + license: GPL-2.0-or-later + license_family: GPL + size: 17625 + timestamp: 1771539597968 +- conda: https://conda.anaconda.org/conda-forge/linux-64/icu-75.1-he02047a_0.conda + sha256: 71e750d509f5fa3421087ba88ef9a7b9be11c53174af3aa4d06aff4c18b38e8e + md5: 8b189310083baabfb622af68fd9d3ae3 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + license: MIT + license_family: MIT + size: 12129203 + timestamp: 1720853576813 +- conda: https://conda.anaconda.org/conda-forge/noarch/importlib-metadata-8.8.0-pyhcf101f3_0.conda + sha256: 82ab2a0d91ca1e7e63ab6a4939356667ef683905dea631bc2121aa534d347b16 + md5: 080594bf4493e6bae2607e65390c520a + depends: + - python >=3.10 + - zipp >=3.20 + - python + license: Apache-2.0 + license_family: APACHE + size: 34387 + timestamp: 1773931568510 +- conda: https://conda.anaconda.org/conda-forge/noarch/jax-0.6.0-pyhd8ed1ab_0.conda + sha256: 573a5582dfba84a8f67c351b6218cb9579cb8d0f6d4b4186a806852111d4a6f1 + md5: bd364feb12c744cf5c60e1e5b586171b + depends: + - importlib-metadata >=4.6 + - jaxlib >=0.6.0,<=0.6.0 + - ml_dtypes >=0.5.0 + - numpy >=1.25 + - opt_einsum + - python >=3.10 + - scipy >=1.11.1 + constrains: + - cudnn >=9.8,<10.0 + license: Apache-2.0 + license_family: APACHE + size: 1538293 + timestamp: 1748688029463 +- conda: https://conda.anaconda.org/conda-forge/linux-64/jaxlib-0.6.0-cpu_py313h8f0a827_0.conda + sha256: bd6abb44e16ef94bad40a554ab6c23becca05093250d58f62f90c72cddddf5d6 + md5: a581353603f02b9c5b07da446b01b4b3 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20250127.1,<20250128.0a0 + - libgcc >=13 + - libgrpc >=1.71.0,<1.72.0a0 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - ml_dtypes >=0.2.0 + - numpy >=1.21,<3 + - openssl >=3.5.0,<4.0a0 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + - scipy >=1.9 + constrains: + - jax >=0.6.0 + arch: x86_64 + platform: linux + license: Apache-2.0 + license_family: APACHE + size: 60644089 + timestamp: 1748673286014 +- conda: https://conda.anaconda.org/conda-forge/noarch/kernel-headers_linux-64-3.10.0-he073ed8_18.conda + sha256: a922841ad80bd7b222502e65c07ecb67e4176c4fa5b03678a005f39fcc98be4b + md5: ad8527bf134a90e1c9ed35fa0b64318c + constrains: + - sysroot_linux-64 ==2.17 + license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0 + license_family: GPL + size: 943486 + timestamp: 1729794504440 +- conda: https://conda.anaconda.org/conda-forge/linux-64/keyutils-1.6.3-hb9d3cd8_0.conda + sha256: 0960d06048a7185d3542d850986d807c6e37ca2e644342dd0c72feefcf26c2a4 + md5: b38117a3c920364aff79f870c984b4a3 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + size: 134088 + timestamp: 1754905959823 +- conda: https://conda.anaconda.org/conda-forge/linux-64/kiwisolver-1.4.8-py313h33d0bda_1.conda + sha256: 59099e42c46c08b0a59e179cc845ae9fb181316cc018d0fc58560370467af419 + md5: 6d8d806d9db877ace75ca67aa572bf84 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 72112 + timestamp: 1751494043915 +- conda: https://conda.anaconda.org/conda-forge/linux-64/krb5-1.21.3-h659f571_0.conda + sha256: 99df692f7a8a5c27cd14b5fb1374ee55e756631b9c3d659ed3ee60830249b238 + md5: 3f43953b7d3fb3aaa1d0d0723d91e368 + depends: + - keyutils >=1.6.1,<2.0a0 + - libedit >=3.1.20191231,<3.2.0a0 + - libedit >=3.1.20191231,<4.0a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + - openssl >=3.3.1,<4.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 1370023 + timestamp: 1719463201255 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lcms2-2.17-h717163a_0.conda + sha256: d6a61830a354da022eae93fa896d0991385a875c6bba53c82263a289deda9db8 + md5: 000e85703f0fd9594c81710dd5066471 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libtiff >=4.7.0,<4.8.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 248046 + timestamp: 1739160907615 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ld_impl_linux-64-2.45.1-default_hbd61a6d_102.conda + sha256: 3d584956604909ff5df353767f3a2a2f60e07d070b328d109f30ac40cd62df6c + md5: 18335a698559cdbcd86150a48bf54ba6 + depends: + - __glibc >=2.17,<3.0.a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - binutils_impl_linux-64 2.45.1 + license: GPL-3.0-only + size: 728002 + timestamp: 1774197446916 +- conda: https://conda.anaconda.org/conda-forge/linux-64/lerc-4.0.0-h0aef613_1.conda + sha256: 412381a43d5ff9bbed82cd52a0bbca5b90623f62e41007c9c42d3870c60945ff + md5: 9344155d33912347b37f0ae6c410a835 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + arch: x86_64 + platform: linux + license: Apache-2.0 + license_family: Apache + size: 264243 + timestamp: 1745264221534 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libabseil-20250127.1-cxx17_hbbce691_0.conda + sha256: 65d5ca837c3ee67b9d769125c21dc857194d7f6181bb0e7bd98ae58597b457d0 + md5: 00290e549c5c8a32cc271020acc9ec6b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + constrains: + - abseil-cpp =20250127.1 + - libabseil-static =20250127.1=cxx17* + arch: x86_64 + platform: linux + license: Apache-2.0 + license_family: Apache + size: 1325007 + timestamp: 1742369558286 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libblas-3.9.0-39_h91f140b_blis.conda + build_number: 39 + sha256: 2b4a385edd7a7b17f64ed8592076aa5d70e4ed41a2cb3ce5e5a4296113021724 + md5: 98ed9181bd96e524785d28c55654dc84 + depends: + - blis >=0.9.0,<0.9.1.0a0 + constrains: + - mkl <2026 + - libcblas 3.9.0 39*_blis + - blas 2.139 blis + arch: x86_64 + platform: linux + track_features: + - blas_blis + - blas_blis_2 + license: BSD-3-Clause + license_family: BSD + size: 17506 + timestamp: 1763189402494 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlicommon-1.1.0-hb9d3cd8_3.conda + sha256: 462a8ed6a7bb9c5af829ec4b90aab322f8bcd9d8987f793e6986ea873bbd05cf + md5: cb98af5db26e3f482bebb80ce9d947d3 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 69233 + timestamp: 1749230099545 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlidec-1.1.0-hb9d3cd8_3.conda + sha256: 3eb27c1a589cbfd83731be7c3f19d6d679c7a444c3ba19db6ad8bf49172f3d83 + md5: 1c6eecffad553bde44c5238770cfb7da + depends: + - __glibc >=2.17,<3.0.a0 + - libbrotlicommon 1.1.0 hb9d3cd8_3 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 33148 + timestamp: 1749230111397 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libbrotlienc-1.1.0-hb9d3cd8_3.conda + sha256: 76e8492b0b0a0d222bfd6081cae30612aa9915e4309396fdca936528ccf314b7 + md5: 3facafe58f3858eb95527c7d3a3fc578 + depends: + - __glibc >=2.17,<3.0.a0 + - libbrotlicommon 1.1.0 hb9d3cd8_3 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 282657 + timestamp: 1749230124839 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcblas-3.9.0-39_h3c44731_blis.conda + build_number: 39 + sha256: 61be251bf2a7e29c886346807d555949be4f14d651e726caccb44cc6aed569d9 + md5: 76f8aa56374c04b9c80f5b11276c1081 + depends: + - libblas 3.9.0 39_h91f140b_blis + constrains: + - blas 2.139 blis + arch: x86_64 + platform: linux + track_features: + - blas_blis + license: BSD-3-Clause + license_family: BSD + size: 17490 + timestamp: 1763189409817 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang-cpp20.1-20.1.7-default_h1df26ce_0.conda + sha256: 4194c75a91a9c790cbe96c3c33fc2f388274d1be85ec884ce7c88d7e8f9d96f2 + md5: f9ef7bce54a7673cdbc2fadd8bca1956 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libllvm20 >=20.1.7,<20.2.0a0 + - libstdcxx >=13 + arch: x86_64 + platform: linux + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 20925717 + timestamp: 1749876303353 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libclang13-20.1.7-default_he06ed0a_0.conda + sha256: 6541d19a1659062dbf8823d6a1206e28f788369bcf7af9171d7c9069c1d35932 + md5: 846875a174de6b6ff19e205a7d90eb74 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libllvm20 >=20.1.7,<20.2.0a0 + - libstdcxx >=13 + arch: x86_64 + platform: linux + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 12116245 + timestamp: 1749876520951 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libcups-2.3.3-hb8b1518_5.conda + sha256: cb83980c57e311783ee831832eb2c20ecb41e7dee6e86e8b70b8cef0e43eab55 + md5: d4a250da4737ee127fb1fa6452a9002e + depends: + - __glibc >=2.17,<3.0.a0 + - krb5 >=1.21.3,<1.22.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: Apache-2.0 + license_family: Apache + size: 4523621 + timestamp: 1749905341688 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libdeflate-1.24-h86f0d12_0.conda + sha256: 8420748ea1cc5f18ecc5068b4f24c7a023cc9b20971c99c824ba10641fb95ddf + md5: 64f0c503da58ec25ebd359e4d990afa8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 72573 + timestamp: 1747040452262 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libdrm-2.4.125-hb9d3cd8_0.conda + sha256: f53458db897b93b4a81a6dbfd7915ed8fa4a54951f97c698dde6faa028aadfd2 + md5: 4c0ab57463117fbb8df85268415082f5 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libpciaccess >=0.18,<0.19.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 246161 + timestamp: 1749904704373 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libedit-3.1.20250104-pl5321h7949ede_0.conda + sha256: d789471216e7aba3c184cd054ed61ce3f6dac6f87a50ec69291b9297f8c18724 + md5: c277e0a4d549b03ac1e9d6cbbe3d017b + depends: + - ncurses + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - ncurses >=6.5,<7.0a0 + arch: x86_64 + platform: linux + license: BSD-2-Clause + license_family: BSD + size: 134676 + timestamp: 1738479519902 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libegl-1.7.0-ha4b6fd6_2.conda + sha256: 7fd5408d359d05a969133e47af580183fbf38e2235b562193d427bb9dad79723 + md5: c151d5eb730e9b7480e6d48c0fc44048 + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + arch: x86_64 + platform: linux + license: LicenseRef-libglvnd + size: 44840 + timestamp: 1731330973553 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libexpat-2.7.0-h5888daf_0.conda + sha256: 33ab03438aee65d6aa667cf7d90c91e5e7d734c19a67aa4c7040742c0a13d505 + md5: db0bfbe7dd197b68ad5f30333bae6ce0 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + constrains: + - expat 2.7.0.* + license: MIT + license_family: MIT + size: 74427 + timestamp: 1743431794976 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libffi-3.4.6-h2dba641_1.conda + sha256: 764432d32db45466e87f10621db5b74363a9f847d2b8b1f9743746cd160f06ab + md5: ede4673863426c0883c0063d853bbd85 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: MIT + license_family: MIT + size: 57433 + timestamp: 1743434498161 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype-2.13.3-ha770c72_1.conda + sha256: 7be9b3dac469fe3c6146ff24398b685804dfc7a1de37607b84abd076f57cc115 + md5: 51f5be229d83ecd401fb369ab96ae669 + depends: + - libfreetype6 >=2.13.3 + arch: x86_64 + platform: linux + license: GPL-2.0-only OR FTL + size: 7693 + timestamp: 1745369988361 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libfreetype6-2.13.3-h48d6fc4_1.conda + sha256: 7759bd5c31efe5fbc36a7a1f8ca5244c2eabdbeb8fc1bee4b99cf989f35c7d81 + md5: 3c255be50a506c50765a93a6644f32fe + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libpng >=1.6.47,<1.7.0a0 + - libzlib >=1.3.1,<2.0a0 + constrains: + - freetype >=2.13.3 + arch: x86_64 + platform: linux + license: GPL-2.0-only OR FTL + size: 380134 + timestamp: 1745369987697 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-13.4.0-he0feb66_18.conda + sha256: bcac86c9572eaeeadd195b581de8e6d80d0ad8ef3f93bd92b3bdbc749df7f7e7 + md5: d58c699e1f2f7c970993cb5fb55e1176 + depends: + - __glibc >=2.17,<3.0.a0 + - _openmp_mutex >=4.5 + constrains: + - libgcc-ng ==13.4.0=*_18 + - libgomp 13.4.0 he0feb66_18 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 963844 + timestamp: 1771377326189 +- conda: https://conda.anaconda.org/conda-forge/noarch/libgcc-devel_linux-64-13.4.0-hd1d28cc_118.conda + sha256: 2f4150691400ec130ffebca96f375224ed47e062f3ab4adecec4acd79463357b + md5: 1012081c5cc2806ba38bf580ca5aa3f5 + depends: + - __unix + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 2844236 + timestamp: 1771377215473 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgcc-ng-13.4.0-h69a702a_18.conda + sha256: d99f2ffcda58d102499a34f49abca4c4141af1664700ce080389d17f0b2b3470 + md5: d8af48019e5caafa6833d2407cdc6c23 + depends: + - libgcc 13.4.0 he0feb66_18 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 27595 + timestamp: 1771377337906 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgd-2.3.3-h6f5c62b_11.conda + sha256: 19e5be91445db119152217e8e8eec4fd0499d854acc7d8062044fb55a70971cd + md5: 68fc66282364981589ef36868b1a7c78 + depends: + - __glibc >=2.17,<3.0.a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - freetype >=2.12.1,<3.0a0 + - icu >=75.1,<76.0a0 + - libexpat >=2.6.4,<3.0a0 + - libgcc >=13 + - libjpeg-turbo >=3.0.0,<4.0a0 + - libpng >=1.6.45,<1.7.0a0 + - libtiff >=4.7.0,<4.8.0a0 + - libwebp-base >=1.5.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: GD + license_family: BSD + size: 177082 + timestamp: 1737548051015 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran-13.4.0-h69a702a_18.conda + sha256: ca3b27235017f7f61780a238e65ee1a037f9a6620498373f5bdf91acae5036aa + md5: c8300f67c6e500482d5f307d5ad63565 + depends: + - libgfortran5 13.4.0 hd358419_18 + constrains: + - libgfortran-ng ==13.4.0=*_18 + arch: x86_64 + platform: linux + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 27550 + timestamp: 1771377381328 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgfortran5-13.4.0-hd358419_18.conda + sha256: ef8f64676c1024215b3ef16c9ca465d82afb82f615cc4612db87ece8f079bd71 + md5: 0f406de88b4f504f251ce6db5e7bc6c9 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13.4.0 + constrains: + - libgfortran 13.4.0 + arch: x86_64 + platform: linux + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 2288147 + timestamp: 1771377353553 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgl-1.7.0-ha4b6fd6_2.conda + sha256: dc2752241fa3d9e40ce552c1942d0a4b5eeb93740c9723873f6fcf8d39ef8d2d + md5: 928b8be80851f5d8ffb016f9c81dae7a + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + - libglx 1.7.0 ha4b6fd6_2 + arch: x86_64 + platform: linux + license: LicenseRef-libglvnd + size: 134712 + timestamp: 1731330998354 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglib-2.84.2-h3618099_0.conda + sha256: a6b5cf4d443044bc9a0293dd12ca2015f0ebe5edfdc9c4abdde0b9947f9eb7bd + md5: 072ab14a02164b7c0c089055368ff776 + depends: + - __glibc >=2.17,<3.0.a0 + - libffi >=3.4.6,<3.5.0a0 + - libgcc >=13 + - libiconv >=1.18,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - pcre2 >=10.45,<10.46.0a0 + constrains: + - glib 2.84.2 *_0 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + size: 3955066 + timestamp: 1747836671118 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglvnd-1.7.0-ha4b6fd6_2.conda + sha256: 1175f8a7a0c68b7f81962699751bb6574e6f07db4c9f72825f978e3016f46850 + md5: 434ca7e50e40f4918ab701e3facd59a0 + depends: + - __glibc >=2.17,<3.0.a0 + arch: x86_64 + platform: linux + license: LicenseRef-libglvnd + size: 132463 + timestamp: 1731330968309 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libglx-1.7.0-ha4b6fd6_2.conda + sha256: 2d35a679624a93ce5b3e9dd301fff92343db609b79f0363e6d0ceb3a6478bfa7 + md5: c8013e438185f33b13814c5c488acd5c + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + - xorg-libx11 >=1.8.10,<2.0a0 + arch: x86_64 + platform: linux + license: LicenseRef-libglvnd + size: 75504 + timestamp: 1731330988898 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgomp-13.4.0-he0feb66_18.conda + sha256: 286dedfdbd1485803dbcfc74375f577d2f20c82a79336d634558a1846c8d2b22 + md5: 6283a076677d95a7dae5bc16e9484e20 + depends: + - __glibc >=2.17,<3.0.a0 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 566914 + timestamp: 1771377233364 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libgrpc-1.71.0-h8e591d7_1.conda + sha256: 37267300b25f292a6024d7fd9331085fe4943897940263c3a41d6493283b2a18 + md5: c3cfd72cbb14113abee7bbd86f44ad69 + depends: + - __glibc >=2.17,<3.0.a0 + - c-ares >=1.34.5,<2.0a0 + - libabseil * cxx17* + - libabseil >=20250127.1,<20250128.0a0 + - libgcc >=13 + - libprotobuf >=5.29.3,<5.29.4.0a0 + - libre2-11 >=2024.7.2 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.0,<4.0a0 + - re2 + constrains: + - grpc-cpp =1.71.0 + arch: x86_64 + platform: linux + license: Apache-2.0 + license_family: APACHE + size: 7920187 + timestamp: 1745229332239 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libhwloc-2.11.2-default_h0d58e46_1001.conda + sha256: d14c016482e1409ae1c50109a9ff933460a50940d2682e745ab1c172b5282a69 + md5: 804ca9e91bcaea0824a341d55b1684f2 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - libxml2 >=2.13.4,<2.14.0a0 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 2423200 + timestamp: 1731374922090 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libiconv-1.18-h4ce23a2_1.conda + sha256: 18a4afe14f731bfb9cf388659994263904d20111e42f841e9eea1bb6f91f4ab4 + md5: e796ff8ddc598affdf7c173d6145f087 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: LGPL-2.1-only + size: 713084 + timestamp: 1740128065462 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libjpeg-turbo-3.1.0-hb9d3cd8_0.conda + sha256: 98b399287e27768bf79d48faba8a99a2289748c65cd342ca21033fab1860d4a4 + md5: 9fa334557db9f63da6c9285fd2a48638 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + constrains: + - jpeg <0.0.0a + arch: x86_64 + platform: linux + license: IJG AND BSD-3-Clause AND Zlib + size: 628947 + timestamp: 1745268527144 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblapack-3.9.0-12_hd37a5e2_netlib.conda + build_number: 12 + sha256: 31e122ada73c23cb2c3bb75b66b6810dc8d22abfa3650b66de2f78fe03322e07 + md5: 4b181b55915cefcd35c8398c9274e629 + depends: + - __glibc >=2.17,<3.0.a0 + - libblas 3.9.0.* + - libgcc >=13 + - libgfortran + - libgfortran5 >=13.3.0 + constrains: + - mkl <2025 + arch: x86_64 + platform: linux + track_features: + - blas_netlib + - blas_netlib_2 + license: BSD-3-Clause + license_family: BSD + size: 2780544 + timestamp: 1745846571197 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblapacke-3.9.0-12_hce4cc19_netlib.conda + build_number: 12 + sha256: 835845c91862d0c81d958e89060723e57ba25809335277ae4e2dcf07d3a80659 + md5: bdcf65db13abdddba7af29592f93600b + depends: + - __glibc >=2.17,<3.0.a0 + - libblas 3.9.0.* + - libcblas 3.9.0.* + - libgcc >=13 + - libgfortran + - libgfortran5 >=13.3.0 + - liblapack 3.9.0.* + constrains: + - mkl <2025 + arch: x86_64 + platform: linux + track_features: + - blas_netlib + - blas_netlib_2 + license: BSD-3-Clause + license_family: BSD + size: 495776 + timestamp: 1745846582522 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libllvm20-20.1.7-he9d0ab4_0.conda + sha256: 5c51416c10e84ac6a73560c82e20f99788b1395ce431c450391966d07a444fa6 + md5: 63f1accca4913e6b66a2d546c30ff4db + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - libxml2 >=2.13.8,<2.14.0a0 + - libzlib >=1.3.1,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + arch: x86_64 + platform: linux + license: Apache-2.0 WITH LLVM-exception + license_family: Apache + size: 43026762 + timestamp: 1749836200754 +- conda: https://conda.anaconda.org/conda-forge/linux-64/liblzma-5.8.1-hb9d3cd8_2.conda + sha256: f2591c0069447bbe28d4d696b7fcb0c5bd0b4ac582769b89addbcf26fb3430d8 + md5: 1a580f7796c7bf6393fddb8bbbde58dc + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + constrains: + - xz 5.8.1.* + license: 0BSD + size: 112894 + timestamp: 1749230047870 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libmpdec-4.0.0-hb9d3cd8_0.conda + sha256: 3aa92d4074d4063f2a162cd8ecb45dccac93e543e565c01a787e16a43501f7ee + md5: c7e925f37e3b40d893459e625f6a53f1 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: BSD-2-Clause + license_family: BSD + size: 91183 + timestamp: 1748393666725 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libntlm-1.8-hb9d3cd8_0.conda + sha256: 3b3f19ced060013c2dd99d9d46403be6d319d4601814c772a3472fe2955612b0 + md5: 7c7927b404672409d9917d49bff5f2d6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + size: 33418 + timestamp: 1734670021371 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libopengl-1.7.0-ha4b6fd6_2.conda + sha256: 215086c108d80349e96051ad14131b751d17af3ed2cb5a34edd62fa89bfe8ead + md5: 7df50d44d4a14d6c31a2c54f2cd92157 + depends: + - __glibc >=2.17,<3.0.a0 + - libglvnd 1.7.0 ha4b6fd6_2 + arch: x86_64 + platform: linux + license: LicenseRef-libglvnd + size: 50757 + timestamp: 1731330993524 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpciaccess-0.18-hb9d3cd8_0.conda + sha256: 0bd91de9b447a2991e666f284ae8c722ffb1d84acb594dbd0c031bd656fa32b2 + md5: 70e3400cbbfa03e96dcde7fc13e38c7b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 28424 + timestamp: 1749901812541 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpng-1.6.50-h943b412_0.conda + sha256: c7b212bdd3f9d5450c4bae565ccb9385222bf9bb92458c2a23be36ff1b981389 + md5: 51de14db340a848869e69c632b43cca7 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: zlib-acknowledgement + size: 289215 + timestamp: 1751559366724 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libpq-17.5-h27ae623_0.conda + sha256: 2dbcef0db82e0e7b6895b6c0dadd3d36c607044c40290c7ca10656f3fca3166f + md5: 6458be24f09e1b034902ab44fe9de908 + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=75.1,<76.0a0 + - krb5 >=1.21.3,<1.22.0a0 + - libgcc >=13 + - openldap >=2.6.9,<2.7.0a0 + - openssl >=3.5.0,<4.0a0 + arch: x86_64 + platform: linux + license: PostgreSQL + size: 2680582 + timestamp: 1746743259857 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libprotobuf-5.29.3-h501fc15_1.conda + sha256: 691af28446345674c6b3fb864d0e1a1574b6cc2f788e0f036d73a6b05dcf81cf + md5: edb86556cf4a0c133e7932a1597ff236 + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20250127.1,<20250128.0a0 + - libgcc >=13 + - libstdcxx >=13 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 3358788 + timestamp: 1745159546868 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libre2-11-2025.06.26-hba17884_0.conda + sha256: 89535af669f63e0dc4ae75a5fc9abb69b724b35e0f2ca0304c3d9744a55c8310 + md5: f6881c04e6617ebba22d237c36f1b88e + depends: + - __glibc >=2.17,<3.0.a0 + - libabseil * cxx17* + - libabseil >=20250127.1,<20250128.0a0 + - libgcc >=13 + - libstdcxx >=13 + constrains: + - re2 2025.06.26.* + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 211720 + timestamp: 1751053073521 +- conda: https://conda.anaconda.org/conda-forge/linux-64/librsvg-2.58.4-he92a37e_3.conda + sha256: a45ef03e6e700cc6ac6c375e27904531cf8ade27eb3857e080537ff283fb0507 + md5: d27665b20bc4d074b86e628b3ba5ab8b + depends: + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.4,<2.0a0 + - freetype >=2.13.3,<3.0a0 + - gdk-pixbuf >=2.42.12,<3.0a0 + - harfbuzz >=11.0.0,<12.0a0 + - libgcc >=13 + - libglib >=2.84.0,<3.0a0 + - libpng >=1.6.47,<1.7.0a0 + - libxml2 >=2.13.7,<2.14.0a0 + - pango >=1.56.3,<2.0a0 + constrains: + - __glibc >=2.17 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + size: 6543651 + timestamp: 1743368725313 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsanitizer-13.4.0-h2a15e64_18.conda + sha256: 019d5635f8b546e70886740a255f0ad92f777a990d504d7bb945539b16dbaee1 + md5: d4cccd80dee79958aa4581987d8f375d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13.4.0 + - libstdcxx >=13.4.0 + arch: x86_64 + platform: linux + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 6591860 + timestamp: 1771377400521 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libsqlite-3.50.2-h2f26a44_1.conda + sha256: 20bbeb64a1b427832d5f29be5b0506a91462028fc492fe9958d02b2c135714d8 + md5: 3d7a6ff85f94535f9c524afd4533424f + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=75.1,<76.0a0 + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 + license: Unlicense + size: 925117 + timestamp: 1752070211965 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-13.4.0-h934c35e_18.conda + sha256: e8ad7f3a9bd25f750d395a80a06bf5577af73cce0d6bb99e8d559b5fabc6395b + md5: 1bcbd853c7b666bd145a30b94361be21 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc 13.4.0 he0feb66_18 + constrains: + - libstdcxx-ng ==13.4.0=*_18 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 5680170 + timestamp: 1771377375220 +- conda: https://conda.anaconda.org/conda-forge/noarch/libstdcxx-devel_linux-64-13.4.0-h6963c3b_118.conda + sha256: 29477fff696ba73c22dbb958835d0c9d6d78bac8df8fabe29b9508c4ada3e6b3 + md5: 2aa85201a0eed4ea8eb47aed81e2cbbe + depends: + - __unix + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 19902036 + timestamp: 1771377254135 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libstdcxx-ng-13.4.0-hdf11a46_18.conda + sha256: de00d6bb3d1f3801dfd2333320ac38aed51b4a33a9f72145176b0465156b72d5 + md5: 92f07706a19f30ad9caaa1cf65510980 + depends: + - libstdcxx 13.4.0 h934c35e_18 + license: GPL-3.0-only WITH GCC-exception-3.1 + license_family: GPL + size: 27634 + timestamp: 1771377422554 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libtiff-4.7.0-hf01ce69_5.conda + sha256: 7fa6ddac72e0d803bb08e55090a8f2e71769f1eb7adbd5711bdd7789561601b1 + md5: e79a094918988bb1807462cd42c83962 + depends: + - __glibc >=2.17,<3.0.a0 + - lerc >=4.0.0,<5.0a0 + - libdeflate >=1.24,<1.25.0a0 + - libgcc >=13 + - libjpeg-turbo >=3.1.0,<4.0a0 + - liblzma >=5.8.1,<6.0a0 + - libstdcxx >=13 + - libwebp-base >=1.5.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + arch: x86_64 + platform: linux + license: HPND + size: 429575 + timestamp: 1747067001268 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libuuid-2.38.1-h0b41bf4_0.conda + sha256: 787eb542f055a2b3de553614b25f09eefb0a0931b0c87dbcce6efdfd92f04f18 + md5: 40b61aab5c7ba9ff276c41cfffe6b80b + depends: + - libgcc-ng >=12 + license: BSD-3-Clause + license_family: BSD + size: 33601 + timestamp: 1680112270483 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libwebp-base-1.5.0-h851e524_0.conda + sha256: c45283fd3e90df5f0bd3dbcd31f59cdd2b001d424cf30a07223655413b158eaf + md5: 63f790534398730f59e1b899c3644d4a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + constrains: + - libwebp 1.5.0 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 429973 + timestamp: 1734777489810 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcb-1.17.0-h8a09558_0.conda + sha256: 666c0c431b23c6cec6e492840b176dde533d48b7e6fb8883f5071223433776aa + md5: 92ed62436b625154323d40d5f2f11dd7 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - pthread-stubs + - xorg-libxau >=1.0.11,<2.0a0 + - xorg-libxdmcp + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 395888 + timestamp: 1727278577118 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxcrypt-4.4.36-hd590300_1.conda + sha256: 6ae68e0b86423ef188196fff6207ed0c8195dd84273cb5623b85aa08033a410c + md5: 5aa797f8787fe7a17d1b0821485b5adc + depends: + - libgcc-ng >=12 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + size: 100393 + timestamp: 1702724383534 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxkbcommon-1.10.0-h65c71a3_0.conda + sha256: a8043a46157511b3ceb6573a99952b5c0232313283f2d6a066cec7c8dcaed7d0 + md5: fedf6bfe5d21d21d2b1785ec00a8889a + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - libxcb >=1.17.0,<2.0a0 + - libxml2 >=2.13.8,<2.14.0a0 + - xkeyboard-config + - xorg-libxau >=1.0.12,<2.0a0 + arch: x86_64 + platform: linux + license: MIT/X11 Derivative + license_family: MIT + size: 707156 + timestamp: 1747911059945 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxml2-2.13.8-h4bc477f_0.conda + sha256: b0b3a96791fa8bb4ec030295e8c8bf2d3278f33c0f9ad540e73b5e538e6268e7 + md5: 14dbe05b929e329dbaa6f2d0aa19466d + depends: + - __glibc >=2.17,<3.0.a0 + - icu >=75.1,<76.0a0 + - libgcc >=13 + - libiconv >=1.18,<2.0a0 + - liblzma >=5.8.1,<6.0a0 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 690864 + timestamp: 1746634244154 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libxslt-1.1.43-h7a3aeb2_0.conda + sha256: 35ddfc0335a18677dd70995fa99b8f594da3beb05c11289c87b6de5b930b47a3 + md5: 31059dc620fa57d787e3899ed0421e6d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libxml2 >=2.13.8,<2.14.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 244399 + timestamp: 1753273455036 +- conda: https://conda.anaconda.org/conda-forge/linux-64/libzlib-1.3.2-h25fd6f3_2.conda + sha256: 55044c403570f0dc26e6364de4dc5368e5f3fc7ff103e867c487e2b5ab2bcda9 + md5: d87ff7921124eccd67248aa483c23fec + depends: + - __glibc >=2.17,<3.0.a0 + constrains: + - zlib 1.3.2 *_2 + license: Zlib + license_family: Other + size: 63629 + timestamp: 1774072609062 +- conda: https://conda.anaconda.org/conda-forge/linux-64/llvm-openmp-22.1.0-h4922eb0_0.conda + sha256: 543c9f17cf6ee6d7b635823fb9009df421d510c36739534df6ae43eadaf6ff4e + md5: 5e7da5333653c631d27732893b934351 + depends: + - __glibc >=2.17,<3.0.a0 + constrains: + - intel-openmp <0.0a0 + - openmp 22.1.0|22.1.0.* + arch: x86_64 + platform: linux + license: Apache-2.0 WITH LLVM-exception + license_family: APACHE + size: 6136884 + timestamp: 1772024545 +- conda: https://conda.anaconda.org/conda-forge/noarch/logical-unification-0.4.7-pyhd8ed1ab_0.conda + sha256: 5a3995f2b6c47d0b4842f3842490920e2dbf074854667d8649dd5abe81914a54 + md5: f2815c465aa44db830f0b31b7e6baaff + depends: + - multipledispatch + - python >=3.10 + - toolz + license: BSD-3-Clause + license_family: BSD + size: 18830 + timestamp: 1761054211310 +- conda: https://conda.anaconda.org/conda-forge/noarch/markdown-it-py-4.0.0-pyhd8ed1ab_0.conda + sha256: 7b1da4b5c40385791dbc3cc85ceea9fad5da680a27d5d3cb8bfaa185e304a89e + md5: 5b5203189eb668f042ac2b0826244964 + depends: + - mdurl >=0.1,<1 + - python >=3.10 + license: MIT + license_family: MIT + size: 64736 + timestamp: 1754951288511 +- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-3.10.3-py313h78bf25f_0.conda + sha256: 384337a8553f9e5dec80e4d1c46460207d96b0e2b6e73aa1c0de04a52d90917b + md5: cc9324e614a297fdf23439d887d3513d + depends: + - matplotlib-base >=3.10.3,<3.10.4.0a0 + - pyside6 >=6.7.2 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + - tornado >=5 + arch: x86_64 + platform: linux + license: PSF-2.0 + license_family: PSF + size: 17426 + timestamp: 1746820711137 +- conda: https://conda.anaconda.org/conda-forge/linux-64/matplotlib-base-3.10.3-py313h129903b_0.conda + sha256: eb23d6945d34836b62add0ca454f287cadb74b4b771cdd7196a1f51def425014 + md5: 4f8816d006b1c155ec416bcf7ff6cee2 + depends: + - __glibc >=2.17,<3.0.a0 + - contourpy >=1.0.1 + - cycler >=0.10 + - fonttools >=4.22.0 + - freetype + - kiwisolver >=1.3.1 + - libfreetype >=2.13.3 + - libfreetype6 >=2.13.3 + - libgcc >=13 + - libstdcxx >=13 + - numpy >=1.21,<3 + - numpy >=1.23 + - packaging >=20.0 + - pillow >=8 + - pyparsing >=2.3.1 + - python >=3.13,<3.14.0a0 + - python-dateutil >=2.7 + - python_abi 3.13.* *_cp313 + - qhull >=2020.2,<2020.3.0a0 + - tk >=8.6.13,<8.7.0a0 + arch: x86_64 + platform: linux + license: PSF-2.0 + license_family: PSF + size: 8479847 + timestamp: 1746820689093 +- conda: https://conda.anaconda.org/conda-forge/noarch/mdurl-0.1.2-pyhd8ed1ab_1.conda + sha256: 78c1bbe1723449c52b7a9df1af2ee5f005209f67e40b6e1d3c7619127c43b1c7 + md5: 592132998493b3ff25fd7479396e8351 + depends: + - python >=3.9 + license: MIT + license_family: MIT + size: 14465 + timestamp: 1733255681319 +- conda: https://conda.anaconda.org/conda-forge/noarch/minikanren-1.0.5-pyhd8ed1ab_1.conda + sha256: aced546f3dbc7f8710182b1f1ec30d2aaec2f4f9b48513d7d95fb2004ee775f6 + md5: ef7868bd5e40d31a8a41312e91ec6a9c + depends: + - cons >=0.4.0 + - etuples >=0.3.1 + - logical-unification >=0.4.1 + - multipledispatch + - python >=3.10 + - toolz + - typing_extensions + license: BSD-3-Clause + license_family: BSD + size: 27317 + timestamp: 1755897118661 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mkl-2024.2.2-ha770c72_17.conda + sha256: 1e59d0dc811f150d39c2ff2da930d69dcb91cb05966b7df5b7d85133006668ed + md5: e4ab075598123e783b788b995afbdad0 + depends: + - _openmp_mutex * *_llvm + - _openmp_mutex >=4.5 + - llvm-openmp >=20.1.8 + - tbb 2021.* + arch: x86_64 + platform: linux + license: LicenseRef-IntelSimplifiedSoftwareOct2022 + license_family: Proprietary + size: 124988693 + timestamp: 1753975818422 +- conda: https://conda.anaconda.org/conda-forge/linux-64/mkl-service-2.5.2-py313hae39701_0.conda + sha256: 632e5be381c8265bbdcf49f0470eea2e29e32228a74803b6f0a951a977a467a9 + md5: a2159ec3fd414fcda13e8d780393a1af + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - mkl >=2024.2.2,<2025.0a0 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 75165 + timestamp: 1751376181154 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ml_dtypes-0.5.1-py313ha87cce1_0.conda + sha256: 99b0aed0c8c0f365ea35dded676fb19a106aac48b2a1ae5990de317f35dc8955 + md5: f30e252cdd2ecb7f2bb9a6e5f0c334de + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - numpy >=1.21,<3 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + arch: x86_64 + platform: linux + license: MPL-2.0 AND Apache-2.0 + size: 293551 + timestamp: 1736538997988 +- conda: https://conda.anaconda.org/conda-forge/noarch/multipledispatch-0.6.0-pyhd8ed1ab_1.conda + sha256: c6216a21154373b340c64f321f22fec51db4ee6156c2e642fa58368103ac5d09 + md5: 121a57fce7fff0857ec70fa03200962f + depends: + - python >=3.6 + - six + license: BSD-3-Clause + license_family: BSD + size: 17254 + timestamp: 1721907640382 +- conda: https://conda.anaconda.org/conda-forge/noarch/munkres-1.1.4-pyhd8ed1ab_1.conda + sha256: d09c47c2cf456de5c09fa66d2c3c5035aa1fa228a1983a433c47b876aa16ce90 + md5: 37293a85a0f4f77bbd9cf7aaefc62609 + depends: + - python >=3.9 + license: Apache-2.0 + license_family: Apache + size: 15851 + timestamp: 1749895533014 +- conda: https://conda.anaconda.org/conda-forge/linux-64/ncurses-6.5-h2d0b736_3.conda + sha256: 3fde293232fa3fca98635e1167de6b7c7fda83caf24b9d6c91ec9eefb4f4d586 + md5: 47e340acb35de30501a76c7c799c41d7 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + license: X11 AND BSD-3-Clause + size: 891641 + timestamp: 1738195959188 +- conda: https://conda.anaconda.org/conda-forge/linux-64/numpy-2.3.1-py313h17eae1a_0.conda + sha256: 96b2ad622ac6521bb58586e9e671e49efe84988bc34a14cbd113b98c67728d5d + md5: 3a155f4d1e110a7330c17ccdce55d315 + depends: + - __glibc >=2.17,<3.0.a0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc >=13 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx >=13 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + constrains: + - numpy-base <0a0 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 8553831 + timestamp: 1751342634355 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openjpeg-2.5.3-h5fbd93e_0.conda + sha256: 5bee706ea5ba453ed7fd9da7da8380dd88b865c8d30b5aaec14d2b6dd32dbc39 + md5: 9e5816bc95d285c115a3ebc2f8563564 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libpng >=1.6.44,<1.7.0a0 + - libstdcxx >=13 + - libtiff >=4.7.0,<4.8.0a0 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: BSD-2-Clause + license_family: BSD + size: 342988 + timestamp: 1733816638720 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openldap-2.6.10-he970967_0.conda + sha256: cb0b07db15e303e6f0a19646807715d28f1264c6350309a559702f4f34f37892 + md5: 2e5bf4f1da39c0b32778561c3c4e5878 + depends: + - __glibc >=2.17,<3.0.a0 + - cyrus-sasl >=2.1.27,<3.0a0 + - krb5 >=1.21.3,<1.22.0a0 + - libgcc >=13 + - libstdcxx >=13 + - openssl >=3.5.0,<4.0a0 + arch: x86_64 + platform: linux + license: OLDAP-2.8 + license_family: BSD + size: 780253 + timestamp: 1748010165522 +- conda: https://conda.anaconda.org/conda-forge/linux-64/openssl-3.5.1-h7b32b05_0.conda + sha256: 942347492164190559e995930adcdf84e2fea05307ec8012c02a505f5be87462 + md5: c87df2ab1448ba69169652ab9547082d + depends: + - __glibc >=2.17,<3.0.a0 + - ca-certificates + - libgcc >=13 + license: Apache-2.0 + license_family: Apache + size: 3131002 + timestamp: 1751390382076 +- conda: https://conda.anaconda.org/conda-forge/noarch/opt_einsum-3.4.0-pyhd8ed1ab_1.conda + sha256: af71aabb2bfa4b2c89b7b06403e5cec23b418452cae9f9772bd7ac3f9ea1ff44 + md5: 52919815cd35c4e1a0298af658ccda04 + depends: + - python >=3.9 + license: MIT + license_family: MIT + size: 62479 + timestamp: 1733688053334 +- conda: https://conda.anaconda.org/conda-forge/noarch/packaging-26.0-pyhcf101f3_0.conda + sha256: c1fc0f953048f743385d31c468b4a678b3ad20caffdeaa94bed85ba63049fd58 + md5: b76541e68fea4d511b1ac46a28dcd2c6 + depends: + - python >=3.8 + - python + license: Apache-2.0 + license_family: APACHE + size: 72010 + timestamp: 1769093650580 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pandas-2.3.0-py313ha87cce1_0.conda + sha256: c4a6e9bc13454c5afd17600c2ee2b6b07fee8b2629cb1c193c22c048faa9bdcc + md5: 8664b4fa9b5b23b0d1cdc55c7195fcfe + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - numpy >=1.21,<3 + - numpy >=1.22.4 + - python >=3.13,<3.14.0a0 + - python-dateutil >=2.8.2 + - python-tzdata >=2022.7 + - python_abi 3.13.* *_cp313 + - pytz >=2020.1 + constrains: + - zstandard >=0.19.0 + - sqlalchemy >=2.0.0 + - pyqt5 >=5.15.9 + - pyxlsb >=1.0.10 + - qtpy >=2.3.0 + - odfpy >=1.4.1 + - python-calamine >=0.1.7 + - pytables >=3.8.0 + - numexpr >=2.8.4 + - s3fs >=2022.11.0 + - html5lib >=1.1 + - pyarrow >=10.0.1 + - xarray >=2022.12.0 + - lxml >=4.9.2 + - openpyxl >=3.1.0 + - fastparquet >=2022.12.0 + - fsspec >=2022.11.0 + - matplotlib >=3.6.3 + - scipy >=1.10.0 + - pandas-gbq >=0.19.0 + - xlsxwriter >=3.0.5 + - blosc >=1.21.3 + - xlrd >=2.0.1 + - bottleneck >=1.3.6 + - numba >=0.56.4 + - beautifulsoup4 >=4.11.2 + - pyreadstat >=1.2.0 + - tabulate >=0.9.0 + - tzdata >=2022.7 + - gcsfs >=2022.11.0 + - psycopg2 >=2.9.6 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 14991000 + timestamp: 1749100101435 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pango-1.56.4-hadf4263_0.conda + sha256: 3613774ad27e48503a3a6a9d72017087ea70f1426f6e5541dbdb59a3b626eaaf + md5: 79f71230c069a287efe3a8614069ddf1 + depends: + - __glibc >=2.17,<3.0.a0 + - cairo >=1.18.4,<2.0a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - fribidi >=1.0.10,<2.0a0 + - harfbuzz >=11.0.1 + - libexpat >=2.7.0,<3.0a0 + - libfreetype >=2.13.3 + - libfreetype6 >=2.13.3 + - libgcc >=13 + - libglib >=2.84.2,<3.0a0 + - libpng >=1.6.49,<1.7.0a0 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: LGPL-2.1-or-later + size: 455420 + timestamp: 1751292466873 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pcre2-10.45-hc749103_0.conda + sha256: 27c4014f616326240dcce17b5f3baca3953b6bc5f245ceb49c3fa1e6320571eb + md5: b90bece58b4c2bf25969b70f3be42d25 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 1197308 + timestamp: 1745955064657 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pillow-11.3.0-py313h8db990d_0.conda + sha256: 73067c9a1ea4857ce9fb6788d404cd7d931ba323ad26eddf083c5b12dc8d73c0 + md5: 114a74a6e184101112fdffd3a1cb5b8f + depends: + - __glibc >=2.17,<3.0.a0 + - lcms2 >=2.17,<3.0a0 + - libfreetype >=2.13.3 + - libfreetype6 >=2.13.3 + - libgcc >=13 + - libjpeg-turbo >=3.1.0,<4.0a0 + - libtiff >=4.7.0,<4.8.0a0 + - libwebp-base >=1.5.0,<2.0a0 + - libxcb >=1.17.0,<2.0a0 + - libzlib >=1.3.1,<2.0a0 + - openjpeg >=2.5.3,<3.0a0 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + - tk >=8.6.13,<8.7.0a0 + arch: x86_64 + platform: linux + license: HPND + size: 42651243 + timestamp: 1751482117433 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pixman-0.46.2-h29eaf8c_0.conda + sha256: 6cb261595b5f0ae7306599f2bb55ef6863534b6d4d1bc0dcfdfa5825b0e4e53d + md5: 39b4228a867772d610c02e06f939a5b8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 402222 + timestamp: 1749552884791 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pthread-stubs-0.4-hb9d3cd8_1002.conda + sha256: 9c88f8c64590e9567c6c80823f0328e58d3b1efb0e1c539c0315ceca764e0973 + md5: b3c17d95b5a10c6e64a21fa17573e70e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 8252 + timestamp: 1726802366959 +- conda: https://conda.anaconda.org/conda-forge/noarch/pygments-2.19.2-pyhd8ed1ab_0.conda + sha256: 5577623b9f6685ece2697c6eb7511b4c9ac5fb607c9babc2646c811b428fd46a + md5: 6b6ece66ebcae2d5f326c77ef2c5a066 + depends: + - python >=3.9 + license: BSD-2-Clause + license_family: BSD + size: 889287 + timestamp: 1750615908735 +- conda: https://conda.anaconda.org/conda-forge/noarch/pymc-5.24.1-hd8ed1ab_0.conda + noarch: python + sha256: 9b8904d1bea8a0605dd36bd10bfd5623a52857835f7521b896bd2b8af43d09d6 + md5: 1f3e5cfa64520cc64825aa776d13ecad + depends: + - pymc-base 5.24.1 pyhd8ed1ab_0 + - pytensor + - python-graphviz + license: Apache-2.0 + license_family: Apache + size: 12180 + timestamp: 1753043544422 +- conda: https://conda.anaconda.org/conda-forge/noarch/pymc-base-5.24.1-pyhd8ed1ab_0.conda + sha256: 145d8b94dc25d422ebe94fe631d421e9b22f6e68ba9b274c86853e94cddb7ec5 + md5: 2df648a60dcc28ca879d5a2824918231 + depends: + - arviz >=0.13.0 + - cachetools >=4.2.1 + - cloudpickle + - numpy >=1.25.0 + - pandas >=0.24.0 + - pytensor-base >=2.31.2,<2.32 + - python >=3.10 + - rich >=13.7.1 + - scipy >=1.4.1 + - threadpoolctl >=3.1.0,<4.0.0 + - typing_extensions >=3.7.4 + license: Apache-2.0 + license_family: Apache + size: 349019 + timestamp: 1753043541292 +- conda: https://conda.anaconda.org/conda-forge/noarch/pyparsing-3.3.2-pyhcf101f3_0.conda + sha256: 417fba4783e528ee732afa82999300859b065dc59927344b4859c64aae7182de + md5: 3687cc0b82a8b4c17e1f0eb7e47163d5 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + size: 110893 + timestamp: 1769003998136 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pyside6-6.9.1-py313h7dabd7a_0.conda + sha256: fc91214da44dc2efef121ae79ba996b08c11e46b4d768fa10d7a6bd59a97d685 + md5: 42a24d0f4fe3a2e8307de3838e162452 + depends: + - __glibc >=2.17,<3.0.a0 + - libclang13 >=20.1.6 + - libegl >=1.7.0,<2.0a0 + - libgcc >=13 + - libgl >=1.7.0,<2.0a0 + - libopengl >=1.7.0,<2.0a0 + - libstdcxx >=13 + - libxml2 >=2.13.8,<2.14.0a0 + - libxslt >=1.1.39,<2.0a0 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + - qt6-main 6.9.1.* + - qt6-main >=6.9.1,<6.10.0a0 + arch: x86_64 + platform: linux + license: LGPL-3.0-only + license_family: LGPL + size: 10098865 + timestamp: 1749047341823 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pytensor-2.31.6-py313ha6381f5_0.conda + sha256: 115ad06a7db0f40e3363b662e0ef52d2e0e403d452a153613d9d5d88dfcd8089 + md5: 2a63259fbb786e57e4b98d729f0737d7 + depends: + - python + - pytensor-base ==2.31.6 np2py313hfea535a_0 + - gxx + - gcc_linux-64 13.* + - sysroot_linux-64 2.17.* + - gxx_linux-64 13.* + - mkl-service + - blas + - python_abi 3.13.* *_cp313 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 10593 + timestamp: 1751640030925 +- conda: https://conda.anaconda.org/conda-forge/linux-64/pytensor-base-2.31.6-np2py313hfea535a_0.conda + sha256: f375b97d5bc123243f6aef4b80c1599c32f5a8577fb54a9022618287b41898a2 + md5: c11c29daac63980b7cbf38449d89b647 + depends: + - python + - setuptools >=59.0.0 + - scipy >=1,<2 + - numpy >=1.17.0 + - filelock >=3.15 + - etuples + - logical-unification + - minikanren + - cons + - libgcc >=13 + - __glibc >=2.17,<3.0.a0 + - libstdcxx >=13 + - libgcc >=13 + - python_abi 3.13.* *_cp313 + - numpy >=1.23,<3 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 2729036 + timestamp: 1751640030925 +- conda: https://conda.anaconda.org/conda-forge/linux-64/python-3.13.5-hec9711d_102_cp313.conda + build_number: 102 + sha256: c2cdcc98ea3cbf78240624e4077e164dc9d5588eefb044b4097c3df54d24d504 + md5: 89e07d92cf50743886f41638d58c4328 + depends: + - __glibc >=2.17,<3.0.a0 + - bzip2 >=1.0.8,<2.0a0 + - ld_impl_linux-64 >=2.36.1 + - libexpat >=2.7.0,<3.0a0 + - libffi >=3.4.6,<3.5.0a0 + - libgcc >=13 + - liblzma >=5.8.1,<6.0a0 + - libmpdec >=4.0.0,<5.0a0 + - libsqlite >=3.50.1,<4.0a0 + - libuuid >=2.38.1,<3.0a0 + - libzlib >=1.3.1,<2.0a0 + - ncurses >=6.5,<7.0a0 + - openssl >=3.5.0,<4.0a0 + - python_abi 3.13.* *_cp313 + - readline >=8.2,<9.0a0 + - tk >=8.6.13,<8.7.0a0 + - tzdata + license: Python-2.0 + size: 33273132 + timestamp: 1750064035176 + python_site_packages_path: lib/python3.13/site-packages +- conda: https://conda.anaconda.org/conda-forge/noarch/python-dateutil-2.9.0.post0-pyhe01879c_2.conda + sha256: d6a17ece93bbd5139e02d2bd7dbfa80bee1a4261dced63f65f679121686bf664 + md5: 5b8d21249ff20967101ffa321cab24e8 + depends: + - python >=3.9 + - six >=1.5 + - python + license: Apache-2.0 + license_family: APACHE + size: 233310 + timestamp: 1751104122689 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-graphviz-0.21-pyhbacfb6d_0.conda + sha256: b0139f80dea17136451975e4c0fefb5c86893d8b7bc6360626e8b025b8d8003a + md5: 606d94da4566aa177df7615d68b29176 + depends: + - graphviz >=2.46.1 + - python >=3.9 + license: MIT + license_family: MIT + size: 38837 + timestamp: 1749998558249 +- conda: https://conda.anaconda.org/conda-forge/noarch/python-tzdata-2025.3-pyhd8ed1ab_0.conda + sha256: 467134ef39f0af2dbb57d78cb3e4821f01003488d331a8dd7119334f4f47bfbd + md5: 7ead57407430ba33f681738905278d03 + depends: + - python >=3.10 + license: Apache-2.0 + license_family: APACHE + size: 143542 + timestamp: 1765719982349 +- conda: https://conda.anaconda.org/conda-forge/noarch/python_abi-3.13-8_cp313.conda + build_number: 8 + sha256: 210bffe7b121e651419cb196a2a63687b087497595c9be9d20ebe97dd06060a7 + md5: 94305520c52a4aa3f6c2b1ff6008d9f8 + constrains: + - python 3.13.* *_cp313 + license: BSD-3-Clause + license_family: BSD + size: 7002 + timestamp: 1752805902938 +- conda: https://conda.anaconda.org/conda-forge/noarch/pytz-2026.1.post1-pyhcf101f3_0.conda + sha256: d35c15c861d5635db1ba847a2e0e7de4c01994999602db1f82e41b5935a9578a + md5: f8a489f43a1342219a3a4d69cecc6b25 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + size: 201725 + timestamp: 1773679724369 +- conda: https://conda.anaconda.org/conda-forge/linux-64/qhull-2020.2-h434a139_5.conda + sha256: 776363493bad83308ba30bcb88c2552632581b143e8ee25b1982c8c743e73abc + md5: 353823361b1d27eb3960efb076dfcaf6 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc-ng >=12 + - libstdcxx-ng >=12 + arch: x86_64 + platform: linux + license: LicenseRef-Qhull + size: 552937 + timestamp: 1720813982144 +- conda: https://conda.anaconda.org/conda-forge/linux-64/qt6-main-6.9.1-h0384650_1.conda + sha256: 820338eadfdac82e0ec208e41a7f02cc3a7adb8fc0dcf107a57b2a1cdec9f89e + md5: 3610aa92d2de36047886f30e99342f21 + depends: + - __glibc >=2.17,<3.0.a0 + - alsa-lib >=1.2.14,<1.3.0a0 + - dbus >=1.16.2,<2.0a0 + - double-conversion >=3.3.1,<3.4.0a0 + - fontconfig >=2.15.0,<3.0a0 + - fonts-conda-ecosystem + - harfbuzz >=11.0.1 + - icu >=75.1,<76.0a0 + - krb5 >=1.21.3,<1.22.0a0 + - libclang-cpp20.1 >=20.1.7,<20.2.0a0 + - libclang13 >=20.1.7 + - libcups >=2.3.3,<2.4.0a0 + - libdrm >=2.4.125,<2.5.0a0 + - libegl >=1.7.0,<2.0a0 + - libfreetype >=2.13.3 + - libfreetype6 >=2.13.3 + - libgcc >=13 + - libgl >=1.7.0,<2.0a0 + - libglib >=2.84.2,<3.0a0 + - libjpeg-turbo >=3.1.0,<4.0a0 + - libllvm20 >=20.1.7,<20.2.0a0 + - libpng >=1.6.49,<1.7.0a0 + - libpq >=17.5,<18.0a0 + - libsqlite >=3.50.1,<4.0a0 + - libstdcxx >=13 + - libtiff >=4.7.0,<4.8.0a0 + - libwebp-base >=1.5.0,<2.0a0 + - libxcb >=1.17.0,<2.0a0 + - libxkbcommon >=1.10.0,<2.0a0 + - libxml2 >=2.13.8,<2.14.0a0 + - libzlib >=1.3.1,<2.0a0 + - openssl >=3.5.0,<4.0a0 + - pcre2 >=10.45,<10.46.0a0 + - wayland >=1.23.1,<2.0a0 + - xcb-util >=0.4.1,<0.5.0a0 + - xcb-util-cursor >=0.1.5,<0.2.0a0 + - xcb-util-image >=0.4.0,<0.5.0a0 + - xcb-util-keysyms >=0.4.1,<0.5.0a0 + - xcb-util-renderutil >=0.3.10,<0.4.0a0 + - xcb-util-wm >=0.4.2,<0.5.0a0 + - xorg-libice >=1.1.2,<2.0a0 + - xorg-libsm >=1.2.6,<2.0a0 + - xorg-libx11 >=1.8.12,<2.0a0 + - xorg-libxcomposite >=0.4.6,<1.0a0 + - xorg-libxcursor >=1.2.3,<2.0a0 + - xorg-libxdamage >=1.1.6,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxrandr >=1.5.4,<2.0a0 + - xorg-libxtst >=1.2.5,<2.0a0 + - xorg-libxxf86vm >=1.1.6,<2.0a0 + - zstd >=1.5.7,<1.6.0a0 + constrains: + - qt 6.9.1 + arch: x86_64 + platform: linux + license: LGPL-3.0-only + license_family: LGPL + size: 52006560 + timestamp: 1750920502800 +- conda: https://conda.anaconda.org/conda-forge/linux-64/re2-2025.06.26-h9925aae_0.conda + sha256: 7a0b82cb162229e905f500f18e32118ef581e1fd182036f3298510b8e8663134 + md5: 2b4249747a9091608dbff2bd22afde44 + depends: + - libre2-11 2025.06.26 hba17884_0 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 27330 + timestamp: 1751053087063 +- conda: https://conda.anaconda.org/conda-forge/linux-64/readline-8.2-h8c095d6_2.conda + sha256: 2d6d0c026902561ed77cd646b5021aef2d4db22e57a5b0178dfc669231e06d2c + md5: 283b96675859b20a825f8fa30f311446 + depends: + - libgcc >=13 + - ncurses >=6.5,<7.0a0 + license: GPL-3.0-only + license_family: GPL + size: 282480 + timestamp: 1740379431762 +- conda: https://conda.anaconda.org/conda-forge/noarch/rich-14.3.3-pyhcf101f3_0.conda + sha256: b06ce84d6a10c266811a7d3adbfa1c11f13393b91cc6f8a5b468277d90be9590 + md5: 7a6289c50631d620652f5045a63eb573 + depends: + - markdown-it-py >=2.2.0 + - pygments >=2.13.0,<3.0.0 + - python >=3.10 + - typing_extensions >=4.0.0,<5.0.0 + - python + license: MIT + license_family: MIT + size: 208472 + timestamp: 1771572730357 +- conda: https://conda.anaconda.org/conda-forge/linux-64/scipy-1.16.0-py313h86fcf2b_0.conda + sha256: 75bee2b5cb27616bcbd700d42dacc06577b90f1f9e31dc7682f4244867982a78 + md5: 8c60fe574a5abab59cd365d32e279872 + depends: + - __glibc >=2.17,<3.0.a0 + - libblas >=3.9.0,<4.0a0 + - libcblas >=3.9.0,<4.0a0 + - libgcc >=13 + - libgfortran + - libgfortran5 >=13.3.0 + - liblapack >=3.9.0,<4.0a0 + - libstdcxx >=13 + - numpy <2.6 + - numpy >=1.23,<3 + - numpy >=1.25.2 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + arch: x86_64 + platform: linux + license: BSD-3-Clause + license_family: BSD + size: 16727241 + timestamp: 1751148531084 +- conda: https://conda.anaconda.org/conda-forge/noarch/setuptools-82.0.1-pyh332efcf_0.conda + sha256: 82088a6e4daa33329a30bc26dc19a98c7c1d3f05c0f73ce9845d4eab4924e9e1 + md5: 8e194e7b992f99a5015edbd4ebd38efd + depends: + - python >=3.10 + license: MIT + license_family: MIT + size: 639697 + timestamp: 1773074868565 +- conda: https://conda.anaconda.org/conda-forge/noarch/six-1.17.0-pyhe01879c_1.conda + sha256: 458227f759d5e3fcec5d9b7acce54e10c9e1f4f4b7ec978f3bfd54ce4ee9853d + md5: 3339e3b65d58accf4ca4fb8748ab16b3 + depends: + - python >=3.9 + - python + license: MIT + license_family: MIT + size: 18455 + timestamp: 1753199211006 +- conda: https://conda.anaconda.org/conda-forge/noarch/sysroot_linux-64-2.17-h0157908_18.conda + sha256: 69ab5804bdd2e8e493d5709eebff382a72fab3e9af6adf93a237ccf8f7dbd624 + md5: 460eba7851277ec1fd80a1a24080787a + depends: + - kernel-headers_linux-64 3.10.0 he073ed8_18 + - tzdata + license: LGPL-2.0-or-later AND LGPL-2.0-or-later WITH exceptions AND GPL-2.0-or-later AND MPL-2.0 + license_family: GPL + size: 15166921 + timestamp: 1735290488259 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tbb-2021.13.0-hceb3a55_1.conda + sha256: 65463732129899770d54b1fbf30e1bb82fdebda9d7553caf08d23db4590cd691 + md5: ba7726b8df7b9d34ea80e82b097a4893 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libhwloc >=2.11.2,<2.11.3.0a0 + - libstdcxx >=13 + arch: x86_64 + platform: linux + license: Apache-2.0 + license_family: APACHE + size: 175954 + timestamp: 1732982638805 +- conda: https://conda.anaconda.org/conda-forge/noarch/threadpoolctl-3.6.0-pyhecae5ae_0.conda + sha256: 6016672e0e72c4cf23c0cf7b1986283bd86a9c17e8d319212d78d8e9ae42fdfd + md5: 9d64911b31d57ca443e9f1e36b04385f + depends: + - python >=3.9 + license: BSD-3-Clause + license_family: BSD + size: 23869 + timestamp: 1741878358548 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tk-8.6.13-noxft_ha0e22de_103.conda + sha256: 1544760538a40bcd8ace2b1d8ebe3eb5807ac268641f8acdc18c69c5ebfeaf64 + md5: 86bc20552bf46075e3d92b67f089172d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libzlib >=1.3.1,<2.0a0 + constrains: + - xorg-libx11 >=1.8.12,<2.0a0 + license: TCL + license_family: BSD + size: 3284905 + timestamp: 1763054914403 +- conda: https://conda.anaconda.org/conda-forge/noarch/toolz-1.1.0-pyhd8ed1ab_1.conda + sha256: 4e379e1c18befb134247f56021fdf18e112fb35e64dd1691858b0a0f3bea9a45 + md5: c07a6153f8306e45794774cf9b13bd32 + depends: + - python >=3.10 + license: BSD-3-Clause + license_family: BSD + size: 53978 + timestamp: 1760707830681 +- conda: https://conda.anaconda.org/conda-forge/linux-64/tornado-6.5.1-py313h536fd9c_0.conda + sha256: 282c9c3380217119c779fc4c432b0e4e1e42e9a6265bfe36b6f17f6b5d4e6614 + md5: e9434a5155db25c38ade26f71a2f5a48 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - python >=3.13,<3.14.0a0 + - python_abi 3.13.* *_cp313 + arch: x86_64 + platform: linux + license: Apache-2.0 + license_family: Apache + size: 873269 + timestamp: 1748003477089 +- conda: https://conda.anaconda.org/conda-forge/noarch/typing_extensions-4.15.0-pyhcf101f3_0.conda + sha256: 032271135bca55aeb156cee361c81350c6f3fb203f57d024d7e5a1fc9ef18731 + md5: 0caa1af407ecff61170c9437a808404d + depends: + - python >=3.10 + - python + license: PSF-2.0 + license_family: PSF + size: 51692 + timestamp: 1756220668932 +- conda: https://conda.anaconda.org/conda-forge/noarch/tzdata-2025c-hc9c84f9_1.conda + sha256: 1d30098909076af33a35017eed6f2953af1c769e273a0626a04722ac4acaba3c + md5: ad659d0a2b3e47e38d829aa8cad2d610 + license: LicenseRef-Public-Domain + size: 119135 + timestamp: 1767016325805 +- conda: https://conda.anaconda.org/conda-forge/linux-64/wayland-1.24.0-h3e06ad9_0.conda + sha256: ba673427dcd480cfa9bbc262fd04a9b1ad2ed59a159bd8f7e750d4c52282f34c + md5: 0f2ca7906bf166247d1d760c3422cb8a + depends: + - __glibc >=2.17,<3.0.a0 + - libexpat >=2.7.0,<3.0a0 + - libffi >=3.4.6,<3.5.0a0 + - libgcc >=13 + - libstdcxx >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 330474 + timestamp: 1751817998141 +- conda: https://conda.anaconda.org/conda-forge/noarch/xarray-2026.2.0-pyhcf101f3_0.conda + sha256: 1d49f2c80c63913c5a9a525b64434a30cf1386502d0f24607db61bd46fa36a40 + md5: b1b3a2477c1b888f15bbef01d7a9615f + depends: + - python >=3.11 + - numpy >=1.26 + - packaging >=24.1 + - pandas >=2.2 + - python + constrains: + - bottleneck >=1.4 + - cartopy >=0.23 + - cftime >=1.6 + - dask-core >=2024.6 + - distributed >=2024.6 + - flox >=0.9 + - h5netcdf >=1.3 + - h5py >=3.11 + - hdf5 >=1.14 + - iris >=3.9 + - matplotlib-base >=3.8 + - nc-time-axis >=1.4 + - netcdf4 >=1.6.0 + - numba >=0.60 + - numbagg >=0.8 + - pint >=0.24 + - pydap >=3.5.0 + - scipy >=1.13 + - seaborn-base >=0.13 + - sparse >=0.15 + - toolz >=0.12 + - zarr >=2.18 + license: Apache-2.0 + license_family: APACHE + size: 1011911 + timestamp: 1771083999178 +- conda: https://conda.anaconda.org/conda-forge/noarch/xarray-einstats-0.10.0-pyhd8ed1ab_0.conda + sha256: 02943091700f860bc3fc117deabe5fd609ed7bae64fd97da2f70241167c2719d + md5: b82273c95432c78efe98f14cbc46be7d + depends: + - numpy >=2.0 + - python >=3.12 + - scipy >=1.13 + - xarray >=2024.02.0 + license: Apache-2.0 + license_family: APACHE + size: 38256 + timestamp: 1771933879255 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-0.4.1-h4f16b4b_2.conda + sha256: ad8cab7e07e2af268449c2ce855cbb51f43f4664936eff679b1f3862e6e4b01d + md5: fdc27cb255a7a2cc73b7919a968b48f0 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libxcb >=1.17.0,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 20772 + timestamp: 1750436796633 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-cursor-0.1.5-hb9d3cd8_0.conda + sha256: c7b35db96f6e32a9e5346f97adc968ef2f33948e3d7084295baebc0e33abdd5b + md5: eb44b3b6deb1cab08d72cb61686fe64c + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libxcb >=1.13 + - libxcb >=1.16,<2.0.0a0 + - xcb-util-image >=0.4.0,<0.5.0a0 + - xcb-util-renderutil >=0.3.10,<0.4.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 20296 + timestamp: 1726125844850 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-image-0.4.0-hb711507_2.conda + sha256: 94b12ff8b30260d9de4fd7a28cca12e028e572cbc504fd42aa2646ec4a5bded7 + md5: a0901183f08b6c7107aab109733a3c91 + depends: + - libgcc-ng >=12 + - libxcb >=1.16,<2.0.0a0 + - xcb-util >=0.4.1,<0.5.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 24551 + timestamp: 1718880534789 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-keysyms-0.4.1-hb711507_0.conda + sha256: 546e3ee01e95a4c884b6401284bb22da449a2f4daf508d038fdfa0712fe4cc69 + md5: ad748ccca349aec3e91743e08b5e2b50 + depends: + - libgcc-ng >=12 + - libxcb >=1.16,<2.0.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 14314 + timestamp: 1718846569232 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-renderutil-0.3.10-hb711507_0.conda + sha256: 2d401dadc43855971ce008344a4b5bd804aca9487d8ebd83328592217daca3df + md5: 0e0cbe0564d03a99afd5fd7b362feecd + depends: + - libgcc-ng >=12 + - libxcb >=1.16,<2.0.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 16978 + timestamp: 1718848865819 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xcb-util-wm-0.4.2-hb711507_0.conda + sha256: 31d44f297ad87a1e6510895740325a635dd204556aa7e079194a0034cdd7e66a + md5: 608e0ef8256b81d04456e8d211eee3e8 + depends: + - libgcc-ng >=12 + - libxcb >=1.16,<2.0.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 51689 + timestamp: 1718844051451 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xkeyboard-config-2.45-hb9d3cd8_0.conda + sha256: a5d4af601f71805ec67403406e147c48d6bad7aaeae92b0622b7e2396842d3fe + md5: 397a013c2dc5145a70737871aaa87e98 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.12,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 392406 + timestamp: 1749375847832 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libice-1.1.2-hb9d3cd8_0.conda + sha256: c12396aabb21244c212e488bbdc4abcdef0b7404b15761d9329f5a4a39113c4b + md5: fb901ff28063514abb6046c9ec2c4a45 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 58628 + timestamp: 1734227592886 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libsm-1.2.6-he73a12e_0.conda + sha256: 277841c43a39f738927145930ff963c5ce4c4dacf66637a3d95d802a64173250 + md5: 1c74ff8c35dcadf952a16f752ca5aa49 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libuuid >=2.38.1,<3.0a0 + - xorg-libice >=1.1.2,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 27590 + timestamp: 1741896361728 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libx11-1.8.12-h4f16b4b_0.conda + sha256: 51909270b1a6c5474ed3978628b341b4d4472cd22610e5f22b506855a5e20f67 + md5: db038ce880f100acc74dba10302b5630 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libxcb >=1.17.0,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 835896 + timestamp: 1741901112627 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxau-1.0.12-hb9d3cd8_0.conda + sha256: ed10c9283974d311855ae08a16dfd7e56241fac632aec3b92e3cfe73cff31038 + md5: f6ebe2cb3f82ba6c057dde5d9debe4f7 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 14780 + timestamp: 1734229004433 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcomposite-0.4.6-hb9d3cd8_2.conda + sha256: 753f73e990c33366a91fd42cc17a3d19bb9444b9ca5ff983605fa9e953baf57f + md5: d3c295b50f092ab525ffe3c2aa4b7413 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 13603 + timestamp: 1727884600744 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxcursor-1.2.3-hb9d3cd8_0.conda + sha256: 832f538ade441b1eee863c8c91af9e69b356cd3e9e1350fff4fe36cc573fc91a + md5: 2ccd714aa2242315acaf0a67faea780b + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + - xorg-libxrender >=0.9.11,<0.10.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 32533 + timestamp: 1730908305254 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdamage-1.1.6-hb9d3cd8_0.conda + sha256: 43b9772fd6582bf401846642c4635c47a9b0e36ca08116b3ec3df36ab96e0ec0 + md5: b5fcc7172d22516e1f965490e65e33a4 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 13217 + timestamp: 1727891438799 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxdmcp-1.1.5-hb9d3cd8_0.conda + sha256: 6b250f3e59db07c2514057944a3ea2044d6a8cdde8a47b6497c254520fade1ee + md5: 8035c64cb77ed555e3f150b7b3972480 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 19901 + timestamp: 1727794976192 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxext-1.3.6-hb9d3cd8_0.conda + sha256: da5dc921c017c05f38a38bd75245017463104457b63a1ce633ed41f214159c14 + md5: febbab7d15033c913d53c7a2c102309d + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 50060 + timestamp: 1727752228921 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxfixes-6.0.1-hb9d3cd8_0.conda + sha256: 2fef37e660985794617716eb915865ce157004a4d567ed35ec16514960ae9271 + md5: 4bdb303603e9821baf5fe5fdff1dc8f8 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 19575 + timestamp: 1727794961233 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxi-1.8.2-hb9d3cd8_0.conda + sha256: 1a724b47d98d7880f26da40e45f01728e7638e6ec69f35a3e11f92acd05f9e7a + md5: 17dcc85db3c7886650b8908b183d6876 + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxfixes >=6.0.1,<7.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 47179 + timestamp: 1727799254088 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxinerama-1.1.5-h5888daf_1.conda + sha256: 1b9141c027f9d84a9ee5eb642a0c19457c788182a5a73c5a9083860ac5c20a8c + md5: 5e2eb9bf77394fc2e5918beefec9f9ab + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - libstdcxx >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 13891 + timestamp: 1727908521531 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrandr-1.5.4-hb9d3cd8_0.conda + sha256: ac0f037e0791a620a69980914a77cb6bb40308e26db11698029d6708f5aa8e0d + md5: 2de7f99d6581a4a7adbff607b5c278ca + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxrender >=0.9.11,<0.10.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 29599 + timestamp: 1727794874300 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxrender-0.9.12-hb9d3cd8_0.conda + sha256: 044c7b3153c224c6cedd4484dd91b389d2d7fd9c776ad0f4a34f099b3389f4a1 + md5: 96d57aba173e878a2089d5638016dc5e + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 33005 + timestamp: 1734229037766 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxtst-1.2.5-hb9d3cd8_3.conda + sha256: 752fdaac5d58ed863bbf685bb6f98092fe1a488ea8ebb7ed7b606ccfce08637a + md5: 7bbe9a0cc0df0ac5f5a8ad6d6a11af2f + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + - xorg-libxi >=1.7.10,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 32808 + timestamp: 1727964811275 +- conda: https://conda.anaconda.org/conda-forge/linux-64/xorg-libxxf86vm-1.1.6-hb9d3cd8_0.conda + sha256: 8a4e2ee642f884e6b78c20c0892b85dd9b2a6e64a6044e903297e616be6ca35b + md5: 5efa5fa6243a622445fdfd72aee15efa + depends: + - __glibc >=2.17,<3.0.a0 + - libgcc >=13 + - xorg-libx11 >=1.8.10,<2.0a0 + - xorg-libxext >=1.3.6,<2.0a0 + arch: x86_64 + platform: linux + license: MIT + license_family: MIT + size: 17819 + timestamp: 1734214575628 +- conda: https://conda.anaconda.org/conda-forge/noarch/zipp-3.23.0-pyhcf101f3_1.conda + sha256: b4533f7d9efc976511a73ef7d4a2473406d7f4c750884be8e8620b0ce70f4dae + md5: 30cd29cb87d819caead4d55184c1d115 + depends: + - python >=3.10 + - python + license: MIT + license_family: MIT + size: 24194 + timestamp: 1764460141901 +- conda: https://conda.anaconda.org/conda-forge/linux-64/zstd-1.5.7-hb78ec9c_6.conda + sha256: 68f0206ca6e98fea941e5717cec780ed2873ffabc0e1ed34428c061e2c6268c7 + md5: 4a13eeac0b5c8e5b8ab496e6c4ddd829 + depends: + - __glibc >=2.17,<3.0.a0 + - libzlib >=1.3.1,<2.0a0 + license: BSD-3-Clause + license_family: BSD + size: 601375 + timestamp: 1764777111296 diff --git a/scripts/Benchmarking/.CondaPkg/pixi.toml b/scripts/Benchmarking/.CondaPkg/pixi.toml new file mode 100644 index 0000000..6c36918 --- /dev/null +++ b/scripts/Benchmarking/.CondaPkg/pixi.toml @@ -0,0 +1,18 @@ +[dependencies] +pytensor = "*" +libstdcxx = ">=3.4,<14.0" +bambi = "*" +libstdcxx-ng = ">=3.4,<14.0" +jax = "*" + + [dependencies.python] + channel = "conda-forge" + build = "*cp*" + version = ">=3.10,!=3.14.0,!=3.14.1,<4" + +[project] +name = ".CondaPkg" +platforms = ["linux-64"] +channels = ["conda-forge"] +channel-priority = "strict" +description = "automatically generated by CondaPkg.jl" diff --git a/scripts/Benchmarking/CondaPkg.toml b/scripts/Benchmarking/CondaPkg.toml new file mode 100644 index 0000000..db6dd60 --- /dev/null +++ b/scripts/Benchmarking/CondaPkg.toml @@ -0,0 +1,4 @@ +[deps] +bambi = "" +jax = "" +pytensor = "" diff --git a/scripts/Benchmarking/Manifest.toml b/scripts/Benchmarking/Manifest.toml new file mode 100644 index 0000000..2605cad --- /dev/null +++ b/scripts/Benchmarking/Manifest.toml @@ -0,0 +1,2011 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.10.11" +manifest_format = "2.0" +project_hash = "9b232e3eeb1fa6a5bfa886bd13dad382f4ecae74" + +[[deps.ADTypes]] +git-tree-sha1 = "f7304359109c768cf32dc5fa2d371565bb63b68a" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "1.21.0" +weakdeps = ["ChainRulesCore", "ConstructionBase", "EnzymeCore"] + + [deps.ADTypes.extensions] + ADTypesChainRulesCoreExt = "ChainRulesCore" + ADTypesConstructionBaseExt = "ConstructionBase" + ADTypesEnzymeCoreExt = "EnzymeCore" + +[[deps.AbstractFFTs]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "d92ad398961a3ed262d8bf04a1a2b8340f915fef" +uuid = "621f4979-c628-5d54-868e-fcf4e3e8185c" +version = "1.5.0" +weakdeps = ["ChainRulesCore", "Test"] + + [deps.AbstractFFTs.extensions] + AbstractFFTsChainRulesCoreExt = "ChainRulesCore" + AbstractFFTsTestExt = "Test" + +[[deps.AbstractMCMC]] +deps = ["BangBang", "ConsoleProgressMonitor", "Dates", "Distributed", "FillArrays", "LogDensityProblems", "Logging", "LoggingExtras", "ProgressLogging", "Random", "StatsBase", "TerminalLoggers", "Transducers", "UUIDs"] +git-tree-sha1 = "511d0d8cbf38045be05188ae26880afb57342a88" +uuid = "80f14c24-f653-4e6a-9b94-39d6b0f70001" +version = "5.14.0" + + [deps.AbstractMCMC.extensions] + AbstractMCMCOnlineStatsExt = "OnlineStats" + AbstractMCMCTensorBoardLoggerExt = "TensorBoardLogger" + + [deps.AbstractMCMC.weakdeps] + OnlineStats = "a15396b6-48d5-5d58-9928-6d29437db91e" + TensorBoardLogger = "899adc3e-224a-11e9-021f-63837185c80f" + +[[deps.AbstractPPL]] +deps = ["AbstractMCMC", "Accessors", "BangBang", "DensityInterface", "JSON", "LinearAlgebra", "MacroTools", "OrderedCollections", "Random", "StatsBase"] +git-tree-sha1 = "cc74854881ab9531bde1ecc624ef3f9821497717" +uuid = "7a57a42e-76ec-4ea3-a279-07e840d6d9cf" +version = "0.14.1" +weakdeps = ["Distributions"] + + [deps.AbstractPPL.extensions] + AbstractPPLDistributionsExt = ["Distributions", "LinearAlgebra"] + +[[deps.AbstractTrees]] +git-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177" +uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" +version = "0.4.5" + +[[deps.Accessors]] +deps = ["CompositionsBase", "ConstructionBase", "Dates", "InverseFunctions", "MacroTools"] +git-tree-sha1 = "856ecd7cebb68e5fc87abecd2326ad59f0f911f3" +uuid = "7d9f7c33-5ae7-4f3b-8dc6-eff91059b697" +version = "0.1.43" + + [deps.Accessors.extensions] + AxisKeysExt = "AxisKeys" + IntervalSetsExt = "IntervalSets" + LinearAlgebraExt = "LinearAlgebra" + StaticArraysExt = "StaticArrays" + StructArraysExt = "StructArrays" + TestExt = "Test" + UnitfulExt = "Unitful" + + [deps.Accessors.weakdeps] + AxisKeys = "94b1ba4f-4ee9-5380-92f1-94cde586c3c5" + IntervalSets = "8197267c-284f-5f27-9208-e0e47529a953" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.Adapt]] +deps = ["LinearAlgebra", "Requires"] +git-tree-sha1 = "35ea197a51ce46fcd01c4a44befce0578a1aaeca" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.5.0" +weakdeps = ["SparseArrays", "StaticArrays"] + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + +[[deps.AdvancedHMC]] +deps = ["AbstractMCMC", "ArgCheck", "DocStringExtensions", "LinearAlgebra", "LogDensityProblems", "LogDensityProblemsAD", "ProgressMeter", "Random", "Setfield", "Statistics", "StatsBase", "StatsFuns"] +git-tree-sha1 = "15e1bafe97eb0eeb77c8dae63cdcfa133986b254" +uuid = "0bf59076-c3b1-5ca4-86bd-e02cd72cde3d" +version = "0.8.3" + + [deps.AdvancedHMC.extensions] + AdvancedHMCADTypesExt = "ADTypes" + AdvancedHMCCUDAExt = "CUDA" + AdvancedHMCComponentArraysExt = "ComponentArrays" + AdvancedHMCMCMCChainsExt = "MCMCChains" + AdvancedHMCOrdinaryDiffEqExt = "OrdinaryDiffEq" + + [deps.AdvancedHMC.weakdeps] + ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66" + MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" + OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" + +[[deps.AdvancedMH]] +deps = ["AbstractMCMC", "Distributions", "DocStringExtensions", "FillArrays", "LinearAlgebra", "LogDensityProblems", "Random", "Requires"] +git-tree-sha1 = "62ddbccf0ce5c26f8ef3cebe4bedef6b1599d616" +uuid = "5b7e9947-ddc0-4b3f-9b55-0d8042f74170" +version = "0.8.10" +weakdeps = ["DiffResults", "ForwardDiff", "MCMCChains", "StructArrays"] + + [deps.AdvancedMH.extensions] + AdvancedMHForwardDiffExt = ["DiffResults", "ForwardDiff"] + AdvancedMHMCMCChainsExt = "MCMCChains" + AdvancedMHStructArraysExt = "StructArrays" + +[[deps.AdvancedPS]] +deps = ["AbstractMCMC", "Distributions", "Random", "Random123", "Requires", "SSMProblems", "StatsFuns"] +git-tree-sha1 = "d92dd3fb4cc2748860ae8d5dd1d324cf0715a53b" +uuid = "576499cb-2369-40b2-a588-c64705576edc" +version = "0.7.2" +weakdeps = ["Libtask"] + + [deps.AdvancedPS.extensions] + AdvancedPSLibtaskExt = "Libtask" + +[[deps.AdvancedVI]] +deps = ["ADTypes", "Accessors", "ChainRulesCore", "DiffResults", "DifferentiationInterface", "Distributions", "DocStringExtensions", "FillArrays", "Functors", "LinearAlgebra", "LogDensityProblems", "Optimisers", "ProgressMeter", "Random", "StatsBase"] +git-tree-sha1 = "d69d7d9e1756fff9dd5d3fd26add46ee5ac62be4" +uuid = "b5ca4192-6429-45e5-a2d9-87aec30a685c" +version = "0.6.2" + + [deps.AdvancedVI.extensions] + AdvancedVIBijectorsExt = ["Bijectors", "Optimisers"] + AdvancedVIEnzymeExt = ["Enzyme", "ChainRulesCore"] + AdvancedVIMooncakeExt = ["Mooncake", "ChainRulesCore"] + AdvancedVIReverseDiffExt = ["ReverseDiff", "ChainRulesCore"] + + [deps.AdvancedVI.weakdeps] + Bijectors = "76274a88-744f-5084-9051-94815aaf08c4" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + +[[deps.AliasTables]] +deps = ["PtrArrays", "Random"] +git-tree-sha1 = "9876e1e164b144ca45e9e3198d0b689cadfed9ff" +uuid = "66dad0bd-aa9a-41b7-9441-69ab47430ed8" +version = "1.1.3" + +[[deps.ArgCheck]] +git-tree-sha1 = "f9e9a66c9b7be1ad7372bbd9b062d9230c30c5ce" +uuid = "dce04be8-c92d-5529-be00-80e4d2c0e197" +version = "2.5.0" + +[[deps.ArgTools]] +uuid = "0dad84c5-d112-42e6-8d28-ef12dabb789f" +version = "1.1.1" + +[[deps.ArnoldiMethod]] +deps = ["LinearAlgebra", "Random", "StaticArrays"] +git-tree-sha1 = "d57bd3762d308bded22c3b82d033bff85f6195c6" +uuid = "ec485272-7323-5ecc-a04f-4719b315124d" +version = "0.4.0" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "78b3a7a536b4b0a747a0f296ea77091ca0a9f9a3" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.23.0" + + [deps.ArrayInterface.extensions] + ArrayInterfaceAMDGPUExt = "AMDGPU" + ArrayInterfaceBandedMatricesExt = "BandedMatrices" + ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" + ArrayInterfaceCUDAExt = "CUDA" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] + ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" + ArrayInterfaceChainRulesExt = "ChainRules" + ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceMetalExt = "Metal" + ArrayInterfaceReverseDiffExt = "ReverseDiff" + ArrayInterfaceSparseArraysExt = "SparseArrays" + ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" + ArrayInterfaceTrackerExt = "Tracker" + + [deps.ArrayInterface.weakdeps] + AMDGPU = "21141c5a-9bdb-4563-92ae-f87d6854732e" + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CUDSS = "45b445bb-4962-46a0-9369-b4df9d0f772e" + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + Metal = "dde4c033-4e86-420c-a63e-0dd931031962" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.Artifacts]] +uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" + +[[deps.AxisAlgorithms]] +deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"] +git-tree-sha1 = "01b8ccb13d68535d73d2b0c23e39bd23155fb712" +uuid = "13072b0f-2c55-5437-9ae7-d433b7a33950" +version = "1.1.0" + +[[deps.AxisArrays]] +deps = ["Dates", "IntervalSets", "IterTools", "RangeArrays"] +git-tree-sha1 = "4126b08903b777c88edf1754288144a0492c05ad" +uuid = "39de3d68-74b9-583c-8d2d-e117c070f3a9" +version = "0.4.8" + +[[deps.BangBang]] +deps = ["Accessors", "ConstructionBase", "InitialValues", "LinearAlgebra"] +git-tree-sha1 = "cceb62468025be98d42a5dc581b163c20896b040" +uuid = "198e06fe-97b7-11e9-32a5-e1d131e6ad66" +version = "0.4.9" + + [deps.BangBang.extensions] + BangBangChainRulesCoreExt = "ChainRulesCore" + BangBangDataFramesExt = "DataFrames" + BangBangStaticArraysExt = "StaticArrays" + BangBangStructArraysExt = "StructArrays" + BangBangTablesExt = "Tables" + BangBangTypedTablesExt = "TypedTables" + + [deps.BangBang.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" + +[[deps.Baselet]] +git-tree-sha1 = "aebf55e6d7795e02ca500a689d326ac979aaf89e" +uuid = "9718e550-a3fa-408a-8086-8db961cd8217" +version = "0.1.1" + +[[deps.Bijectors]] +deps = ["AbstractPPL", "ArgCheck", "ChainRulesCore", "ChangesOfVariables", "DifferentiationInterface", "Distributions", "DocStringExtensions", "EnzymeCore", "Functors", "InverseFunctions", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "MappedArrays", "Random", "Reexport", "Roots", "SparseArrays", "Statistics", "Test"] +git-tree-sha1 = "e876fd33fef2708270d8f72b4491af71fed12ec6" +uuid = "76274a88-744f-5084-9051-94815aaf08c4" +version = "0.15.18" + + [deps.Bijectors.extensions] + BijectorsDistributionsADExt = "DistributionsAD" + BijectorsForwardDiffExt = "ForwardDiff" + BijectorsLazyArraysExt = "LazyArrays" + BijectorsMooncakeExt = "Mooncake" + BijectorsReverseDiffChainRulesExt = ["ChainRules", "ReverseDiff"] + BijectorsReverseDiffExt = "ReverseDiff" + + [deps.Bijectors.weakdeps] + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + DistributionsAD = "ced4e74d-a319-5a8a-b0ac-84af2272839c" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + +[[deps.BridgeStan]] +deps = ["Downloads", "Inflate", "TOML", "Tar"] +git-tree-sha1 = "f8689ac4ce3245df7a436889988762a6c4a9da12" +uuid = "c88b6f0a-829e-4b0b-94b7-f06ab5908f5a" +version = "2.7.0" + +[[deps.CEnum]] +git-tree-sha1 = "389ad5c84de1ae7cf0e28e381131c98ea87d54fc" +uuid = "fa961155-64e5-5f13-b03f-caf6b980ea82" +version = "0.5.0" + +[[deps.CSV]] +deps = ["CodecZlib", "Dates", "FilePathsBase", "InlineStrings", "Mmap", "Parsers", "PooledArrays", "PrecompileTools", "SentinelArrays", "Tables", "Unicode", "WeakRefStrings", "WorkerUtilities"] +git-tree-sha1 = "8d8e0b0f350b8e1c91420b5e64e5de774c2f0f4d" +uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" +version = "0.10.16" + +[[deps.CategoricalArrays]] +deps = ["Compat", "DataAPI", "Future", "Missings", "Printf", "Requires", "Statistics", "Unicode"] +git-tree-sha1 = "a6f644eb7bbc0171286f0f3ad1ffde8f04be7b83" +uuid = "324d7699-5711-5eae-9e2f-1d82baa6b597" +version = "1.1.0" + + [deps.CategoricalArrays.extensions] + CategoricalArraysArrowExt = "Arrow" + CategoricalArraysJSONExt = "JSON" + CategoricalArraysRecipesBaseExt = "RecipesBase" + CategoricalArraysSentinelArraysExt = "SentinelArrays" + CategoricalArraysStatsBaseExt = "StatsBase" + CategoricalArraysStructTypesExt = "StructTypes" + + [deps.CategoricalArrays.weakdeps] + Arrow = "69666777-d1a9-59fb-9406-91d4454c9d45" + JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" + RecipesBase = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" + SentinelArrays = "91c51154-3ec4-41a3-a24f-3f23e20d615c" + StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" + StructTypes = "856f2bd8-1eba-4b0a-8007-ebc267875bd4" + +[[deps.ChainRules]] +deps = ["Adapt", "ChainRulesCore", "Compat", "Distributed", "GPUArraysCore", "IrrationalConstants", "LinearAlgebra", "Random", "RealDot", "SparseArrays", "SparseInverseSubset", "Statistics", "StructArrays", "SuiteSparse"] +git-tree-sha1 = "3c190c570fb3108c09f838607386d10c71701789" +uuid = "082447d4-558c-5d27-93f4-14fc19e9eca2" +version = "1.73.0" + +[[deps.ChainRulesCore]] +deps = ["Compat", "LinearAlgebra"] +git-tree-sha1 = "e4c6a16e77171a5f5e25e9646617ab1c276c5607" +uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" +version = "1.26.0" +weakdeps = ["SparseArrays"] + + [deps.ChainRulesCore.extensions] + ChainRulesCoreSparseArraysExt = "SparseArrays" + +[[deps.Chairmarks]] +deps = ["Printf", "Random"] +git-tree-sha1 = "9a49491e67e7a4d6f885c43d00bb101e6e5a434b" +uuid = "0ca39b1e-fe0b-4e98-acfc-b1656634c4de" +version = "1.3.1" +weakdeps = ["Statistics"] + + [deps.Chairmarks.extensions] + StatisticsChairmarksExt = ["Statistics"] + +[[deps.ChangesOfVariables]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "3aa4bf1532aa2e14e0374c4fd72bed9a9d0d0f6c" +uuid = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" +version = "0.1.10" +weakdeps = ["InverseFunctions", "Test"] + + [deps.ChangesOfVariables.extensions] + ChangesOfVariablesInverseFunctionsExt = "InverseFunctions" + ChangesOfVariablesTestExt = "Test" + +[[deps.CodecZlib]] +deps = ["TranscodingStreams", "Zlib_jll"] +git-tree-sha1 = "962834c22b66e32aa10f7611c08c8ca4e20749a9" +uuid = "944b1d66-785c-5afd-91f1-9de20f533193" +version = "0.7.8" + +[[deps.CommonSolve]] +git-tree-sha1 = "78ea4ddbcf9c241827e7035c3a03e2e456711470" +uuid = "38540f10-b2f7-11e9-35d8-d573e4eb0ff2" +version = "0.2.6" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools"] +git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.1" + +[[deps.Compat]] +deps = ["TOML", "UUIDs"] +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" +uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" +version = "4.18.1" +weakdeps = ["Dates", "LinearAlgebra"] + + [deps.Compat.extensions] + CompatLinearAlgebraExt = "LinearAlgebra" + +[[deps.CompilerSupportLibraries_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" +version = "1.1.1+0" + +[[deps.CompositionsBase]] +git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" +uuid = "a33af91c-f02d-484b-be07-31d278c5ca2b" +version = "0.1.2" +weakdeps = ["InverseFunctions"] + + [deps.CompositionsBase.extensions] + CompositionsBaseInverseFunctionsExt = "InverseFunctions" + +[[deps.Conda]] +deps = ["Downloads", "JSON", "VersionParsing"] +git-tree-sha1 = "8f06b0cfa4c514c7b9546756dbae91fcfbc92dc9" +uuid = "8f4d0f93-b110-5947-807f-2305c1781a2d" +version = "1.10.3" + +[[deps.CondaPkg]] +deps = ["JSON", "Markdown", "MicroMamba", "Pidfile", "Pkg", "Preferences", "Scratch", "TOML", "pixi_jll"] +git-tree-sha1 = "0300af904a8c8d41ff715a60a6959136d22b8572" +uuid = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +version = "0.2.34" + +[[deps.ConsoleProgressMonitor]] +deps = ["Logging", "ProgressMeter"] +git-tree-sha1 = "3ab7b2136722890b9af903859afcf457fa3059e8" +uuid = "88cd18e8-d9cc-4ea6-8889-5259c0d15c8b" +version = "0.1.2" + +[[deps.ConstructionBase]] +git-tree-sha1 = "b4b092499347b18a015186eae3042f72267106cb" +uuid = "187b0558-2788-49d3-abe0-74a17ed4e7c9" +version = "1.6.0" +weakdeps = ["IntervalSets", "LinearAlgebra", "StaticArrays"] + + [deps.ConstructionBase.extensions] + ConstructionBaseIntervalSetsExt = "IntervalSets" + ConstructionBaseLinearAlgebraExt = "LinearAlgebra" + ConstructionBaseStaticArraysExt = "StaticArrays" + +[[deps.Crayons]] +git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15" +uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" +version = "4.1.1" + +[[deps.DataAPI]] +git-tree-sha1 = "abe83f3a2f1b857aac70ef8b269080af17764bbe" +uuid = "9a962f9c-6df0-11e9-0e5d-c546b8b5ee8a" +version = "1.16.0" + +[[deps.DataFrames]] +deps = ["Compat", "DataAPI", "DataStructures", "Future", "InlineStrings", "InvertedIndices", "IteratorInterfaceExtensions", "LinearAlgebra", "Markdown", "Missings", "PooledArrays", "PrecompileTools", "PrettyTables", "Printf", "Random", "Reexport", "SentinelArrays", "SortingAlgorithms", "Statistics", "TableTraits", "Tables", "Unicode"] +git-tree-sha1 = "d8928e9169ff76c6281f39a659f9bca3a573f24c" +uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" +version = "1.8.1" + +[[deps.DataStructures]] +deps = ["OrderedCollections"] +git-tree-sha1 = "e357641bb3e0638d353c4b29ea0e40ea644066a6" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.19.3" + +[[deps.DataValueInterfaces]] +git-tree-sha1 = "bfc1187b79289637fa0ef6d4436ebdfe6905cbd6" +uuid = "e2d170a0-9d28-54be-80f0-106bbe20a464" +version = "1.0.0" + +[[deps.Dates]] +deps = ["Printf"] +uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" + +[[deps.DefineSingletons]] +git-tree-sha1 = "0fba8b706d0178b4dc7fd44a96a92382c9065c2c" +uuid = "244e2a9f-e319-4986-a169-4d1fe445cd52" +version = "0.1.2" + +[[deps.DensityInterface]] +deps = ["InverseFunctions", "Test"] +git-tree-sha1 = "80c3e8639e3353e5d2912fb3a1916b8455e2494b" +uuid = "b429d917-457f-4dbc-8f4c-0cc954292b1d" +version = "0.4.0" + +[[deps.DiffResults]] +deps = ["StaticArraysCore"] +git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621" +uuid = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" +version = "1.1.0" + +[[deps.DiffRules]] +deps = ["IrrationalConstants", "LogExpFunctions", "NaNMath", "Random", "SpecialFunctions"] +git-tree-sha1 = "23163d55f885173722d1e4cf0f6110cdbaf7e272" +uuid = "b552c78f-8df3-52c6-915a-8e097449b14b" +version = "1.15.1" + +[[deps.DifferentiationInterface]] +deps = ["ADTypes", "LinearAlgebra"] +git-tree-sha1 = "7ae99144ea44715402c6c882bfef2adbeadbc4ce" +uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" +version = "0.7.16" + + [deps.DifferentiationInterface.extensions] + DifferentiationInterfaceChainRulesCoreExt = "ChainRulesCore" + DifferentiationInterfaceDiffractorExt = "Diffractor" + DifferentiationInterfaceEnzymeExt = ["EnzymeCore", "Enzyme"] + DifferentiationInterfaceFastDifferentiationExt = "FastDifferentiation" + DifferentiationInterfaceFiniteDiffExt = "FiniteDiff" + DifferentiationInterfaceFiniteDifferencesExt = "FiniteDifferences" + DifferentiationInterfaceForwardDiffExt = ["ForwardDiff", "DiffResults"] + DifferentiationInterfaceGPUArraysCoreExt = "GPUArraysCore" + DifferentiationInterfaceGTPSAExt = "GTPSA" + DifferentiationInterfaceMooncakeExt = "Mooncake" + DifferentiationInterfacePolyesterForwardDiffExt = ["PolyesterForwardDiff", "ForwardDiff", "DiffResults"] + DifferentiationInterfaceReverseDiffExt = ["ReverseDiff", "DiffResults"] + DifferentiationInterfaceSparseArraysExt = "SparseArrays" + DifferentiationInterfaceSparseConnectivityTracerExt = "SparseConnectivityTracer" + DifferentiationInterfaceSparseMatrixColoringsExt = "SparseMatrixColorings" + DifferentiationInterfaceStaticArraysExt = "StaticArrays" + DifferentiationInterfaceSymbolicsExt = "Symbolics" + DifferentiationInterfaceTrackerExt = "Tracker" + DifferentiationInterfaceZygoteExt = ["Zygote", "ForwardDiff"] + + [deps.DifferentiationInterface.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" + Diffractor = "9f5e2b26-1114-432f-b630-d3fe2085c51c" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + FastDifferentiation = "eb9bf01b-bf85-4b60-bf87-ee5de06c00be" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + GTPSA = "b27dd330-f138-47c5-815b-40db9dd9b6e8" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PolyesterForwardDiff = "98d1487c-24ca-40b6-b7ab-df2af84e126b" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" + SparseMatrixColorings = "0a514795-09f3-496d-8182-132a7b665d35" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + Symbolics = "0c5d862f-8b57-4792-8d23-62f2024744c7" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.DispatchDoctor]] +deps = ["MacroTools", "Preferences"] +git-tree-sha1 = "42cd00edaac86f941815fe557c1d01e11913e07c" +uuid = "8d63f2c5-f18a-4cf2-ba9d-b3f60fc568c8" +version = "0.4.28" +weakdeps = ["ChainRulesCore", "EnzymeCore"] + + [deps.DispatchDoctor.extensions] + DispatchDoctorChainRulesCoreExt = "ChainRulesCore" + DispatchDoctorEnzymeCoreExt = "EnzymeCore" + +[[deps.Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" + +[[deps.Distributions]] +deps = ["AliasTables", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] +git-tree-sha1 = "fbcc7610f6d8348428f722ecbe0e6cfe22e672c6" +uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" +version = "0.25.123" +weakdeps = ["ChainRulesCore", "DensityInterface", "Test"] + + [deps.Distributions.extensions] + DistributionsChainRulesCoreExt = "ChainRulesCore" + DistributionsDensityInterfaceExt = "DensityInterface" + DistributionsTestExt = "Test" + +[[deps.DocStringExtensions]] +git-tree-sha1 = "7442a5dfe1ebb773c29cc2962a8980f47221d76c" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.5" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.6.0" + +[[deps.DynamicPPL]] +deps = ["ADTypes", "AbstractMCMC", "AbstractPPL", "Accessors", "BangBang", "Bijectors", "Chairmarks", "Compat", "ConstructionBase", "DifferentiationInterface", "Distributions", "DocStringExtensions", "FillArrays", "InteractiveUtils", "LinearAlgebra", "LogDensityProblems", "MacroTools", "OrderedCollections", "PrecompileTools", "Printf", "Random", "Statistics", "Test"] +git-tree-sha1 = "14ded43f8a62568b17efc62d9f04491a2d4d8c9b" +uuid = "366bfd00-2699-11ea-058f-f148b4cae6d8" +version = "0.40.14" + + [deps.DynamicPPL.extensions] + DynamicPPLEnzymeCoreExt = ["EnzymeCore"] + DynamicPPLForwardDiffExt = ["ForwardDiff"] + DynamicPPLMCMCChainsExt = ["MCMCChains"] + DynamicPPLMarginalLogDensitiesExt = ["MarginalLogDensities"] + DynamicPPLMooncakeExt = ["Mooncake", "DifferentiationInterface"] + DynamicPPLReverseDiffExt = ["ReverseDiff"] + + [deps.DynamicPPL.weakdeps] + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" + MarginalLogDensities = "f0c3360a-fb8d-11e9-1194-5521fd7ee392" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + +[[deps.EllipticalSliceSampling]] +deps = ["AbstractMCMC", "ArrayInterface", "Distributions", "Random", "Statistics"] +git-tree-sha1 = "e611b7fdfbfb5b18d5e98776c30daede41b44542" +uuid = "cad2338a-1db2-11e9-3401-43bc07c9ede2" +version = "2.0.0" + +[[deps.EnumX]] +git-tree-sha1 = "c49898e8438c828577f04b92fc9368c388ac783c" +uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" +version = "1.0.7" + +[[deps.Enzyme]] +deps = ["CEnum", "EnzymeCore", "Enzyme_jll", "GPUCompiler", "InteractiveUtils", "LLVM", "Libdl", "LinearAlgebra", "ObjectFile", "PrecompileTools", "Preferences", "Printf", "Random", "SparseArrays"] +git-tree-sha1 = "ea65d3121f09b5f31102542db9445163b7c99182" +uuid = "7da242da-08ed-463a-9acd-ee780be4f1d9" +version = "0.13.129" + + [deps.Enzyme.extensions] + EnzymeBFloat16sExt = "BFloat16s" + EnzymeChainRulesCoreExt = "ChainRulesCore" + EnzymeGPUArraysCoreExt = "GPUArraysCore" + EnzymeLogExpFunctionsExt = "LogExpFunctions" + EnzymeSpecialFunctionsExt = "SpecialFunctions" + EnzymeStaticArraysExt = "StaticArrays" + + [deps.Enzyme.weakdeps] + ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b" + BFloat16s = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.EnzymeCore]] +git-tree-sha1 = "990991b8aa76d17693a98e3a915ac7aa49f08d1a" +uuid = "f151be2c-9106-41f4-ab19-57ee4f262869" +version = "0.8.18" +weakdeps = ["Adapt", "ChainRulesCore"] + + [deps.EnzymeCore.extensions] + AdaptExt = "Adapt" + EnzymeCoreChainRulesCoreExt = "ChainRulesCore" + +[[deps.Enzyme_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"] +git-tree-sha1 = "fea21cfc452db42e3878aab62a76896e76d54d12" +uuid = "7cc45869-7501-5eee-bdea-0790c847d4ef" +version = "0.0.249+0" + +[[deps.ExprTools]] +git-tree-sha1 = "27415f162e6028e81c72b82ef756bf321213b6ec" +uuid = "e2ba6199-217a-4e67-a87a-7c52f15ade04" +version = "0.1.10" + +[[deps.ExproniconLite]] +git-tree-sha1 = "c13f0b150373771b0fdc1713c97860f8df12e6c2" +uuid = "55351af7-c7e9-48d6-89ff-24e801d99491" +version = "0.10.14" + +[[deps.FFTA]] +deps = ["AbstractFFTs", "DocStringExtensions", "LinearAlgebra", "MuladdMacro", "Primes", "Random", "Reexport"] +git-tree-sha1 = "65e55303b72f4a567a51b174dd2c47496efeb95a" +uuid = "b86e33f2-c0db-4aa1-a6e0-ab43e668529e" +version = "0.3.1" + +[[deps.FastClosures]] +git-tree-sha1 = "acebe244d53ee1b461970f8910c235b259e772ef" +uuid = "9aa1b823-49e4-5ca5-8b0f-3971ec8bab6a" +version = "0.3.2" + +[[deps.FilePathsBase]] +deps = ["Compat", "Dates"] +git-tree-sha1 = "3bab2c5aa25e7840a4b065805c0cdfc01f3068d2" +uuid = "48062228-2e41-5def-b9a4-89aafe57970f" +version = "0.9.24" +weakdeps = ["Mmap", "Test"] + + [deps.FilePathsBase.extensions] + FilePathsBaseMmapExt = "Mmap" + FilePathsBaseTestExt = "Test" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" + +[[deps.FillArrays]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "2f979084d1e13948a3352cf64a25df6bd3b4dca3" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.16.0" +weakdeps = ["PDMats", "SparseArrays", "StaticArrays", "Statistics"] + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + FillArraysStaticArraysExt = "StaticArrays" + FillArraysStatisticsExt = "Statistics" + +[[deps.FiniteDiff]] +deps = ["ArrayInterface", "LinearAlgebra", "Setfield"] +git-tree-sha1 = "9340ca07ca27093ff68418b7558ca37b05f8aeb1" +uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" +version = "2.29.0" + + [deps.FiniteDiff.extensions] + FiniteDiffBandedMatricesExt = "BandedMatrices" + FiniteDiffBlockBandedMatricesExt = "BlockBandedMatrices" + FiniteDiffSparseArraysExt = "SparseArrays" + FiniteDiffStaticArraysExt = "StaticArrays" + + [deps.FiniteDiff.weakdeps] + BandedMatrices = "aae01518-5342-5314-be14-df237901396f" + BlockBandedMatrices = "ffab5731-97b5-5995-9138-79e8c1846df0" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "eef4c86803f47dcb61e9b8790ecaa96956fdd8ae" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "1.3.2" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + +[[deps.FunctionWrappers]] +git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.1.3" + +[[deps.FunctionWrappersWrappers]] +deps = ["FunctionWrappers"] +git-tree-sha1 = "b104d487b34566608f8b4e1c39fb0b10aa279ff8" +uuid = "77dc65aa-8811-40c2-897b-53d922fa7daf" +version = "0.1.3" + +[[deps.Functors]] +deps = ["Compat", "ConstructionBase", "LinearAlgebra", "Random"] +git-tree-sha1 = "60a0339f28a233601cb74468032b5c302d5067de" +uuid = "d9f16b24-f501-4c13-a1f2-28368ffc5196" +version = "0.5.2" + +[[deps.Future]] +deps = ["Random"] +uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" + +[[deps.GPUArraysCore]] +deps = ["Adapt"] +git-tree-sha1 = "83cf05ab16a73219e5f6bd1bdfa9848fa24ac627" +uuid = "46192b85-c4d5-4398-a991-12ede77f4527" +version = "0.2.0" + +[[deps.GPUCompiler]] +deps = ["ExprTools", "InteractiveUtils", "LLVM", "Libdl", "Logging", "PrecompileTools", "Preferences", "Scratch", "Serialization", "TOML", "Tracy", "UUIDs"] +git-tree-sha1 = "966946d226e8b676ca6409454718accb18c34c54" +uuid = "61eb1bfa-7361-4325-ad38-22787b887f55" +version = "1.8.2" + +[[deps.Graphs]] +deps = ["ArnoldiMethod", "DataStructures", "Inflate", "LinearAlgebra", "Random", "SimpleTraits", "SparseArrays", "Statistics"] +git-tree-sha1 = "7eb45fe833a5b7c51cf6d89c5a841d5967e44be3" +uuid = "86223c79-3864-5bf0-83f7-82e725a168b6" +version = "1.14.0" +weakdeps = ["Distributed", "SharedArrays"] + + [deps.Graphs.extensions] + GraphsSharedArraysExt = "SharedArrays" + +[[deps.HypergeometricFunctions]] +deps = ["LinearAlgebra", "OpenLibm_jll", "SpecialFunctions"] +git-tree-sha1 = "68c173f4f449de5b438ee67ed0c9c748dc31a2ec" +uuid = "34004b35-14d8-5ef3-9330-4cdb6864b03a" +version = "0.3.28" + +[[deps.Inflate]] +git-tree-sha1 = "d1b1b796e47d94588b3757fe84fbf65a5ec4a80d" +uuid = "d25df0c9-e2be-5dd7-82c8-3ad0b3e990b9" +version = "0.1.5" + +[[deps.InitialValues]] +git-tree-sha1 = "4da0f88e9a39111c2fa3add390ab15f3a44f3ca3" +uuid = "22cec73e-a1b8-11e9-2c92-598750a2cf9c" +version = "0.3.1" + +[[deps.InlineStrings]] +git-tree-sha1 = "8f3d257792a522b4601c24a577954b0a8cd7334d" +uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48" +version = "1.4.5" + + [deps.InlineStrings.extensions] + ArrowTypesExt = "ArrowTypes" + ParsersExt = "Parsers" + + [deps.InlineStrings.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + Parsers = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" + +[[deps.IntegerMathUtils]] +git-tree-sha1 = "4c1acff2dc6b6967e7e750633c50bc3b8d83e617" +uuid = "18e54dd8-cb9d-406c-a71d-865a43cbb235" +version = "0.1.3" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" + +[[deps.Interpolations]] +deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"] +git-tree-sha1 = "65d505fa4c0d7072990d659ef3fc086eb6da8208" +uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" +version = "0.16.2" + + [deps.Interpolations.extensions] + InterpolationsForwardDiffExt = "ForwardDiff" + InterpolationsUnitfulExt = "Unitful" + + [deps.Interpolations.weakdeps] + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.IntervalSets]] +git-tree-sha1 = "d966f85b3b7a8e49d034d27a189e9a4874b4391a" +uuid = "8197267c-284f-5f27-9208-e0e47529a953" +version = "0.7.13" +weakdeps = ["Random", "RecipesBase", "Statistics"] + + [deps.IntervalSets.extensions] + IntervalSetsRandomExt = "Random" + IntervalSetsRecipesBaseExt = "RecipesBase" + IntervalSetsStatisticsExt = "Statistics" + +[[deps.InverseFunctions]] +git-tree-sha1 = "a779299d77cd080bf77b97535acecd73e1c5e5cb" +uuid = "3587e190-3f89-42d0-90ee-14403ec27112" +version = "0.1.17" +weakdeps = ["Dates", "Test"] + + [deps.InverseFunctions.extensions] + InverseFunctionsDatesExt = "Dates" + InverseFunctionsTestExt = "Test" + +[[deps.InvertedIndices]] +git-tree-sha1 = "6da3c4316095de0f5ee2ebd875df8721e7e0bdbe" +uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f" +version = "1.3.1" + +[[deps.IrrationalConstants]] +git-tree-sha1 = "b2d91fe939cae05960e760110b328288867b5758" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.2.6" + +[[deps.IterTools]] +git-tree-sha1 = "42d5f897009e7ff2cf88db414a389e5ed1bdd023" +uuid = "c8e1da08-722c-5040-9ed9-7db0dc04731e" +version = "1.10.0" + +[[deps.IteratorInterfaceExtensions]] +git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" +uuid = "82899510-4779-5014-852e-03e436cf321d" +version = "1.0.0" + +[[deps.JLLWrappers]] +deps = ["Artifacts", "Preferences"] +git-tree-sha1 = "0533e564aae234aff59ab625543145446d8b6ec2" +uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" +version = "1.7.1" + +[[deps.JSON]] +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "b3ad4a0255688dcb895a52fafbaae3023b588a90" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.4.0" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + +[[deps.Jieko]] +deps = ["ExproniconLite"] +git-tree-sha1 = "2f05ed29618da60c06a87e9c033982d4f71d0b6c" +uuid = "ae98c720-c025-4a4a-838c-29b094483192" +version = "0.2.1" + +[[deps.KernelDensity]] +deps = ["Distributions", "DocStringExtensions", "FFTA", "Interpolations", "StatsBase"] +git-tree-sha1 = "4260cfc991b8885bf747801fb60dd4503250e478" +uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b" +version = "0.6.11" + +[[deps.LLVM]] +deps = ["CEnum", "LLVMExtra_jll", "Libdl", "Preferences", "Printf", "Unicode"] +git-tree-sha1 = "69e4739502b7ab5176117e97e1664ed181c35036" +uuid = "929cbde3-209d-540e-8aea-75f648917ca0" +version = "9.4.6" + + [deps.LLVM.extensions] + BFloat16sExt = "BFloat16s" + + [deps.LLVM.weakdeps] + BFloat16s = "ab4f0b2a-ad5b-11e8-123f-65d77653426b" + +[[deps.LLVMExtra_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl", "TOML"] +git-tree-sha1 = "8e76807afb59ebb833e9b131ebf1a8c006510f33" +uuid = "dad2f222-ce93-54a1-a47d-0025e8a3acab" +version = "0.0.38+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.0" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" + +[[deps.LeftChildRightSiblingTrees]] +deps = ["AbstractTrees"] +git-tree-sha1 = "95ba48564903b43b2462318aa243ee79d81135ff" +uuid = "1d6d02ad-be62-4b6b-8a6d-2f90e265016e" +version = "0.2.1" + +[[deps.LibCURL]] +deps = ["LibCURL_jll", "MozillaCACerts_jll"] +uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" +version = "0.6.4" + +[[deps.LibCURL_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] +uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" +version = "8.4.0+0" + +[[deps.LibGit2]] +deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.6.4+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.0+1" + +[[deps.LibTracyClient_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d4e20500d210247322901841d4eafc7a0c52642d" +uuid = "ad6e5548-8b26-5c9f-8ef3-ef0ad883f3a5" +version = "0.13.1+0" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" + +[[deps.Libtask]] +deps = ["MistyClosures", "Test"] +git-tree-sha1 = "c54cab5deb43c7efaad9140adb7419f4c34bf380" +uuid = "6f1fad26-d15e-5dc8-ae53-837a1d7b8c9f" +version = "0.9.15" + +[[deps.LineSearches]] +deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Printf"] +git-tree-sha1 = "738bdcacfef25b3a9e4a39c28613717a6b23751e" +uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +version = "7.6.0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + +[[deps.LogDensityProblems]] +deps = ["ArgCheck", "DocStringExtensions", "Random"] +git-tree-sha1 = "d9625f27ded4ad726ceca7819394a4cc77ed25b3" +uuid = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c" +version = "2.2.0" + +[[deps.LogDensityProblemsAD]] +deps = ["DocStringExtensions", "LogDensityProblems"] +git-tree-sha1 = "7b83f3ad0a8105f79a067cafbfd124827bb398d0" +uuid = "996a588d-648d-4e1f-a8f0-a84b347e47b1" +version = "1.13.1" + + [deps.LogDensityProblemsAD.extensions] + LogDensityProblemsADADTypesExt = "ADTypes" + LogDensityProblemsADDifferentiationInterfaceExt = ["ADTypes", "DifferentiationInterface"] + LogDensityProblemsADEnzymeExt = "Enzyme" + LogDensityProblemsADFiniteDifferencesExt = "FiniteDifferences" + LogDensityProblemsADForwardDiffBenchmarkToolsExt = ["BenchmarkTools", "ForwardDiff"] + LogDensityProblemsADForwardDiffExt = "ForwardDiff" + LogDensityProblemsADReverseDiffExt = "ReverseDiff" + LogDensityProblemsADTrackerExt = "Tracker" + LogDensityProblemsADZygoteExt = "Zygote" + + [deps.LogDensityProblemsAD.weakdeps] + ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b" + BenchmarkTools = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" + DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + FiniteDifferences = "26cc04aa-876d-5657-8c51-4c34ba976000" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "0.3.29" +weakdeps = ["ChainRulesCore", "ChangesOfVariables", "InverseFunctions"] + + [deps.LogExpFunctions.extensions] + LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" + LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" + LogExpFunctionsInverseFunctionsExt = "InverseFunctions" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" + +[[deps.LoggingExtras]] +deps = ["Dates", "Logging"] +git-tree-sha1 = "f00544d95982ea270145636c181ceda21c4e2575" +uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" +version = "1.2.0" + +[[deps.MCMCChains]] +deps = ["AbstractMCMC", "AxisArrays", "DataAPI", "Dates", "Distributions", "IteratorInterfaceExtensions", "KernelDensity", "LinearAlgebra", "MCMCDiagnosticTools", "MLJModelInterface", "NaturalSort", "OrderedCollections", "PrettyTables", "Random", "RecipesBase", "Statistics", "StatsBase", "StatsFuns", "TableTraits", "Tables"] +git-tree-sha1 = "060d6bc7cf60e621dfd056ed2c1a2db1e68db0fe" +uuid = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" +version = "7.7.0" + +[[deps.MCMCDiagnosticTools]] +deps = ["AbstractFFTs", "DataAPI", "DataStructures", "Distributions", "LinearAlgebra", "MLJModelInterface", "Random", "SpecialFunctions", "Statistics", "StatsBase", "StatsFuns", "Tables"] +git-tree-sha1 = "f90494689e927268dec7bbd1ece64f134ad251f4" +uuid = "be115224-59cd-429b-ad48-344e309966f0" +version = "0.3.16" + +[[deps.MLJModelInterface]] +deps = ["InteractiveUtils", "REPL", "Random", "ScientificTypesBase", "StatisticalTraits"] +git-tree-sha1 = "c275fae2e693206b4527dd9d2382aa15359ef3ed" +uuid = "e80e1ace-859a-464e-9ed9-23947d8ae3ea" +version = "1.12.1" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.MappedArrays]] +git-tree-sha1 = "0ee4497a4e80dbd29c058fcee6493f5219556f40" +uuid = "dbb5928d-eab1-5f90-85c2-b9b0edb7c900" +version = "0.4.3" + +[[deps.Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" + +[[deps.MbedTLS_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.1010+0" + +[[deps.MicroCollections]] +deps = ["Accessors", "BangBang", "InitialValues"] +git-tree-sha1 = "44d32db644e84c75dab479f1bc15ee76a1a3618f" +uuid = "128add7d-3638-4c79-886c-908ea0c25c34" +version = "0.2.0" + +[[deps.MicroMamba]] +deps = ["Pkg", "Scratch", "micromamba_jll"] +git-tree-sha1 = "535656ce55266bfed0575cd051acc4f36dc869a0" +uuid = "0b3b1443-0f03-428d-bdfb-f27f9c1191ea" +version = "0.1.15" + +[[deps.Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "1.2.0" + +[[deps.MistyClosures]] +git-tree-sha1 = "d1a692e293c2a0dc8fda79c04cad60582f3d4de3" +uuid = "dbe65cb8-6be2-42dd-bbc5-4196aaced4f4" +version = "2.1.0" + +[[deps.Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" + +[[deps.Mooncake]] +deps = ["ADTypes", "ChainRules", "ChainRulesCore", "DispatchDoctor", "ExprTools", "Graphs", "LinearAlgebra", "MistyClosures", "PrecompileTools", "Random", "Test"] +git-tree-sha1 = "8a790060135e8740badf9a3c52c9a9853ccd3706" +uuid = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" +version = "0.5.19" + + [deps.Mooncake.extensions] + MooncakeAllocCheckExt = "AllocCheck" + MooncakeCUDAExt = "CUDA" + MooncakeDistributionsExt = "Distributions" + MooncakeDynamicExpressionsExt = "DynamicExpressions" + MooncakeFluxExt = "Flux" + MooncakeFunctionWrappersExt = "FunctionWrappers" + MooncakeJETExt = "JET" + MooncakeLogExpFunctionsExt = "LogExpFunctions" + MooncakeLuxLibExt = ["LuxLib", "MLDataDevices", "Static"] + MooncakeLuxLibSLEEFPiratesExtension = ["LuxLib", "SLEEFPirates"] + MooncakeNNlibExt = ["NNlib", "GPUArraysCore"] + MooncakeSpecialFunctionsExt = "SpecialFunctions" + + [deps.Mooncake.weakdeps] + AllocCheck = "9b6a8646-10ed-4001-bbdc-1d2f46dfbb1a" + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + DynamicExpressions = "a40a106e-89c9-4ca8-8020-a735e8728b6b" + Flux = "587475ba-b771-5e3f-ad9e-33799f191a9c" + FunctionWrappers = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + JET = "c3a54625-cd67-489e-a8e7-0a5a0ff4e31b" + LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688" + LuxLib = "82251201-b29d-42c6-8e01-566dec8acb11" + MLDataDevices = "7e8f7934-dd98-4c1a-8fe8-92b47a384d40" + NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" + SLEEFPirates = "476501e8-09a2-5ece-8869-fb82de89a1fa" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + Static = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" + +[[deps.Moshi]] +deps = ["ExproniconLite", "Jieko"] +git-tree-sha1 = "53f817d3e84537d84545e0ad749e483412dd6b2a" +uuid = "2e0e35c7-a2e4-4343-998d-7ef72827ed2d" +version = "0.3.7" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2025.12.2" + +[[deps.MuladdMacro]] +git-tree-sha1 = "cac9cc5499c25554cba55cd3c30543cff5ca4fab" +uuid = "46d2c3a1-f734-5fdb-9937-b9b9aeba4221" +version = "0.2.4" + +[[deps.NLSolversBase]] +deps = ["ADTypes", "DifferentiationInterface", "FiniteDiff", "LinearAlgebra"] +git-tree-sha1 = "b3f76b463c7998473062992b246045e6961a074e" +uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" +version = "8.0.0" + +[[deps.NaNMath]] +deps = ["OpenLibm_jll"] +git-tree-sha1 = "9b8215b1ee9e78a293f99797cd31375471b2bcae" +uuid = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" +version = "1.1.3" + +[[deps.NaturalSort]] +git-tree-sha1 = "eda490d06b9f7c00752ee81cfa451efe55521e21" +uuid = "c020b1a1-e9b0-503a-9c33-f039bfc54a85" +version = "1.0.0" + +[[deps.NetworkOptions]] +uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" +version = "1.2.0" + +[[deps.ObjectFile]] +deps = ["Reexport", "StructIO"] +git-tree-sha1 = "22faba70c22d2f03e60fbc61da99c4ebfc3eb9ba" +uuid = "d8793406-e978-5875-9003-1fc021f44a92" +version = "0.5.0" + +[[deps.OffsetArrays]] +git-tree-sha1 = "117432e406b5c023f665fa73dc26e79ec3630151" +uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" +version = "1.17.0" +weakdeps = ["Adapt"] + + [deps.OffsetArrays.extensions] + OffsetArraysAdaptExt = "Adapt" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.23+5" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.5+0" + +[[deps.OpenSpecFun_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1346c9208249809840c91b26703912dff463d335" +uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" +version = "0.5.6+0" + +[[deps.Optim]] +deps = ["ADTypes", "EnumX", "FillArrays", "LineSearches", "LinearAlgebra", "NLSolversBase", "NaNMath", "PositiveFactorizations", "Printf", "SparseArrays", "Statistics"] +git-tree-sha1 = "7957b66b4e80f1031417197099f35273f7dd93dd" +uuid = "429524aa-4258-5aef-a3af-852621145aeb" +version = "2.0.1" + + [deps.Optim.extensions] + OptimMOIExt = "MathOptInterface" + + [deps.Optim.weakdeps] + MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" + +[[deps.Optimisers]] +deps = ["ChainRulesCore", "ConstructionBase", "Functors", "LinearAlgebra", "Random", "Statistics"] +git-tree-sha1 = "36b5d2b9dd06290cd65fcf5bdbc3a551ed133af5" +uuid = "3bd65402-5787-11e9-1adc-39752487f4e2" +version = "0.4.7" + + [deps.Optimisers.extensions] + OptimisersAdaptExt = ["Adapt"] + OptimisersEnzymeCoreExt = "EnzymeCore" + OptimisersReactantExt = "Reactant" + + [deps.Optimisers.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + Reactant = "3c362404-f566-11ee-1572-e11a4b42c853" + +[[deps.Optimization]] +deps = ["ADTypes", "ArrayInterface", "ConsoleProgressMonitor", "DocStringExtensions", "LinearAlgebra", "Logging", "LoggingExtras", "OptimizationBase", "Printf", "Reexport", "SciMLBase", "SparseArrays", "TerminalLoggers"] +git-tree-sha1 = "2c409c814c2d745620fdd55391a66ee514561146" +uuid = "7f7a1694-90dd-40f0-9382-eb1efda571ba" +version = "5.5.0" + +[[deps.OptimizationBase]] +deps = ["ADTypes", "ArrayInterface", "DifferentiationInterface", "DocStringExtensions", "FastClosures", "LinearAlgebra", "PDMats", "PrecompileTools", "Reexport", "SciMLBase", "SciMLLogging", "SparseArrays", "SparseConnectivityTracer", "SparseMatrixColorings", "SymbolicIndexingInterface"] +git-tree-sha1 = "a3d7837832e515111c95a02df7dc55edbdf17d8a" +uuid = "bca83a33-5cc9-4baa-983d-23429ab6bcbb" +version = "5.1.0" + + [deps.OptimizationBase.extensions] + OptimizationChainRulesCoreExt = "ChainRulesCore" + OptimizationEnzymeExt = ["ChainRulesCore", "Enzyme"] + OptimizationFiniteDiffExt = "FiniteDiff" + OptimizationForwardDiffExt = "ForwardDiff" + OptimizationMLDataDevicesExt = "MLDataDevices" + OptimizationMLUtilsExt = "MLUtils" + OptimizationMooncakeExt = "Mooncake" + OptimizationReverseDiffExt = "ReverseDiff" + OptimizationSymbolicAnalysisExt = "SymbolicAnalysis" + OptimizationZygoteExt = "Zygote" + + [deps.OptimizationBase.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + FiniteDiff = "6a86dc24-6348-571c-b903-95158fe2bd41" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + MLDataDevices = "7e8f7934-dd98-4c1a-8fe8-92b47a384d40" + MLUtils = "f1d291b0-491e-4a28-83b9-f70985020b54" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SymbolicAnalysis = "4297ee4d-0239-47d8-ba5d-195ecdf594fe" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.OptimizationOptimJL]] +deps = ["Optim", "OptimizationBase", "Reexport", "SciMLBase", "SparseArrays"] +git-tree-sha1 = "eb89577770d4a956010745f182ebea9d8ea714f8" +uuid = "36348300-93cb-4f02-beb5-3c3902f8871e" +version = "0.4.11" + +[[deps.OrderedCollections]] +git-tree-sha1 = "05868e21324cede2207c6f0f466b4bfef6d5e7ee" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.8.1" + +[[deps.PDMats]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "e4cff168707d441cd6bf3ff7e4832bdf34278e4a" +uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" +version = "0.11.37" +weakdeps = ["StatsBase"] + + [deps.PDMats.extensions] + StatsBaseExt = "StatsBase" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "7d2f8f21da5db6a806faf7b9b292296da42b2810" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.8.3" + +[[deps.Pidfile]] +deps = ["FileWatching", "Test"] +git-tree-sha1 = "2d8aaf8ee10df53d0dfb9b8ee44ae7c04ced2b03" +uuid = "fa939f87-e72e-5be4-a000-7fc836dbe307" +version = "1.3.0" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.10.0" + +[[deps.PooledArrays]] +deps = ["DataAPI", "Future"] +git-tree-sha1 = "36d8b4b899628fb92c2749eb488d884a926614d3" +uuid = "2dfb63ee-cc39-5dd5-95bd-886bf059d720" +version = "1.4.3" + +[[deps.PositiveFactorizations]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "17275485f373e6673f7e7f97051f703ed5b15b20" +uuid = "85a6dd25-e78a-55b7-8502-1745935b8125" +version = "0.2.4" + +[[deps.PreallocationTools]] +deps = ["Adapt", "ArrayInterface", "PrecompileTools"] +git-tree-sha1 = "dc8d6bde5005a0eac05ae8faf1eceaaca166cfa4" +uuid = "d236fae5-4411-538c-8e31-a6e3d9e00b46" +version = "1.1.2" + + [deps.PreallocationTools.extensions] + PreallocationToolsForwardDiffExt = "ForwardDiff" + PreallocationToolsReverseDiffExt = "ReverseDiff" + PreallocationToolsSparseConnectivityTracerExt = "SparseConnectivityTracer" + + [deps.PreallocationTools.weakdeps] + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseConnectivityTracer = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" + +[[deps.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "5aa36f7049a63a1528fe8f7c3f2113413ffd4e1f" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.2.1" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "8b770b60760d4451834fe79dd483e318eee709c4" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.5.2" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "REPL", "Reexport", "StringManipulation", "Tables"] +git-tree-sha1 = "211530a7dc76ab59087f4d4d1fc3f086fbe87594" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "3.2.3" + + [deps.PrettyTables.extensions] + PrettyTablesTypstryExt = "Typstry" + + [deps.PrettyTables.weakdeps] + Typstry = "f0ed7684-a786-439e-b1e3-3b82803b501e" + +[[deps.Primes]] +deps = ["IntegerMathUtils"] +git-tree-sha1 = "25cdd1d20cd005b52fc12cb6be3f75faaf59bb9b" +uuid = "27ebfcd6-29c5-5fa9-bf4b-fb8fc14df3ae" +version = "0.5.7" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" + +[[deps.ProgressLogging]] +deps = ["Logging", "SHA", "UUIDs"] +git-tree-sha1 = "f0803bc1171e455a04124affa9c21bba5ac4db32" +uuid = "33c8b6b6-d38a-422a-b730-caa89a2f386c" +version = "0.1.6" + +[[deps.ProgressMeter]] +deps = ["Distributed", "Printf"] +git-tree-sha1 = "fbb92c6c56b34e1a2c4c36058f68f332bec840e7" +uuid = "92933f4c-e287-5a05-a399-4b506db050ca" +version = "1.11.0" + +[[deps.PtrArrays]] +git-tree-sha1 = "4fbbafbc6251b883f4d2705356f3641f3652a7fe" +uuid = "43287f4e-b6f4-7ad1-bb20-aadabca52c3d" +version = "1.4.0" + +[[deps.PythonCall]] +deps = ["CondaPkg", "Dates", "Libdl", "MacroTools", "Markdown", "Pkg", "Serialization", "Tables", "UnsafePointers"] +git-tree-sha1 = "982f3f017f08d31202574ef6bdcf8b3466430bea" +uuid = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +version = "0.9.31" + + [deps.PythonCall.extensions] + CategoricalArraysExt = "CategoricalArrays" + PyCallExt = "PyCall" + + [deps.PythonCall.weakdeps] + CategoricalArrays = "324d7699-5711-5eae-9e2f-1d82baa6b597" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + +[[deps.QuadGK]] +deps = ["DataStructures", "LinearAlgebra"] +git-tree-sha1 = "9da16da70037ba9d701192e27befedefb91ec284" +uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" +version = "2.11.2" +weakdeps = ["Enzyme"] + + [deps.QuadGK.extensions] + QuadGKEnzymeExt = "Enzyme" + +[[deps.RCall]] +deps = ["CategoricalArrays", "Conda", "DataFrames", "DataStructures", "Dates", "Libdl", "Preferences", "REPL", "Random", "StatsModels", "WinReg"] +git-tree-sha1 = "0ea46f30de5b17d7bd8eaaadb431b0a9ae494a48" +uuid = "6f49c342-dc21-5d91-9882-a32aef131414" +version = "0.14.12" +weakdeps = ["AxisArrays"] + + [deps.RCall.extensions] + RCallAxisArraysExt = ["AxisArrays"] + +[[deps.REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" + +[[deps.Random123]] +deps = ["Random", "RandomNumbers"] +git-tree-sha1 = "dbe5fd0b334694e905cb9fda73cd8554333c46e2" +uuid = "74087812-796a-5b5d-8853-05524746bad3" +version = "1.7.1" + +[[deps.RandomNumbers]] +deps = ["Random"] +git-tree-sha1 = "c6ec94d2aaba1ab2ff983052cf6a606ca5985902" +uuid = "e6cf234a-135c-5ec9-84dd-332b85af5143" +version = "1.6.0" + +[[deps.RangeArrays]] +git-tree-sha1 = "b9039e93773ddcfc828f12aadf7115b4b4d225f5" +uuid = "b3c3ace0-ae52-54e7-9d0b-2c1406fd6b9d" +version = "0.3.2" + +[[deps.Ratios]] +deps = ["Requires"] +git-tree-sha1 = "1342a47bf3260ee108163042310d26f2be5ec90b" +uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439" +version = "0.4.5" + + [deps.Ratios.extensions] + RatiosFixedPointNumbersExt = "FixedPointNumbers" + + [deps.Ratios.weakdeps] + FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" + +[[deps.RealDot]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "9f0a1b71baaf7650f4fa8a1d168c7fb6ee41f0c9" +uuid = "c1ae055f-0cd5-4b69-90a6-9a35b1a98df9" +version = "0.1.0" + +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + +[[deps.RecursiveArrayTools]] +deps = ["Adapt", "ArrayInterface", "DocStringExtensions", "GPUArraysCore", "LinearAlgebra", "PrecompileTools", "RecipesBase", "StaticArraysCore", "SymbolicIndexingInterface"] +git-tree-sha1 = "18d2a6fd1ea9a8205cadb3a5704f8e51abdd748b" +uuid = "731186ca-8d62-57ce-b412-fbd966d074cd" +version = "3.48.0" + + [deps.RecursiveArrayTools.extensions] + RecursiveArrayToolsFastBroadcastExt = "FastBroadcast" + RecursiveArrayToolsForwardDiffExt = "ForwardDiff" + RecursiveArrayToolsKernelAbstractionsExt = "KernelAbstractions" + RecursiveArrayToolsMeasurementsExt = "Measurements" + RecursiveArrayToolsMonteCarloMeasurementsExt = "MonteCarloMeasurements" + RecursiveArrayToolsReverseDiffExt = ["ReverseDiff", "Zygote"] + RecursiveArrayToolsSparseArraysExt = ["SparseArrays"] + RecursiveArrayToolsStatisticsExt = "Statistics" + RecursiveArrayToolsStructArraysExt = "StructArrays" + RecursiveArrayToolsTablesExt = ["Tables"] + RecursiveArrayToolsTrackerExt = "Tracker" + RecursiveArrayToolsZygoteExt = "Zygote" + + [deps.RecursiveArrayTools.weakdeps] + FastBroadcast = "7034ab61-46d4-4ed7-9d0f-46aef9175898" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.1" + +[[deps.Rmath]] +deps = ["Random", "Rmath_jll"] +git-tree-sha1 = "5b3d50eb374cea306873b371d3f8d3915a018f0b" +uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa" +version = "0.9.0" + +[[deps.Rmath_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "58cdd8fb2201a6267e1db87ff148dd6c1dbd8ad8" +uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" +version = "0.5.1+0" + +[[deps.Roots]] +deps = ["Accessors", "CommonSolve", "Printf"] +git-tree-sha1 = "10a488dbecb88a9679c8f357d383d7d83dcc748d" +uuid = "f2b01f46-fcfa-551c-844a-d8ac1e96c665" +version = "2.2.13" + + [deps.Roots.extensions] + RootsChainRulesCoreExt = "ChainRulesCore" + RootsForwardDiffExt = "ForwardDiff" + RootsIntervalRootFindingExt = "IntervalRootFinding" + RootsSymPyExt = "SymPy" + RootsSymPyPythonCallExt = "SymPyPythonCall" + RootsUnitfulExt = "Unitful" + + [deps.Roots.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + IntervalRootFinding = "d2bf35a9-74e0-55ec-b149-d360ff49b807" + SymPy = "24249f21-da20-56a4-8eb1-6a02cf4ae2e6" + SymPyPythonCall = "bc8888f7-b21e-4b7c-a06a-5d9c9496438c" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.RuntimeGeneratedFunctions]] +deps = ["ExprTools", "SHA", "Serialization"] +git-tree-sha1 = "7257165d5477fd1025f7cb656019dcb6b0512c38" +uuid = "7e49a35a-f44a-4d26-94aa-eba1b4ca6b47" +version = "0.5.17" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.SSMProblems]] +deps = ["AbstractMCMC", "Distributions", "Random"] +git-tree-sha1 = "cbf723e4c486375cf91236db53a7beefe8291951" +uuid = "26aad666-b158-4e64-9d35-0e672562fa48" +version = "0.6.1" + +[[deps.SciMLBase]] +deps = ["ADTypes", "Accessors", "Adapt", "ArrayInterface", "CommonSolve", "ConstructionBase", "Distributed", "DocStringExtensions", "EnumX", "FunctionWrappersWrappers", "IteratorInterfaceExtensions", "LinearAlgebra", "Logging", "Markdown", "Moshi", "PreallocationTools", "PrecompileTools", "Preferences", "Printf", "RecipesBase", "RecursiveArrayTools", "Reexport", "RuntimeGeneratedFunctions", "SciMLLogging", "SciMLOperators", "SciMLPublic", "SciMLStructures", "StaticArraysCore", "Statistics", "SymbolicIndexingInterface"] +git-tree-sha1 = "0be0208add9b6836a701e0ac3ad30bda72fee51d" +uuid = "0bca4576-84f4-4d90-8ffe-ffa030f20462" +version = "2.150.0" + + [deps.SciMLBase.extensions] + SciMLBaseChainRulesCoreExt = "ChainRulesCore" + SciMLBaseDifferentiationInterfaceExt = "DifferentiationInterface" + SciMLBaseDistributionsExt = "Distributions" + SciMLBaseEnzymeExt = "Enzyme" + SciMLBaseForwardDiffExt = "ForwardDiff" + SciMLBaseMLStyleExt = "MLStyle" + SciMLBaseMakieExt = "Makie" + SciMLBaseMeasurementsExt = "Measurements" + SciMLBaseMonteCarloMeasurementsExt = "MonteCarloMeasurements" + SciMLBaseMooncakeExt = "Mooncake" + SciMLBasePartialFunctionsExt = "PartialFunctions" + SciMLBasePyCallExt = "PyCall" + SciMLBasePythonCallExt = "PythonCall" + SciMLBaseRCallExt = "RCall" + SciMLBaseReverseDiffExt = "ReverseDiff" + SciMLBaseTrackerExt = "Tracker" + SciMLBaseZygoteExt = ["Zygote", "ChainRulesCore"] + + [deps.SciMLBase.weakdeps] + ChainRules = "082447d4-558c-5d27-93f4-14fc19e9eca2" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" + Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078" + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + MonteCarloMeasurements = "0987c9cc-fe09-11e8-30f0-b96dd679fdca" + Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" + PartialFunctions = "570af359-4316-4cb7-8c74-252c00c2016b" + PyCall = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" + PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" + RCall = "6f49c342-dc21-5d91-9882-a32aef131414" + ReverseDiff = "37e2e3b7-166d-5795-8a7a-e32c996b4267" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f" + +[[deps.SciMLLogging]] +deps = ["Logging", "LoggingExtras", "Preferences"] +git-tree-sha1 = "0161be062570af4042cf6f69e3d5d0b0555b6927" +uuid = "a6db7da4-7206-11f0-1eab-35f2a5dbe1d1" +version = "1.9.1" +weakdeps = ["Tracy"] + + [deps.SciMLLogging.extensions] + SciMLLoggingTracyExt = "Tracy" + +[[deps.SciMLOperators]] +deps = ["Accessors", "ArrayInterface", "DocStringExtensions", "LinearAlgebra"] +git-tree-sha1 = "794c760e6aafe9f40dcd7dd30526ea33f0adc8b7" +uuid = "c0aeaf25-5076-4817-a8d5-81caf7dfa961" +version = "1.15.1" +weakdeps = ["SparseArrays", "StaticArraysCore"] + + [deps.SciMLOperators.extensions] + SciMLOperatorsSparseArraysExt = "SparseArrays" + SciMLOperatorsStaticArraysCoreExt = "StaticArraysCore" + +[[deps.SciMLPublic]] +git-tree-sha1 = "0ba076dbdce87ba230fff48ca9bca62e1f345c9b" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.0.1" + +[[deps.SciMLStructures]] +deps = ["ArrayInterface", "PrecompileTools"] +git-tree-sha1 = "607f6867d0b0553e98fc7f725c9f9f13b4d01a32" +uuid = "53ae85a6-f571-4167-b2af-e1d143709226" +version = "1.10.0" + +[[deps.ScientificTypesBase]] +deps = ["InteractiveUtils"] +git-tree-sha1 = "e785eaa35a0f5518a388f9010e66fda64ea95ede" +uuid = "30f210dd-8aff-4c5f-94ba-8e64358c1161" +version = "3.1.0" + +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "9b81b8393e50b7d4e6d0a9f14e192294d3b7c109" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.3.0" + +[[deps.SentinelArrays]] +deps = ["Dates", "Random"] +git-tree-sha1 = "ebe7e59b37c400f694f52b58c93d26201387da70" +uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c" +version = "1.4.9" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" + +[[deps.Setfield]] +deps = ["ConstructionBase", "Future", "MacroTools", "StaticArraysCore"] +git-tree-sha1 = "c5391c6ace3bc430ca630251d02ea9687169ca68" +uuid = "efcf1570-3423-57d1-acb7-fd33fddbac46" +version = "1.1.2" + +[[deps.SharedArrays]] +deps = ["Distributed", "Mmap", "Random", "Serialization"] +uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" + +[[deps.ShiftedArrays]] +git-tree-sha1 = "503688b59397b3307443af35cd953a13e8005c16" +uuid = "1277b4bf-5013-50f5-be3d-901d8477a67a" +version = "2.0.0" + +[[deps.SimpleTraits]] +deps = ["InteractiveUtils", "MacroTools"] +git-tree-sha1 = "be8eeac05ec97d379347584fa9fe2f5f76795bcb" +uuid = "699a6c99-e7fa-54fc-8d76-47d257e15c1d" +version = "0.9.5" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" + +[[deps.SortingAlgorithms]] +deps = ["DataStructures"] +git-tree-sha1 = "64d974c2e6fdf07f8155b5b2ca2ffa9069b608d9" +uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" +version = "1.2.2" + +[[deps.SparseArrays]] +deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] +uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" +version = "1.10.0" + +[[deps.SparseConnectivityTracer]] +deps = ["ADTypes", "DocStringExtensions", "FillArrays", "LinearAlgebra", "Random", "SparseArrays"] +git-tree-sha1 = "590b72143436e443888124aaf4026a636049e3f5" +uuid = "9f842d2f-2579-4b1d-911e-f412cf18a3f5" +version = "1.2.1" + + [deps.SparseConnectivityTracer.extensions] + SparseConnectivityTracerChainRulesCoreExt = "ChainRulesCore" + SparseConnectivityTracerLogExpFunctionsExt = "LogExpFunctions" + SparseConnectivityTracerNNlibExt = "NNlib" + SparseConnectivityTracerNaNMathExt = "NaNMath" + SparseConnectivityTracerSpecialFunctionsExt = "SpecialFunctions" + + [deps.SparseConnectivityTracer.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + LogExpFunctions = "2ab3a3ac-af41-5b50-aa03-7779005ae688" + NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" + NaNMath = "77ba4419-2d1f-58cd-9bb1-8ffee604a2e3" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.SparseInverseSubset]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "52962839426b75b3021296f7df242e40ecfc0852" +uuid = "dc90abb0-5640-4711-901d-7e5b23a2fada" +version = "0.1.2" + +[[deps.SparseMatrixColorings]] +deps = ["ADTypes", "DocStringExtensions", "LinearAlgebra", "PrecompileTools", "Random", "SparseArrays"] +git-tree-sha1 = "fa43a02c01e3e3cb065c89bf9b648b89e3c06f18" +uuid = "0a514795-09f3-496d-8182-132a7b665d35" +version = "0.4.25" + + [deps.SparseMatrixColorings.extensions] + SparseMatrixColoringsCUDAExt = "CUDA" + SparseMatrixColoringsCliqueTreesExt = "CliqueTrees" + SparseMatrixColoringsColorsExt = "Colors" + SparseMatrixColoringsJuMPExt = ["JuMP", "MathOptInterface"] + + [deps.SparseMatrixColorings.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + CliqueTrees = "60701a23-6482-424a-84db-faee86b9b1f8" + Colors = "5ae59095-9a9b-59fe-a467-6f913c188581" + JuMP = "4076af6c-e467-56ae-b986-b466b2749572" + MathOptInterface = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" + +[[deps.SpecialFunctions]] +deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] +git-tree-sha1 = "5acc6a41b3082920f79ca3c759acbcecf18a8d78" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.7.1" +weakdeps = ["ChainRulesCore"] + + [deps.SpecialFunctions.extensions] + SpecialFunctionsChainRulesCoreExt = "ChainRulesCore" + +[[deps.SplittablesBase]] +deps = ["Setfield", "Test"] +git-tree-sha1 = "e08a62abc517eb79667d0a29dc08a3b589516bb5" +uuid = "171d559e-b47b-412a-8079-5efa626c420e" +version = "0.1.15" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "0f529006004a8be48f1be25f3451186579392d47" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.9.17" +weakdeps = ["ChainRulesCore", "Statistics"] + + [deps.StaticArrays.extensions] + StaticArraysChainRulesCoreExt = "ChainRulesCore" + StaticArraysStatisticsExt = "Statistics" + +[[deps.StaticArraysCore]] +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" +uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" +version = "1.4.4" + +[[deps.StatisticalTraits]] +deps = ["ScientificTypesBase"] +git-tree-sha1 = "89f86d9376acd18a1a4fbef66a56335a3a7633b8" +uuid = "64bff920-2084-43da-a3e6-9bb72801c0c9" +version = "3.5.0" + +[[deps.Statistics]] +deps = ["LinearAlgebra", "SparseArrays"] +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.10.0" + +[[deps.StatsAPI]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "178ed29fd5b2a2cfc3bd31c13375ae925623ff36" +uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" +version = "1.8.0" + +[[deps.StatsBase]] +deps = ["AliasTables", "DataAPI", "DataStructures", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] +git-tree-sha1 = "aceda6f4e598d331548e04cc6b2124a6148138e3" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.34.10" + +[[deps.StatsFuns]] +deps = ["HypergeometricFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"] +git-tree-sha1 = "91f091a8716a6bb38417a6e6f274602a19aaa685" +uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c" +version = "1.5.2" +weakdeps = ["ChainRulesCore", "InverseFunctions"] + + [deps.StatsFuns.extensions] + StatsFunsChainRulesCoreExt = "ChainRulesCore" + StatsFunsInverseFunctionsExt = "InverseFunctions" + +[[deps.StatsModels]] +deps = ["DataAPI", "DataStructures", "LinearAlgebra", "Printf", "REPL", "ShiftedArrays", "SparseArrays", "StatsAPI", "StatsBase", "StatsFuns", "Tables"] +git-tree-sha1 = "08786db4a1346d17d0a8d952d2e66fd00fa18192" +uuid = "3eaba693-59b7-5ba5-a881-562e759f1c8d" +version = "0.7.9" + +[[deps.StringManipulation]] +deps = ["PrecompileTools"] +git-tree-sha1 = "d05693d339e37d6ab134c5ab53c29fce5ee5d7d5" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.4.4" + +[[deps.StructArrays]] +deps = ["ConstructionBase", "DataAPI", "Tables"] +git-tree-sha1 = "a2c37d815bf00575332b7bd0389f771cb7987214" +uuid = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" +version = "0.7.2" + + [deps.StructArrays.extensions] + StructArraysAdaptExt = "Adapt" + StructArraysGPUArraysCoreExt = ["GPUArraysCore", "KernelAbstractions"] + StructArraysLinearAlgebraExt = "LinearAlgebra" + StructArraysSparseArraysExt = "SparseArrays" + StructArraysStaticArraysExt = "StaticArrays" + + [deps.StructArrays.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527" + KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" + LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" + SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" + StaticArrays = "90137ffa-7385-5640-81b9-e52037218182" + +[[deps.StructIO]] +git-tree-sha1 = "c581be48ae1cbf83e899b14c07a807e1787512cc" +uuid = "53d494c1-5632-5724-8f4c-31dff12d585f" +version = "0.3.1" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "fa95b3b097bcef5845c142ea2e085f1b2591e92c" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.7.1" + + [deps.StructUtils.extensions] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsStaticArraysCoreExt = ["StaticArraysCore"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + StaticArraysCore = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.SuiteSparse]] +deps = ["Libdl", "LinearAlgebra", "Serialization", "SparseArrays"] +uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9" + +[[deps.SuiteSparse_jll]] +deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] +uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" +version = "7.2.1+1" + +[[deps.SymbolicIndexingInterface]] +deps = ["Accessors", "ArrayInterface", "RuntimeGeneratedFunctions", "StaticArraysCore"] +git-tree-sha1 = "94c58884e013efff548002e8dc2fdd1cb74dfce5" +uuid = "2efcf032-c050-4f8e-a9bb-153293bab1f5" +version = "0.3.46" +weakdeps = ["PrettyTables"] + + [deps.SymbolicIndexingInterface.extensions] + SymbolicIndexingInterfacePrettyTablesExt = "PrettyTables" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TableTraits]] +deps = ["IteratorInterfaceExtensions"] +git-tree-sha1 = "c06b2f539df1c6efa794486abfb6ed2022561a39" +uuid = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c" +version = "1.0.1" + +[[deps.Tables]] +deps = ["DataAPI", "DataValueInterfaces", "IteratorInterfaceExtensions", "OrderedCollections", "TableTraits"] +git-tree-sha1 = "f2c1efbc8f3a609aadf318094f8fc5204bdaf344" +uuid = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" +version = "1.12.1" + +[[deps.Tar]] +deps = ["ArgTools", "SHA"] +uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" +version = "1.10.0" + +[[deps.TerminalLoggers]] +deps = ["LeftChildRightSiblingTrees", "Logging", "Markdown", "Printf", "ProgressLogging", "UUIDs"] +git-tree-sha1 = "f133fab380933d042f6796eda4e130272ba520ca" +uuid = "5d786b92-1e48-4d6f-9151-6b4477ca9bed" +version = "0.1.7" + +[[deps.Test]] +deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] +uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.Tracy]] +deps = ["ExprTools", "LibTracyClient_jll", "Libdl"] +git-tree-sha1 = "73e3ff50fd3990874c59fef0f35d10644a1487bc" +uuid = "e689c965-62c8-4b79-b2c5-8359227902fd" +version = "0.1.6" + + [deps.Tracy.extensions] + TracyProfilerExt = "TracyProfiler_jll" + + [deps.Tracy.weakdeps] + TracyProfiler_jll = "0c351ed6-8a68-550e-8b79-de6f926da83c" + +[[deps.TranscodingStreams]] +git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742" +uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" +version = "0.11.3" + +[[deps.Transducers]] +deps = ["Accessors", "ArgCheck", "BangBang", "Baselet", "CompositionsBase", "ConstructionBase", "DefineSingletons", "Distributed", "InitialValues", "Logging", "Markdown", "MicroCollections", "SplittablesBase", "Tables"] +git-tree-sha1 = "4aa1fdf6c1da74661f6f5d3edfd96648321dade9" +uuid = "28d57a85-8fef-5791-bfe6-a80928e7c999" +version = "0.4.85" + + [deps.Transducers.extensions] + TransducersAdaptExt = "Adapt" + TransducersBlockArraysExt = "BlockArrays" + TransducersDataFramesExt = "DataFrames" + TransducersLazyArraysExt = "LazyArrays" + TransducersOnlineStatsBaseExt = "OnlineStatsBase" + TransducersReferenceablesExt = "Referenceables" + + [deps.Transducers.weakdeps] + Adapt = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" + BlockArrays = "8e7c35d0-a365-5155-bbbb-fb81a777f24e" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + LazyArrays = "5078a376-72f3-5289-bfd5-ec5146d43c02" + OnlineStatsBase = "925886fa-5bf2-5e8e-b522-a9147a512338" + Referenceables = "42d2dcc6-99eb-4e98-b66c-637b7d73030e" + +[[deps.Turing]] +deps = ["ADTypes", "AbstractMCMC", "AbstractPPL", "Accessors", "AdvancedHMC", "AdvancedMH", "AdvancedPS", "AdvancedVI", "BangBang", "Bijectors", "Compat", "DataStructures", "DifferentiationInterface", "Distributions", "DocStringExtensions", "DynamicPPL", "EllipticalSliceSampling", "ForwardDiff", "Libtask", "LinearAlgebra", "LogDensityProblems", "MCMCChains", "Optimization", "OptimizationOptimJL", "OrderedCollections", "Printf", "Random", "Reexport", "SciMLBase", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] +git-tree-sha1 = "05e4dd6cfcaaa38e423c054a82aa3a43abd9a5b3" +uuid = "fce5fe82-541a-59a6-adf8-730c64b5f9a0" +version = "0.43.2" + + [deps.Turing.extensions] + TuringDynamicHMCExt = "DynamicHMC" + + [deps.Turing.weakdeps] + DynamicHMC = "bbc10e6e-7c05-544b-b16e-64fede858acb" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" + +[[deps.UnsafePointers]] +git-tree-sha1 = "c81331b3b2e60a982be57c046ec91f599ede674a" +uuid = "e17b2a0c-0bdf-430a-bd0c-3a23cae4ff39" +version = "1.0.0" + +[[deps.VersionParsing]] +git-tree-sha1 = "58d6e80b4ee071f5efd07fda82cb9fbe17200868" +uuid = "81def892-9a0e-5fdd-b105-ffc91e053289" +version = "1.3.0" + +[[deps.WeakRefStrings]] +deps = ["DataAPI", "InlineStrings", "Parsers"] +git-tree-sha1 = "b1be2855ed9ed8eac54e5caff2afcdb442d52c23" +uuid = "ea10d353-3f73-51f8-a26c-33c1cb351aa5" +version = "1.4.2" + +[[deps.WinReg]] +git-tree-sha1 = "cd910906b099402bcc50b3eafa9634244e5ec83b" +uuid = "1b915085-20d7-51cf-bf83-8f477d6f5128" +version = "1.0.0" + +[[deps.WoodburyMatrices]] +deps = ["LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "248a7031b3da79a127f14e5dc5f417e26f9f6db7" +uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6" +version = "1.1.0" + +[[deps.WorkerUtilities]] +git-tree-sha1 = "cd1659ba0d57b71a464a29e64dbc67cfe83d54e7" +uuid = "76eceee3-57b5-4d4a-8e66-0e911cebbf60" +version = "1.6.1" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.13+1" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.11.0+0" + +[[deps.micromamba_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "717df6f6892af4ee13279a73aa58474e58a88667" +uuid = "f8abcde7-e9b7-5caa-b8af-a437887ae8e4" +version = "2.3.1+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.52.0+1" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.6.1+0" + +[[deps.pixi_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "f349584316617063160a947a82638f7611a8ef0f" +uuid = "4d7b5844-a134-5dcd-ac86-c8f19cd51bed" +version = "0.41.3+0" diff --git a/scripts/Benchmarking/Project.toml b/scripts/Benchmarking/Project.toml index 529e53a..639d29a 100644 --- a/scripts/Benchmarking/Project.toml +++ b/scripts/Benchmarking/Project.toml @@ -1,5 +1,19 @@ [deps] +ADTypes = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +BridgeStan = "c88b6f0a-829e-4b0b-94b7-f06ab5908f5a" +CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" Chairmarks = "0ca39b1e-fe0b-4e98-acfc-b1656634c4de" +CondaPkg = "992eb4ea-22a4-4c89-a5bb-47a3300528ab" +DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" DifferentiationInterface = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" +Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" +Downloads = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +DynamicPPL = "366bfd00-2699-11ea-058f-f148b4cae6d8" Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" +ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" +LogDensityProblems = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c" Mooncake = "da2b9cff-9c12-43a0-ae48-6db2b0edb7d6" +PythonCall = "6099a3de-0909-46bc-b1f4-468b9a2dfc0d" +RCall = "6f49c342-dc21-5d91-9882-a32aef131414" +Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +Turing = "fce5fe82-541a-59a6-adf8-730c64b5f9a0" diff --git a/scripts/Benchmarking/README.md b/scripts/Benchmarking/README.md new file mode 100644 index 0000000..01babb5 --- /dev/null +++ b/scripts/Benchmarking/README.md @@ -0,0 +1,119 @@ +# Bayesian Regression Model Benchmarks + +Benchmarking log-density and gradient evaluation for a Bayesian linear regression across multiple backends and AD systems. + +**Problem**: `drugs ~ o + c + e + a + n` (ESCS dataset, N=604, K=5, 7 unconstrained parameters). + +## Running + +```bash +cd scripts/Benchmarking +julia run_benchmark.jl +``` + +Gradient correctness is verified against brms/Stan as the reference. + +## Results + +### Primal (log-density evaluation) + +| Variant | Time | Allocs | vs Stan | +|---|---|---|---| +| julia6 (manual gemv) | 640 ns | 0 | 3.0x faster | +| julia5 (5-arg mul!) | 670 ns | 0 | 2.8x faster | +| julia7 (split, BLAS mul!) | 680 ns | 0 | 2.8x faster | +| julia3 (BLAS mul!) | 700 ns | 0 | 2.7x faster | +| julia1 (allocating Xc*b) | 1.8 μs | 2 | 1.0x | +| **brms/Stan (glm fused)** | **1.9 μs** | **1** | **1.0x** | +| stan (matvec + vec normal) | 2.9 μs | 1 | 0.66x | +| turing2 (@addlogprob!) | 2.6 μs | 20 | 0.73x | +| stan (loop + vec normal) | 3.1 μs | 1 | 0.61x | +| julia2 (broadcasted row-dot) | 6.7 μs | 0 | 0.28x | +| turing (loop ~) | 10 μs | 20 | 0.19x | +| bambi/PyMC (pytensor) | 34 μs | 9 | 0.06x | + +### Gradient (log-density + gradient, correct results only) + +| Variant | Time | Allocs | vs Stan | +|---|---|---|---| +| **julia7 Enzyme split rev** | **3.3 μs** | **0** | **1.0x** | +| **brms/Stan** | **3.4 μs** | **1** | **1.0x** | +| julia5 Enzyme Dup rev | 3.9 μs | 0 | 0.87x | +| julia3 Enzyme Dup rev | 4.0 μs | 0 | 0.85x | +| julia7 Enzyme split fwd | 6.1 μs | 0 | 0.56x | +| julia6 Enzyme Dup rev | 9.9 μs | 0 | 0.34x | +| julia7 Mooncake rev | 10.8 μs | 1 | 0.31x | +| julia3 Mooncake rev | 11.2 μs | 1 | 0.30x | +| julia6 Mooncake rev | 65.6 μs | 0 | 0.05x | + +## Implementations + +### Hand-written Julia variants + +All implement the same log-density as the brms-generated Stan model: centered predictors, student-t priors, half-student-t on sigma. + +- **julia1**: `Xc * b` allocating, `dot(r, r)` for sum of squares +- **julia2**: Lazy `Base.broadcasted` with per-row dot products, custom `mysum` with `preprocess`/`instantiate` +- **julia3**: Pre-allocated buffer + `mul!` (BLAS gemv) + SIMD residual loop +- **julia4**: Broadcasted `.=` into pre-allocated buffer (same speed as lazy) +- **julia5**: 5-arg `mul!` (`r = Y - Xc*b` in one BLAS call) + SIMD loop +- **julia6**: Manual gemv (column-by-column axpy, no BLAS) + fused residual +- **julia7**: Same as julia3 but with split `ℓ_inner(mu, q)` for fine-grained Enzyme annotations + +### Stan variants + +- **brms (glm fused)**: Uses `normal_id_glm_lpdf` — hand-optimized fused likelihood with custom adjoint +- **stan (matvec + vec)**: Separate `Xc * b` + vectorized `normal_lpdf` +- **stan (loop + vec)**: Precomputed `mu` + vectorized `normal_lpdf` + +### Turing/DynamicPPL variants + +- **turing**: Standard `@model` with per-observation `Y[i] ~ Normal(mu[i], sigma)` loop +- **turing2**: Same priors but likelihood via `Turing.@addlogprob!`, bypassing tilde processing + +## AD Backend Notes + +### Enzyme + +- **`function_annotation=Enzyme.Const`**: Produces **wrong gradients** on julia3/5/6/7. `Const` prevents shadow memory allocation for captured mutable buffers (`mu`, `r_buf`), so adjoints can't propagate through `mul!`. +- **`function_annotation=Enzyme.Duplicated`**: Correct gradients but creates shadows for ALL captured variables including constant data arrays (Y: 4.8KB, Xc: 24KB), adding ~1 μs overhead from zeroing ~30KB per call. +- **Fine-grained split (julia7)**: `ℓ_inner(mu, q)` takes the buffer as an explicit argument. Called with `Const(ℓ_inner)` + `Duplicated(mu, dmu)` + `Duplicated(q, grad)`. Only ~5KB shadow for the buffer. **Matches Stan performance.** + +### Mooncake + +- **Reverse mode**: Correct gradients, ~11 μs on julia3/5/7. Automatically determines constness (uses `NoRData` for Y/Xc) but has higher per-call overhead than Enzyme's LLVM-level codegen. +- **Forward mode**: Correct but extremely slow (milliseconds, 60-500k allocs). +- The split approach doesn't help Mooncake — it traces through the full closure graph regardless. + +### ForwardDiff + +Fails on julia3/5/6/7 because `mul!` writes into pre-allocated `Float64` buffers that can't hold `Dual` numbers. Works on julia1 (allocating version). + +## Key Insights + +### Why hand-written Julia primals beat Stan + +Stan evaluates with autodiff-ready `var` types even for primal-only calls (`propto=false`). Julia operates on plain `Float64` with zero-allocation BLAS + SIMD loops. + +### Why Stan's gradient is hard to beat + +Stan's `normal_id_glm_lpdf` has a hand-written adjoint that fuses primal and gradient into one pass, reusing intermediates. Gradient/primal ratio is 1.8x. Julia + Enzyme achieves 4.7x (whole-closure `Duplicated`) but matches Stan at 4.6x with fine-grained `Const`/`Duplicated` annotations. + +### Why broadcasted row-dots are slow + +`eachrow(Xc)` + per-row `dot`: 604 dot products of length 5, each too short for SIMD. BLAS `gemv` processes column-by-column — each axpy touches 604 contiguous elements, perfect for vectorization. + +### DynamicPPL overhead breakdown + +| Component | Time | Allocs | +|---|---|---| +| Empty model | 0 μs | 0 | +| Parameter management + transforms + priors | 1.0 μs | 18 | +| + manual likelihood (`@addlogprob!`) | 2.6 μs | 20 | +| + loop with 604 `~` tilde statements | 10 μs | 20 | + +DynamicPPL v0.40 is already type-stable (`@code_warntype` shows concrete types). The overhead is inherent to its generality: parameter unpacking, bijector transforms, accumulator bookkeeping. + +### DynamicPPL main branch + +The main branch of DynamicPPL adds an `adtype` keyword to `LogDensityFunction` for integrated gradient computation. This passes model internals as `DI.Constant` contexts — conceptually similar to our manual Enzyme `Const`/`Duplicated` split. However, the gradient path doesn't work yet with current Mooncake/DI versions (fails at `prepare_gradient` with multi-argument `Constant` contexts). diff --git a/scripts/Benchmarking/benchmark.jl b/scripts/Benchmarking/benchmark.jl new file mode 100644 index 0000000..a26db38 --- /dev/null +++ b/scripts/Benchmarking/benchmark.jl @@ -0,0 +1,1085 @@ +using DataFrames, Chairmarks +using LogDensityProblems: LogDensityProblems, logdensity, logdensity_and_gradient, dimension, capabilities +using PythonCall, RCall, BridgeStan + +import ForwardDiff, Enzyme, Mooncake +using LinearAlgebra: dot, mul! +using Statistics: mean +import DifferentiationInterface as DI +using ADTypes: AutoForwardDiff, AutoEnzyme, AutoMooncake +using Turing +import DynamicPPL +using Distributions: TDist, Normal, logpdf + +# ── Shared helpers ──────────────────────────────────────────────────────────── + +function _parse_formula(formula::String) + lhs, rhs = strip.(split(formula, "~")) + return Symbol(lhs), Symbol.(strip.(split(rhs, "+"))) +end + +function _center_predictors(data::DataFrame, predictors) + raw = hcat([Vector{Float64}(data[!, p]) for p in predictors]...) + col_means = vec(mean(raw, dims=1)) + return raw .- col_means', col_means +end + +# ── PyMC (bambi) problem ─────────────────────────────────────────────────────── +# +# bambi builds a PyMC model under the hood. We compile a single pytensor +# function that returns (logp, flat_gradient) in one forward+backward pass, +# then wrap it in a Julia struct that implements the LogDensityProblems interface. +# +# Construction note: bambi's formula parser (formulae) captures the Python +# calling frame to resolve variable names. When called directly from Julia +# there is no Python frame, so we define a thin Python wrapper function and +# call that instead. + +# Cached numpy module — lazily initialized to avoid errors when Python is not available +const _NP = Ref{Py}() +function get_np() + if !isassigned(_NP) + _NP[] = pyimport("numpy") + end + return _NP[] +end + +# Python helper — lazily initialized +const _PYMC_HELPERS = Ref{Py}() +function get_pymc_helpers() + isassigned(_PYMC_HELPERS) && return _PYMC_HELPERS[] + g = pydict() + pyexec(""" +import numpy as np +import pytensor +import pytensor.tensor as pt + +def build_bambi(formula, data): + \"\"\"Build a bambi model inside a Python frame so formulae can capture it.\"\"\" + import bambi as bmb + return bmb.Model(formula, data) + +def make_logp_dlogp(pm_model, pytensor_mode=None): + \"\"\" + Compile two pytensor functions for a PyMC model that accept a single flat + np.ndarray of unconstrained parameters directly (no dict conversion per call). + + Builds the symbolic graph by replacing each value_var with a slice of a single + flat input vector, then differentiates w.r.t. that vector. This eliminates + the Python-level to_dict() call that would otherwise run on every evaluation. + + Returns (logp_fn, logp_dlogp_fn, q0_flat). + Pass pytensor_mode=\"JAX\" to compile with the JAX backend. + \"\"\" + compile_kwargs = {"mode": pytensor_mode} if pytensor_mode is not None else {} + + q0_dict = pm_model.initial_point() + keys = list(q0_dict.keys()) + shapes = {k: np.shape(q0_dict[k]) for k in keys} + sizes = {k: int(np.prod(shapes[k])) if shapes[k] else 1 for k in keys} + q0_flat = np.concatenate( + [np.atleast_1d(np.asarray(q0_dict[k])).ravel() for k in keys] + ) + + # Single symbolic flat-vector input + q_sym = pt.vector("q", dtype=pytensor.config.floatX) + + # Map each value_var to its corresponding slice of q_sym + replacements = {} + i = 0 + for vv, k in zip(pm_model.value_vars, keys): + s = sizes[k] + replacements[vv] = q_sym[i:i+s].reshape(shapes[k]) if shapes[k] else q_sym[i] + i += s + + logp_expr = pm_model.logp(jacobian=True) + logp_sub = pytensor.clone_replace(logp_expr, replacements) + grad_sym = pytensor.gradient.grad(logp_sub, q_sym) + + compiled_logp = pytensor.function([q_sym], logp_sub, **compile_kwargs) + compiled_fn = pytensor.function([q_sym], [logp_sub, grad_sym], **compile_kwargs) + + def call_logp(q_flat): + return float(compiled_logp(q_flat)) + + def call_logp_dlogp(q_flat): + lp, grad = compiled_fn(q_flat) + return float(lp), np.asarray(grad) + + return call_logp, call_logp_dlogp, q0_flat +""", g) + _PYMC_HELPERS[] = g + return g +end + +struct PyMCProblem + _logp_fn::Py # (np.ndarray) -> float + _fn::Py # (np.ndarray) -> (float, np.ndarray) + _q0::Vector{Float64} # initial unconstrained parameter vector +end + +""" + PyMCProblem(formula, data; compiler=:pytensor) -> PyMCProblem + +Build a bambi/PyMC model from `formula` and `data`, compile a combined +logp+gradient pytensor function, and return a `PyMCProblem` that implements +the `LogDensityProblems` interface. + +`compiler` controls the pytensor backend: +- `:pytensor` (default) — standard C-compiled pytensor +- `:jax` — JAX backend (requires `jax` installed); faster after JIT warmup +""" +function PyMCProblem(formula::String, data::DataFrame; compiler::Symbol = :pytensor) + helpers = get_pymc_helpers() + build_bambi = helpers["build_bambi"] + make_logp_dlogp = helpers["make_logp_dlogp"] + + bm_model = build_bambi(formula, pytable(data)) + bm_model.build() + pm_model = bm_model.backend.model + + pytensor_mode = compiler === :jax ? "JAX" : pybuiltins.None + py_logp_fn, py_fn, py_q0 = make_logp_dlogp(pm_model, pytensor_mode) + q0 = pyconvert(Vector{Float64}, py_q0) + p = PyMCProblem(py_logp_fn, py_fn, q0) + + # JAX functions are JIT-compiled on first call — run one warmup so benchmark + # times reflect steady-state performance, not compilation. + if compiler === :jax + q0_np = get_np().asarray(q0) + py_logp_fn(q0_np) + py_fn(q0_np) + end + + return p +end + +LogDensityProblems.dimension(p::PyMCProblem) = length(p._q0) +LogDensityProblems.capabilities(::Type{PyMCProblem}) = LogDensityProblems.LogDensityOrder{1}() + +function LogDensityProblems.logdensity(p::PyMCProblem, q::AbstractVector{<:Real}) + np = pyimport("numpy") + return pyconvert(Float64, p._logp_fn(np.asarray(q))) +end + +function LogDensityProblems.logdensity_and_gradient(p::PyMCProblem, q::AbstractVector{<:Real}) + np = pyimport("numpy") + result = p._fn(np.asarray(q)) + lp = pyconvert(Float64, result[0]) + grad = pyconvert(Vector{Float64}, result[1]) + return lp, grad +end + +# ── Stan (brms) problem ─────────────────────────────────────────────────────── +# +# brms generates Stan code and data; BridgeStan compiles it to a shared library +# that exposes log_density_gradient with a flat unconstrained parameter vector. +# BridgeStan.StanModel already supports log_density_gradient, so we wrap it in +# a thin struct to keep a symmetric interface with PyMCProblem. + +# Sanitize a formula string for use as a directory name: +# "drugs ~ o + c + e + a + n" → "drugs_o_c_e_a_n" +function _formula_to_path(formula::String) + s = replace(formula, r"[^a-zA-Z0-9]+" => "_") + return strip(s, '_') +end + +struct StanProblem + _model::BridgeStan.StanModel + _q0::Vector{Float64} +end + +""" + StanProblem(formula, data; source, key, models_dir) -> StanProblem + +Generate Stan code and data via `brms`, compile with BridgeStan, and return a +`StanProblem` that implements the `LogDensityProblems` interface. + +Stan source and data files are written to a persistent directory: + `{models_dir}/{source}/{key}/{sanitized_formula}/` +and reused on subsequent calls if they already exist. +""" +function StanProblem( + formula::String, + data::DataFrame; + source::Union{Symbol,Nothing} = nothing, + key::Union{Symbol,Nothing} = nothing, + models_dir::String = joinpath(@__DIR__, "models"), +) + formula_dir = _formula_to_path(formula) + stan_dir = if source !== nothing && key !== nothing + joinpath(models_dir, string(source), string(key), formula_dir) + else + joinpath(models_dir, formula_dir) + end + mkpath(stan_dir) + + stan_file = joinpath(stan_dir, "model.stan") + data_file = joinpath(stan_dir, "data.json") + + if !isfile(stan_file) || !isfile(data_file) + @rput data formula + stan_code = rcopy(String, R"brms::make_stancode(as.formula(formula), data=data)") + stan_data_json = rcopy(String, R""" + jsonlite::toJSON( + brms::make_standata(as.formula(formula), data=data), + auto_unbox=TRUE + ) + """) + write(stan_file, stan_code) + write(data_file, stan_data_json) + end + + sm = BridgeStan.StanModel(stan_file, data_file; warn=false) + q0 = zeros(BridgeStan.param_unc_num(sm)) + return StanProblem(sm, q0) +end + +""" + StanProblem(stan_file, data_file) -> StanProblem + +Compile a pre-written Stan model with BridgeStan. Unlike the `(formula, data)` +constructor this skips brms code generation entirely. +""" +function StanProblem(stan_file::String, data_file::String) + sm = BridgeStan.StanModel(stan_file, data_file; warn=false) + q0 = zeros(BridgeStan.param_unc_num(sm)) + return StanProblem(sm, q0) +end + +LogDensityProblems.dimension(p::StanProblem) = length(p._q0) +LogDensityProblems.capabilities(::Type{StanProblem}) = LogDensityProblems.LogDensityOrder{1}() + +function LogDensityProblems.logdensity(p::StanProblem, q::AbstractVector{<:Real}) + # propto=false avoids autodiff-type overhead that propto=true incurs even + # when no gradient is being computed (see BridgeStan internals docs). + return BridgeStan.log_density(p._model, q; propto=false, jacobian=true) +end + +function LogDensityProblems.logdensity_and_gradient(p::StanProblem, q::AbstractVector{<:Real}) + return BridgeStan.log_density_gradient(p._model, q) +end + +# ── Hand-written Julia problem ──────────────────────────────────────────────── +# +# A pure Julia implementation of the same linear regression model that brms +# generates. The log-density is hand-coded; gradients are computed via +# DifferentiationInterface with a user-selected AD backend. + +struct JuliaProblem{F} + _logdensity::F + _q0::Vector{Float64} +end + +""" + JuliaProblem(formula, data; intercept_prior, sigma_prior) -> JuliaProblem + +Build a hand-written Julia log-density function matching the brms-generated +Stan model (centered predictors, student-t priors). + +`intercept_prior` and `sigma_prior` are `(df, loc, scale)` tuples matching the +`student_t_lpdf` calls in the generated Stan code. +""" +function JuliaProblem( + formula::String, data::DataFrame; + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), + kwargs..., +) + response, predictors = _parse_formula(formula) + Y = Vector{Float64}(data[!, response]) + N = length(Y) + Kc = length(predictors) + Xc, _ = _center_predictors(data, predictors) + + int_df, int_loc, int_scale = intercept_prior + sig_df, sig_loc, sig_scale = sigma_prior + + q0 = zeros(Kc + 2) + + # Pre-compute constants + half_N_log2π = N / 2 * log(2π) + log_half = log(0.5) + int_dist = TDist(int_df) + sig_dist = TDist(sig_df) + inv_int_scale = inv(int_scale) + log_int_scale = log(int_scale) + inv_sig_scale = inv(sig_scale) + log_sig_scale = log(sig_scale) + + function ℓ(q) + b = @view q[1:Kc] + α = q[Kc + 1] + log_σ = q[Kc + 2] + σ = exp(log_σ) + + # Likelihood: Normal(Y | Xc*b + α, σ) + r = Y .- (Xc * b .+ α) + lp = -half_N_log2π - N * log_σ - dot(r, r) / (2 * σ^2) + + # student_t prior on Intercept + lp += logpdf(int_dist, (α - int_loc) * inv_int_scale) - log_int_scale + + # half-student_t prior on sigma + lp += logpdf(sig_dist, (σ - sig_loc) * inv_sig_scale) - log_sig_scale - log_half + + # Jacobian for exp transform + lp += log_σ + + return lp + end + + return JuliaProblem(ℓ, q0) +end + +struct JuliaProblem2{F} + _logdensity::F + _q0::Vector{Float64} +end + +""" + JuliaProblem2(formula, data; intercept_prior, sigma_prior) -> JuliaProblem2 + +Build a hand-written Julia log-density function matching the brms-generated +Stan model (centered predictors, student-t priors). + +`intercept_prior` and `sigma_prior` are `(df, loc, scale)` tuples matching the +`student_t_lpdf` calls in the generated Stan code. +""" +function JuliaProblem2( + formula::String, data::DataFrame; + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), + kwargs..., +) + response, predictors = _parse_formula(formula) + Y = Vector{Float64}(data[!, response]) + N = length(Y) + Kc = length(predictors) + Xc, _ = _center_predictors(data, predictors) + XcT = Matrix(Xc')' + + int_df, int_loc, int_scale = intercept_prior + sig_df, sig_loc, sig_scale = sigma_prior + + q0 = zeros(Kc + 2) + + # Pre-compute constants + half_N_log2π = N / 2 * log(2π) + log_half = log(0.5) + int_dist = TDist(int_df) + sig_dist = TDist(sig_df) + inv_int_scale = inv(int_scale) + log_int_scale = log(int_scale) + inv_sig_scale = inv(sig_scale) + log_sig_scale = log(sig_scale) + + function ℓ(q) + b = @view q[1:Kc] + α = q[Kc + 1] + log_σ = q[Kc + 2] + σ = exp(log_σ) + + # Likelihood: Normal(Y | Xc*b + α, σ) + r = Base.broadcasted(-,Y, Base.broadcasted(+, α, Base.broadcasted(dot, eachrow(XcT), Ref(b)))) + # Y .- (Xc * b .+ α) + # ) + lp = -half_N_log2π - N * log_σ - mysum(abs2, r) / (2 * σ^2) + + # student_t prior on Intercept + lp += logpdf(int_dist, (α - int_loc) * inv_int_scale) - log_int_scale + + # half-student_t prior on sigma + lp += logpdf(sig_dist, (σ - sig_loc) * inv_sig_scale) - log_sig_scale - log_half + + # Jacobian for exp transform + lp += log_σ + + return lp + end + + return JuliaProblem2(ℓ, q0) +end + +struct JuliaProblem3{F} + _logdensity::F + _q0::Vector{Float64} +end + +""" + JuliaProblem3(formula, data; intercept_prior, sigma_prior) -> JuliaProblem3 + +Like JuliaProblem but pre-allocates a buffer for `Xc * b` to avoid allocation +in the hot loop. +""" +function JuliaProblem3( + formula::String, data::DataFrame; + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), + kwargs..., +) + response, predictors = _parse_formula(formula) + Y = Vector{Float64}(data[!, response]) + N = length(Y) + Kc = length(predictors) + Xc, _ = _center_predictors(data, predictors) + + int_df, int_loc, int_scale = intercept_prior + sig_df, sig_loc, sig_scale = sigma_prior + + q0 = zeros(Kc + 2) + mu = Vector{Float64}(undef, N) # pre-allocated buffer + + # Pre-compute constants + half_N_log2π = N / 2 * log(2π) + log_half = log(0.5) + int_dist = TDist(int_df) + sig_dist = TDist(sig_df) + inv_int_scale = inv(int_scale) + log_int_scale = log(int_scale) + inv_sig_scale = inv(sig_scale) + log_sig_scale = log(sig_scale) + + function ℓ(q) + b = @view q[1:Kc] + α = q[Kc + 1] + log_σ = q[Kc + 2] + σ = exp(log_σ) + + # Likelihood: Normal(Y | Xc*b + α, σ) + mul!(mu, Xc, b) # mu = Xc * b (no allocation) + ss = zero(eltype(q)) + @inbounds @simd for i in eachindex(Y) + r = Y[i] - (mu[i] + α) + ss += r * r + end + lp = -half_N_log2π - N * log_σ - ss / (2 * σ^2) + + # student_t prior on Intercept + lp += logpdf(int_dist, (α - int_loc) * inv_int_scale) - log_int_scale + + # half-student_t prior on sigma + lp += logpdf(sig_dist, (σ - sig_loc) * inv_sig_scale) - log_sig_scale - log_half + + # Jacobian for exp transform + lp += log_σ + + return lp + end + + return JuliaProblem3(ℓ, q0) +end + +struct JuliaProblem5{F} + _logdensity::F + _q0::Vector{Float64} +end + +""" + JuliaProblem5(formula, data; ...) -> JuliaProblem5 + +Like JuliaProblem3 but uses 5-arg `mul!` to fuse `r = Y - Xc*b` into one +BLAS call, then handles the intercept shift in the sum-of-squares loop. +""" +function JuliaProblem5( + formula::String, data::DataFrame; + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), + kwargs..., +) + response, predictors = _parse_formula(formula) + Y = Vector{Float64}(data[!, response]) + N = length(Y) + Kc = length(predictors) + Xc, _ = _center_predictors(data, predictors) + + int_df, int_loc, int_scale = intercept_prior + sig_df, sig_loc, sig_scale = sigma_prior + + q0 = zeros(Kc + 2) + r_buf = Vector{Float64}(undef, N) # pre-allocated residual buffer + + # Pre-compute constants + half_N_log2π = N / 2 * log(2π) + log_half = log(0.5) + int_dist = TDist(int_df) + sig_dist = TDist(sig_df) + inv_int_scale = inv(int_scale) + log_int_scale = log(int_scale) + inv_sig_scale = inv(sig_scale) + log_sig_scale = log(sig_scale) + + function ℓ(q) + b = @view q[1:Kc] + α = q[Kc + 1] + log_σ = q[Kc + 2] + σ = exp(log_σ) + + # r_buf = Y - Xc*b (one BLAS call via 5-arg mul!) + copyto!(r_buf, Y) + mul!(r_buf, Xc, b, -1.0, 1.0) + + # Subtract intercept and accumulate sum of squares + ss = zero(eltype(q)) + @inbounds @simd for i in eachindex(r_buf) + ri = r_buf[i] - α + ss += ri * ri + end + lp = -half_N_log2π - N * log_σ - ss / (2 * σ^2) + + # student_t prior on Intercept + lp += logpdf(int_dist, (α - int_loc) * inv_int_scale) - log_int_scale + + # half-student_t prior on sigma + lp += logpdf(sig_dist, (σ - sig_loc) * inv_sig_scale) - log_sig_scale - log_half + + # Jacobian for exp transform + lp += log_σ + + return lp + end + + return JuliaProblem5(ℓ, q0) +end + +struct JuliaProblem6{F} + _logdensity::F + _q0::Vector{Float64} +end + +""" + JuliaProblem6(formula, data; ...) -> JuliaProblem6 + +Manual gemv: computes `mu = Xc * b` column-by-column with explicit loops +instead of calling BLAS, then fuses the residual + sum-of-squares in one pass. +""" +function JuliaProblem6( + formula::String, data::DataFrame; + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), + kwargs..., +) + response, predictors = _parse_formula(formula) + Y = Vector{Float64}(data[!, response]) + N = length(Y) + Kc = length(predictors) + Xc, _ = _center_predictors(data, predictors) + + int_df, int_loc, int_scale = intercept_prior + sig_df, sig_loc, sig_scale = sigma_prior + + q0 = zeros(Kc + 2) + r_buf = Vector{Float64}(undef, N) + + # Pre-compute constants + half_N_log2π = N / 2 * log(2π) + log_half = log(0.5) + int_dist = TDist(int_df) + sig_dist = TDist(sig_df) + inv_int_scale = inv(int_scale) + log_int_scale = log(int_scale) + inv_sig_scale = inv(sig_scale) + log_sig_scale = log(sig_scale) + + function ℓ(q) + b = @view q[1:Kc] + α = q[Kc + 1] + log_σ = q[Kc + 2] + σ = exp(log_σ) + + # Manual gemv: r_buf = Y - α - Xc * b (column-by-column axpy) + @inbounds @simd for i in 1:N + r_buf[i] = Y[i] - α + end + @inbounds for j in 1:Kc + bj = b[j] + @simd for i in 1:N + r_buf[i] -= Xc[i, j] * bj + end + end + + # Sum of squares + ss = zero(eltype(q)) + @inbounds @simd for i in 1:N + ss += r_buf[i] * r_buf[i] + end + lp = -half_N_log2π - N * log_σ - ss / (2 * σ^2) + + # student_t prior on Intercept + lp += logpdf(int_dist, (α - int_loc) * inv_int_scale) - log_int_scale + + # half-student_t prior on sigma + lp += logpdf(sig_dist, (σ - sig_loc) * inv_sig_scale) - log_sig_scale - log_half + + # Jacobian for exp transform + lp += log_σ + + return lp + end + + return JuliaProblem6(ℓ, q0) +end + +struct JuliaProblem4{F} + _logdensity::F + _q0::Vector{Float64} +end + +""" + JuliaProblem4(formula, data; ...) -> JuliaProblem4 + +Like JuliaProblem2 (broadcasted row-dot) but materializes the broadcasted +residual into a pre-allocated vector before computing the sum of squares. +""" +function JuliaProblem4( + formula::String, data::DataFrame; + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), + kwargs..., +) + response, predictors = _parse_formula(formula) + Y = Vector{Float64}(data[!, response]) + N = length(Y) + Kc = length(predictors) + Xc, _ = _center_predictors(data, predictors) + XcT = Matrix(Xc')' + + int_df, int_loc, int_scale = intercept_prior + sig_df, sig_loc, sig_scale = sigma_prior + + q0 = zeros(Kc + 2) + r_buf = Vector{Float64}(undef, N) # pre-allocated residual buffer + + # Pre-compute constants + half_N_log2π = N / 2 * log(2π) + log_half = log(0.5) + int_dist = TDist(int_df) + sig_dist = TDist(sig_df) + inv_int_scale = inv(int_scale) + log_int_scale = log(int_scale) + inv_sig_scale = inv(sig_scale) + log_sig_scale = log(sig_scale) + + function ℓ(q) + b = @view q[1:Kc] + α = q[Kc + 1] + log_σ = q[Kc + 2] + σ = exp(log_σ) + + # Materialize broadcasted residual into pre-allocated buffer + r_buf .= Base.broadcasted(-, Y, Base.broadcasted(+, α, Base.broadcasted(dot, eachrow(XcT), Ref(b)))) + lp = -half_N_log2π - N * log_σ - dot(r_buf, r_buf) / (2 * σ^2) + + # student_t prior on Intercept + lp += logpdf(int_dist, (α - int_loc) * inv_int_scale) - log_int_scale + + # half-student_t prior on sigma + lp += logpdf(sig_dist, (σ - sig_loc) * inv_sig_scale) - log_sig_scale - log_half + + # Jacobian for exp transform + lp += log_σ + + return lp + end + + return JuliaProblem4(ℓ, q0) +end + +@inline function mysum(f, bc::Base.Broadcast.Broadcasted) + bc′ = Base.Broadcast.preprocess(nothing, Base.Broadcast.instantiate(bc)) + rv = zero(Float64) + @simd for I in eachindex(bc′) + @inbounds rv += f(bc′[I]) + end + rv +end +@inline function mysum(f, x) + rv = zero(Float64) + @simd for xi in x + @inbounds rv += f(xi) + end + rv +end + +# ── Split-argument version for fine-grained Enzyme annotations ─────────────── +# +# The closure only captures constant data (Y, Xc, priors). The mutable buffer +# is a separate argument so it can be annotated Duplicated while the closure +# stays Const. This avoids shadow allocation for the large data arrays. + +struct JuliaProblem7{F,G} + _logdensity::F # ℓ(q) — for primal / non-Enzyme AD + _logdensity_split::G # ℓ_inner(mu, q) — for Enzyme with split annotations + _q0::Vector{Float64} + _mu::Vector{Float64} # pre-allocated buffer (passed as arg, not captured) +end + +function JuliaProblem7( + formula::String, data::DataFrame; + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), + kwargs..., +) + response, predictors = _parse_formula(formula) + Y = Vector{Float64}(data[!, response]) + N = length(Y) + Kc = length(predictors) + Xc, _ = _center_predictors(data, predictors) + + int_df, int_loc, int_scale = intercept_prior + sig_df, sig_loc, sig_scale = sigma_prior + + q0 = zeros(Kc + 2) + mu = Vector{Float64}(undef, N) + + half_N_log2π = N / 2 * log(2π) + log_half = log(0.5) + int_dist = TDist(int_df) + sig_dist = TDist(sig_df) + inv_int_scale = inv(int_scale) + log_int_scale = log(int_scale) + inv_sig_scale = inv(sig_scale) + log_sig_scale = log(sig_scale) + + # Split version: mu is an argument, closure captures only const data + function ℓ_inner(mu, q) + b = @view q[1:Kc] + α = q[Kc + 1] + log_σ = q[Kc + 2] + σ = exp(log_σ) + + mul!(mu, Xc, b) + ss = zero(eltype(q)) + @inbounds @simd for i in eachindex(Y) + r = Y[i] - (mu[i] + α) + ss += r * r + end + lp = -half_N_log2π - N * log_σ - ss / (2 * σ^2) + + lp += logpdf(int_dist, (α - int_loc) * inv_int_scale) - log_int_scale + lp += logpdf(sig_dist, (σ - sig_loc) * inv_sig_scale) - log_sig_scale - log_half + lp += log_σ + + return lp + end + + # Wrapper for primal / non-Enzyme use + ℓ(q) = ℓ_inner(mu, q) + + return JuliaProblem7(ℓ, ℓ_inner, q0, mu) +end + +function _benchmark_enzyme_split(p::JuliaProblem7, mode::Symbol; enzyme_mode=Enzyme.Reverse) + q0 = p._q0 + mu = p._mu + dmu = zeros(length(mu)) + ℓ_inner = p._logdensity_split + if mode === :primal + return @be $(p._logdensity)($q0) + elseif mode === :gradient + grad = zeros(length(q0)) + if enzyme_mode === Enzyme.Reverse || enzyme_mode isa Enzyme.ReverseMode + return @be begin + fill!($dmu, 0.0) + fill!($grad, 0.0) + Enzyme.autodiff( + $enzyme_mode, + Enzyme.Const($ℓ_inner), + Enzyme.Active, + Enzyme.Duplicated($mu, $dmu), + Enzyme.Duplicated($q0, $grad), + ) + end + else + # Forward mode: use Duplicated return, batch over parameters + Kc = length(q0) + seeds = [zeros(Kc) for _ in 1:Kc] + for i in 1:Kc; seeds[i][i] = 1.0; end + dmus = [zeros(length(mu)) for _ in 1:Kc] + batch_seeds = Enzyme.BatchDuplicated(q0, ntuple(i -> seeds[i], Kc)) + batch_dmus = Enzyme.BatchDuplicated(mu, ntuple(i -> dmus[i], Kc)) + return @be begin + for s in $seeds; fill!(s, 0.0); end + for i in 1:$Kc; $(seeds)[i][i] = 1.0; end + for d in $dmus; fill!(d, 0.0); end + Enzyme.autodiff( + $enzyme_mode, + Enzyme.Const($ℓ_inner), + Enzyme.BatchDuplicated($mu, $(ntuple(i -> dmus[i], Kc))), + Enzyme.BatchDuplicated($q0, $(ntuple(i -> seeds[i], Kc))), + ) + end + end + else + throw(ArgumentError("Unknown mode :$mode.")) + end +end + +const AnyJuliaProblem = Union{JuliaProblem, JuliaProblem2, JuliaProblem3, JuliaProblem4, JuliaProblem5, JuliaProblem6, JuliaProblem7} + +LogDensityProblems.dimension(p::AnyJuliaProblem) = length(p._q0) +LogDensityProblems.capabilities(::Type{<:AnyJuliaProblem}) = LogDensityProblems.LogDensityOrder{1}() +LogDensityProblems.logdensity(p::AnyJuliaProblem, q::AbstractVector{<:Real}) = p._logdensity(q) + +function LogDensityProblems.logdensity_and_gradient(p::AnyJuliaProblem, q::AbstractVector{<:Real}) + grad = similar(q, Float64) + prep = DI.prepare_gradient(p._logdensity, AutoForwardDiff(), q) + val, _ = DI.value_and_gradient!(p._logdensity, grad, prep, AutoForwardDiff(), q) + return val, grad +end + +function _benchmark(p::AnyJuliaProblem, mode::Symbol; ad=AutoForwardDiff()) + q0 = p._q0 + ℓ = p._logdensity + if mode === :primal + return @be $ℓ($q0) + elseif mode === :gradient + prep = DI.prepare_gradient(ℓ, ad, q0) + grad = similar(q0) + return @be DI.value_and_gradient!($ℓ, $grad, $prep, $ad, $q0) + else + throw(ArgumentError("Unknown mode :$mode. Choose :primal or :gradient.")) + end +end + +# ── Turing (DynamicPPL) problem ────────────────────────────────────────────── +# +# Uses DynamicPPL's @model macro to define the same regression model. +# Gradients are computed via DifferentiationInterface with a user-selected +# AD backend. + +@model function _turing_brms_linear(Y, Xc, Kc, int_prior, sig_prior) + # Flat prior on regression coefficients (matches brms default) + b ~ filldist(Flat(), Kc) + + # student_t prior on Intercept + Intercept ~ int_prior[2] + int_prior[3] * TDist(int_prior[1]) + + # half-student_t prior on sigma + sigma ~ truncated(sig_prior[2] + sig_prior[3] * TDist(sig_prior[1]), lower=0.0) + + # Likelihood + mu = Xc * b .+ Intercept + for i in eachindex(Y) + Y[i] ~ Normal(mu[i], sigma) + end +end + +@model function _turing_brms_linear_addlogprob(Y, Xc, Kc, int_prior, sig_prior) + N = length(Y) + + # Flat prior on regression coefficients (matches brms default) + b ~ filldist(Flat(), Kc) + + # student_t prior on Intercept + Intercept ~ int_prior[2] + int_prior[3] * TDist(int_prior[1]) + + # half-student_t prior on sigma + sigma ~ truncated(sig_prior[2] + sig_prior[3] * TDist(sig_prior[1]), lower=0.0) + + # Likelihood via @addlogprob! — bypasses per-observation tilde processing + dmu = Y .- (Xc * b .+ Intercept) + Turing.@addlogprob! -N/2 * log(2π) - N * log(sigma) - sum(abs2, dmu) / (2 * sigma^2) +end + +struct TuringProblem{L} + _logdensity::L # DynamicPPL.LogDensityFunction + _q0::Vector{Float64} +end + +""" + TuringProblem(formula, data; intercept_prior, sigma_prior) -> TuringProblem + +Build a DynamicPPL model matching the brms-generated Stan model and wrap it +in a `LogDensityFunction` that implements the `LogDensityProblems` interface. +""" +function TuringProblem( + formula::String, data::DataFrame; + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), + kwargs..., +) + response, predictors = _parse_formula(formula) + Y = Vector{Float64}(data[!, response]) + Kc = length(predictors) + Xc, _ = _center_predictors(data, predictors) + + model = _turing_brms_linear(Y, Xc, Kc, intercept_prior, sigma_prior) + ℓ = DynamicPPL.LogDensityFunction(model, DynamicPPL.getlogjoint_internal, DynamicPPL.LinkAll()) + + q0 = zeros(LogDensityProblems.dimension(ℓ)) + return TuringProblem(ℓ, q0) +end + +""" + TuringProblem with `@addlogprob!` — uses `:turing2` backend. + +Same priors as the standard Turing model, but the likelihood is computed +manually and added via `Turing.@addlogprob!`, bypassing per-observation +tilde processing. +""" +function TuringProblem2( + formula::String, data::DataFrame; + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), + kwargs..., +) + response, predictors = _parse_formula(formula) + Y = Vector{Float64}(data[!, response]) + Kc = length(predictors) + Xc, _ = _center_predictors(data, predictors) + + model = _turing_brms_linear_addlogprob(Y, Xc, Kc, intercept_prior, sigma_prior) + ℓ = DynamicPPL.LogDensityFunction(model, DynamicPPL.getlogjoint_internal, DynamicPPL.LinkAll()) + + q0 = zeros(LogDensityProblems.dimension(ℓ)) + return TuringProblem(ℓ, q0) +end + +LogDensityProblems.dimension(p::TuringProblem) = length(p._q0) +LogDensityProblems.capabilities(::Type{<:TuringProblem}) = LogDensityProblems.LogDensityOrder{1}() +LogDensityProblems.logdensity(p::TuringProblem, q::AbstractVector{<:Real}) = + LogDensityProblems.logdensity(p._logdensity, q) + +function LogDensityProblems.logdensity_and_gradient(p::TuringProblem, q::AbstractVector{<:Real}) + f = Base.Fix1(LogDensityProblems.logdensity, p._logdensity) + grad = similar(q, Float64) + prep = DI.prepare_gradient(f, AutoForwardDiff(), q) + val, _ = DI.value_and_gradient!(f, grad, prep, AutoForwardDiff(), q) + return val, grad +end + +function _benchmark(p::TuringProblem, mode::Symbol; ad=AutoForwardDiff()) + q0 = p._q0 + ℓ_dppl = p._logdensity + f = Base.Fix1(LogDensityProblems.logdensity, ℓ_dppl) + if mode === :primal + return @be $f($q0) + elseif mode === :gradient + prep = DI.prepare_gradient(f, ad, q0) + grad = similar(q0) + return @be DI.value_and_gradient!($f, $grad, $prep, $ad, $q0) + else + throw(ArgumentError("Unknown mode :$mode. Choose :primal or :gradient.")) + end +end + +# ── Public API ──────────────────────────────────────────────────────────────── + +""" + make_problem(formula, data, backend) -> PyMCProblem | StanProblem | JuliaProblem | TuringProblem + +Build a log-density problem for `backend` (`:bambi`, `:brms`, `:julia`, or `:turing`). +The returned object implements the `LogDensityProblems` interface: +`logdensity_and_gradient(problem, q)` takes a flat `Vector{Float64}` of +unconstrained parameters and returns `(logp::Float64, grad::Vector{Float64})`. +""" +function make_problem( + formula::String, + data::DataFrame, + backend::Symbol; + compiler::Symbol = :pytensor, + source::Union{Symbol,Nothing} = nothing, + key::Union{Symbol,Nothing} = nothing, + models_dir::String = joinpath(@__DIR__, "models"), + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), +) + if backend === :bambi + return PyMCProblem(formula, data; compiler) + elseif backend === :brms + return StanProblem(formula, data; source, key, models_dir) + elseif backend === :julia + return JuliaProblem(formula, data; intercept_prior, sigma_prior) + elseif backend === :julia2 + return JuliaProblem2(formula, data; intercept_prior, sigma_prior) + elseif backend === :julia3 + return JuliaProblem3(formula, data; intercept_prior, sigma_prior) + elseif backend === :julia4 + return JuliaProblem4(formula, data; intercept_prior, sigma_prior) + elseif backend === :julia5 + return JuliaProblem5(formula, data; intercept_prior, sigma_prior) + elseif backend === :julia6 + return JuliaProblem6(formula, data; intercept_prior, sigma_prior) + elseif backend === :julia7 + return JuliaProblem7(formula, data; intercept_prior, sigma_prior) + elseif backend === :turing + return TuringProblem(formula, data; intercept_prior, sigma_prior) + elseif backend === :turing2 + return TuringProblem2(formula, data; intercept_prior, sigma_prior) + else + throw(ArgumentError("Unknown backend :$backend. Choose :bambi, :brms, :julia, or :turing.")) + end +end + +# ── Low-overhead benchmark helpers ─────────────────────────────────────────── +# +# These bypass the LogDensityProblems interface to eliminate interop overhead: +# +# PyMCProblem: pre-converts q0 to a numpy array with $ interpolation, so each +# timed call is purely the pytensor computation (no Julia→Python conversion). +# +# StanProblem: pre-allocates the gradient buffer (log_density_gradient!) and +# uses $ interpolation for the model and q0, so each timed call is the C +# computation only (no alloc for the gradient vector). +# For the primal, uses propto=false (avoids autodiff-type overhead when no +# gradient is needed; see BridgeStan internals docs). + +function _benchmark(p::PyMCProblem, mode::Symbol; kwargs...) + q0_np = get_np().asarray(p._q0) + if mode === :primal + fn = p._logp_fn + return @be $fn($q0_np) + elseif mode === :gradient + fn = p._fn + return @be $fn($q0_np) + else + throw(ArgumentError("Unknown mode :$mode. Choose :primal or :gradient.")) + end +end + +function _benchmark(p::StanProblem, mode::Symbol; kwargs...) + q0 = p._q0 + if mode === :primal + return @be BridgeStan.log_density($p._model, $q0; propto=false, jacobian=true) + elseif mode === :gradient + grad = zeros(length(q0)) + return @be BridgeStan.log_density_gradient!($p._model, $q0, $grad) + else + throw(ArgumentError("Unknown mode :$mode. Choose :primal or :gradient.")) + end +end + +""" + benchmark_model(formula, data, backend; mode, ad) -> Chairmarks.Sample + +Build a log-density problem for the given backend, then use Chairmarks.@be to +benchmark a single evaluation at the initial unconstrained parameter vector. + +`mode` controls what is benchmarked: +- `:gradient` (default) — logp + gradient +- `:primal` — logp only, without gradient + +`ad` selects the AD backend for gradient computation (`:julia` / `:turing` only): +- `AutoForwardDiff()` (default), `AutoEnzyme()`, or `AutoMooncake()` + +Model compilation / pytensor tracing is excluded from the timing. +Interop overhead (Julia↔Python array conversion, gradient allocation) is +eliminated via \$ interpolation and pre-allocated buffers. +""" +function benchmark_model( + formula::String, + data::DataFrame, + backend::Symbol; + mode::Symbol = :gradient, + ad = AutoForwardDiff(), + compiler::Symbol = :pytensor, + source::Union{Symbol,Nothing} = nothing, + key::Union{Symbol,Nothing} = nothing, + models_dir::String = joinpath(@__DIR__, "models"), + intercept_prior::NTuple{3,Float64} = (3.0, 2.1, 2.5), + sigma_prior::NTuple{3,Float64} = (3.0, 0.0, 2.5), +) + problem = make_problem(formula, data, backend; compiler, source, key, models_dir, intercept_prior, sigma_prior) + return _benchmark(problem, mode; ad) +end diff --git a/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/data.json b/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/data.json new file mode 100644 index 0000000..e37c48a --- /dev/null +++ b/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/data.json @@ -0,0 +1 @@ +{"N":604,"Y":[1.8571,3.0714,1.5714,2.2143,1.0714,1.4286,1.1429,2.1429,2.1429,1.0714,1.8571,2.5,1.8571,2.7143,1.4286,1.7143,1.7143,3.1429,2.7143,1.9286,2.7143,2.2857,2.3571,1.7143,2,2.9286,2.5,2.9286,2.6429,2.2143,2.7857,2.7143,3.0714,2,3,1.9286,3.0714,2.5714,2.7143,3.0714,1.7857,1.7857,3.5714,2.2857,2.7857,2.1429,2.7143,2.7143,2.3571,2.2857,1.8571,2.5714,2.1429,3.0714,2.0714,3.5,1.7143,2.5,2.1429,1.1429,3.5,1.8571,3.2857,2.6429,2,1.8571,2.3571,2.2143,3.1429,2.6429,1.2857,1.6429,2.6429,2.0714,2.2143,3.0714,2.4286,3.2143,2.7143,2.0714,2.4286,2.0714,2.9286,3.4286,1.9286,2.5714,1,2.4286,2.1429,1.7143,1.7857,3.3571,1.7143,1.8571,2.0714,2.7143,1.5,1.5714,1.1429,1,2.8571,3.0714,2.1429,3.3571,3.2143,2.7857,2.3571,1.6429,2.2857,2.4286,2.4286,1.2857,1.5714,2.2143,1.9286,1.6429,2,3.0714,2.5,2.9286,2.5714,2,2.2143,1.2857,1.0714,3,2.6429,1.5,2.0714,4.2857,2.6429,3.1429,1,2.5714,2.8571,2,2.4286,1.7857,1.5714,2.4286,2.5714,2.5,2.0714,2.5,1.6429,2.3571,2.2143,1.3571,3.2143,1.8571,2.7143,1.5714,1.3571,2.1429,1.6429,3.6429,2.5714,2.3571,2.2143,2.1429,1.5,1.1429,2,1.8571,2.9286,2.7143,3.2143,1.5,2.2143,2.5,1.7143,2.1429,1.0714,2.4286,2.5,2.1429,1.8571,1.8571,2.9286,1.0714,1.7143,3.6429,2.7857,1.8571,2,2.4286,2.6429,2.5714,1.8571,3.2857,1.0714,2.2143,2.2857,1.7857,2.7857,2.2857,1.7143,1,1.6429,2.3571,2.5714,2.2857,1.2857,1.4286,1.6429,3.0714,1.8571,1.8571,3.4286,3.2857,2.5,2.6429,3.0714,2.5714,2.6429,3.3571,2.2857,1.4286,2.2143,2.4286,2.9286,1.7857,2.4286,2.1429,2.0714,3.2857,2.2143,1.1429,2.1429,2.0714,2.1429,2.6429,1.0714,1.9286,2.1429,2,3.2143,3.2857,1.2143,2.1429,3.5,1.5714,1.2143,1.7857,1.2857,1.5714,2,2.6429,2,3,3.2143,1.7143,2.3571,2.1429,3.2143,2.2143,1.2143,1.8571,1.9286,2.1429,1.2143,2.6429,2.5,1.5714,2.2857,1.9286,2.1429,1,2.2143,3,2.1429,1.8571,1.9286,3.2143,2.2857,2.4286,1,1.3571,1.7857,1.7857,3.1429,3.3571,2.4286,2.3571,1.9286,1.5714,1.3571,3.7143,3.2143,3.8571,2.0714,3.7857,2.2857,1,2.3571,2.7143,1.2857,2.5,2.2143,2.7143,1,3.5,2.8571,3.2857,2.1429,1.9286,3.1429,1.2143,2.1429,3.3571,2,2.3571,1.7857,2.1429,2.3571,3.4286,2,1.2857,2.2143,3.3571,1.3571,2.3571,3.0714,2.0714,2.5,2.7857,2.2857,3.5,2.5,1.8571,3.0714,2.2143,1.1429,2.7143,3.1429,2.1429,1.2857,2,1.7143,3,3.1429,2.9286,3.4286,2.7857,2.5,1.1429,2.5,1.3571,3.0714,2.9286,2,2.7857,2.3571,1,2.5714,2.1429,1,2.5714,1.6429,2.2143,2.4286,2.7857,2.7857,3.2143,1.4286,2.4286,2.4286,2.2857,3.0714,1,2.0714,2.6429,1.7143,1.9286,1.4286,1.0714,2.2143,3.2857,1.7143,2.2143,3.4286,1.1429,2.4286,2.4286,2.1429,1.7857,2.6429,1.7143,2.1429,2.6429,2.4286,2.5714,1.6429,2.2143,2.2857,1.2857,1.7143,2.6429,2,1.5,2.2857,1.5714,3,1.6429,3.0714,1.5,2.2857,2.2857,2.0714,2.7143,1.8571,2.2143,2,2.4286,2.2143,1.8571,3.2857,2.4286,1,2.9286,2.3571,2.4286,1.6429,2.4286,2.7143,2,2.4286,1.2857,1.0714,2.5714,2.4286,3.2857,2.2857,1.5714,2,2.6429,1.2143,3.2143,1.3571,1.7143,3.1429,3,2,2.0714,2.2143,3.1429,2.0714,1.1429,1.7857,1.7857,1.7857,1.8571,1.7857,2.5,2.0714,2,2.8571,2.7857,2.4286,2.8571,2.9286,1.7857,1.2143,3.1429,1.9286,3.0714,2.1429,1.6429,2.5714,1.5,3.2143,1.5714,2.5714,1.5714,1.2857,2.2857,1.0714,2.7857,2.3571,2.4286,2.0714,3,1.9286,2.1429,1.8571,2.3571,2.9286,2.2857,1.5,1.8571,1.4286,2.4286,3.5,2.5,1.4286,2.9286,1.6429,2.2857,1.9286,1.7143,2.1429,1.5,1.2143,1.9286,1.6429,1.3571,3.0714,1.4286,2.6429,1.3571,2.0714,3,1.3571,1.8571,1.4286,1.7857,2,2.4286,1.4286,2,3.0714,1.5,2,2.4286,2,2.6429,3.9286,2.4286,2,1.7143,1.4286,2,1.7857,1.8571,2.7857,1.1429,1.4286,2.2143,2.0714,1.4286,1.8571,2.6429,3.5,2,2,2.9286,1.7143,2.5714,2.2857,1.2143,2.6429,1.2143,1.9286,1.8571,1.5,1.5,1,1.8571,2.2857,2.2857,2,2.8571,1.2143,2.1429,1.7143,1.4286,2.6429,1.6429,1.5714,1.6429,1.5714,1.0714,2.0714,1.4286,2.3571,2.4286,2.4286,2.2857,1.8571,1.4286,1.7857,1.6429,1.6429,1.0714,3.7143,3.0714,2.2143,2.1429,1.7857,2,2.1429,3.8571,1.6429,3,2.6429,1.7143,2.7857,1.8571,3.1429,2.4286,1.5714,1.5,2.5,3.3571],"K":6,"Kc":5,"X":[[1,122,89,102,115,117],[1,142,132,92,140,69],[1,117,173,101,148,69],[1,130,134,99,135,87],[1,100,130,116,117,50],[1,150,145,130,97,62],[1,105,129,121,128,69],[1,92,125,99,134,82],[1,129,137,123,124,65],[1,85,108,103,145,80],[1,111,84,103,97,122],[1,92,112,99,132,75],[1,111,125,106,108,111],[1,152,97,122,115,93],[1,82,154,101,138,44],[1,120,101,107,109,126],[1,73,127,82,125,85],[1,115,117,93,126,123],[1,114,114,132,124,59],[1,116,111,135,119,50],[1,98,128,99,131,73],[1,107,139,117,98,59],[1,102,154,138,106,59],[1,115,129,99,137,70],[1,101,120,149,127,112],[1,107,111,93,122,71],[1,127,91,87,124,70],[1,108,112,77,122,53],[1,90,137,92,132,82],[1,123,152,123,95,55],[1,106,133,103,138,70],[1,92,108,95,121,90],[1,131,122,105,80,84],[1,96,130,94,118,73],[1,83,141,117,93,64],[1,122,137,90,123,69],[1,128,121,123,106,66],[1,114,109,98,119,83],[1,114,116,65,119,103],[1,140,131,136,69,97],[1,65,146,83,127,63],[1,109,145,119,134,70],[1,138,112,123,121,82],[1,84,123,88,101,93],[1,142,106,88,132,96],[1,100,155,123,129,58],[1,127,103,78,107,80],[1,124,123,110,90,83],[1,121,149,129,141,54],[1,131,96,101,138,105],[1,103,151,124,134,49],[1,89,126,105,99,85],[1,82,126,86,98,76],[1,174,133,143,92,142],[1,110,131,110,103,103],[1,131,114,102,97,68],[1,111,122,103,143,91],[1,111,129,86,118,51],[1,115,144,126,122,52],[1,129,101,83,133,109],[1,146,141,144,116,51],[1,124,127,106,119,74],[1,117,144,111,126,69],[1,86,120,61,112,124],[1,112,123,107,116,94],[1,110,124,110,127,75],[1,129,145,121,145,64],[1,107,151,103,100,54],[1,142,130,115,133,100],[1,124,129,124,110,78],[1,99,143,109,133,66],[1,122,145,122,123,76],[1,141,128,101,100,73],[1,107,108,93,113,71],[1,140,114,104,112,107],[1,144,129,115,101,80],[1,108,110,88,124,93],[1,126,105,90,129,77],[1,122,135,113,110,78],[1,127,91,138,146,104],[1,116,136,125,113,70],[1,121,113,90,125,68],[1,137,128,132,117,102],[1,125,125,117,129,72],[1,106,124,94,149,72],[1,137,91,62,124,114],[1,100,125,120,142,57],[1,84,143,77,136,53],[1,110,123,65,131,146],[1,138,163,150,136,82],[1,114,124,117,114,67],[1,107,121,99,111,100],[1,124,124,112,120,98],[1,92,112,79,126,85],[1,78,119,93,122,62],[1,124,122,112,125,54],[1,103,134,124,129,61],[1,123,115,97,122,59],[1,78,155,82,138,90],[1,90,140,103,147,71],[1,103,130,109,118,56],[1,122,155,75,74,56],[1,92,149,111,106,91],[1,127,122,108,115,132],[1,137,114,105,114,84],[1,97,119,71,85,103],[1,109,127,110,142,90],[1,108,145,109,129,67],[1,103,158,125,134,34],[1,89,111,86,120,84],[1,144,127,133,132,61],[1,136,160,103,148,63],[1,161,136,63,141,50],[1,111,118,96,111,62],[1,109,129,109,112,74],[1,119,127,91,141,64],[1,80,154,109,130,50],[1,102,115,133,111,72],[1,115,109,57,115,69],[1,119,116,127,97,92],[1,119,141,92,127,83],[1,131,128,92,126,79],[1,74,123,76,117,70],[1,112,126,114,153,108],[1,78,135,96,96,61],[1,104,157,140,105,39],[1,115,126,90,118,96],[1,82,128,82,123,73],[1,166,118,111,108,107],[1,138,97,125,107,88],[1,106,136,79,126,47],[1,106,104,96,95,98],[1,118,130,144,149,26],[1,111,137,109,84,90],[1,113,141,94,122,77],[1,88,131,80,132,91],[1,117,121,114,93,67],[1,157,97,116,139,163],[1,130,133,100,144,49],[1,108,67,84,111,149],[1,114,112,70,109,69],[1,104,91,91,97,94],[1,110,128,111,130,84],[1,123,140,125,119,66],[1,120,135,136,162,61],[1,102,93,102,122,68],[1,105,119,136,125,49],[1,107,130,103,122,75],[1,106,139,108,121,65],[1,137,112,94,143,61],[1,124,157,101,143,34],[1,131,138,118,134,57],[1,103,125,122,128,67],[1,77,103,89,136,119],[1,139,138,134,125,84],[1,122,125,103,94,100],[1,87,135,62,130,87],[1,111,136,136,128,59],[1,111,111,102,157,45],[1,95,111,109,103,114],[1,105,146,106,136,80],[1,114,119,104,125,65],[1,137,130,126,117,63],[1,131,111,93,137,50],[1,146,143,112,147,66],[1,142,123,129,110,94],[1,130,141,99,107,67],[1,90,91,52,140,141],[1,108,160,108,125,61],[1,114,153,105,93,62],[1,109,97,96,132,98],[1,105,130,119,144,82],[1,109,126,107,136,77],[1,139,117,133,145,75],[1,136,99,104,100,84],[1,92,116,124,93,77],[1,140,125,109,100,66],[1,101,130,105,139,76],[1,145,118,96,85,70],[1,98,139,128,131,142],[1,132,113,125,123,71],[1,114,102,113,133,80],[1,136,132,113,129,84],[1,76,133,87,127,51],[1,118,102,81,121,91],[1,114,140,126,133,44],[1,120,107,107,120,68],[1,122,120,121,121,90],[1,112,139,143,107,82],[1,157,158,134,124,57],[1,113,127,119,117,55],[1,132,130,123,99,45],[1,96,121,92,124,71],[1,95,104,79,111,95],[1,130,125,127,109,66],[1,120,130,100,131,81],[1,103,89,72,127,116],[1,105,132,92,131,110],[1,84,97,114,99,126],[1,101,110,96,115,74],[1,107,124,95,130,84],[1,106,97,108,138,105],[1,102,140,96,130,62],[1,96,106,115,121,83],[1,117,122,113,119,95],[1,108,140,130,127,69],[1,138,132,138,133,60],[1,101,97,121,121,75],[1,54,121,116,137,57],[1,104,109,119,89,85],[1,92,158,87,101,64],[1,132,109,79,106,117],[1,159,98,109,124,79],[1,97,127,122,130,62],[1,99,151,133,105,75],[1,141,104,118,140,80],[1,116,120,126,149,64],[1,110,117,120,122,78],[1,101,126,105,128,72],[1,119,161,126,144,34],[1,128,137,123,108,82],[1,115,122,94,146,69],[1,125,155,117,151,23],[1,143,108,130,134,63],[1,121,131,105,119,95],[1,115,115,129,112,87],[1,137,133,104,127,75],[1,117,159,120,92,65],[1,125,118,107,118,73],[1,97,120,102,124,116],[1,114,131,90,115,39],[1,114,148,90,87,91],[1,105,127,84,143,107],[1,95,152,135,119,80],[1,104,133,97,125,78],[1,92,115,113,143,108],[1,100,108,116,112,86],[1,91,123,130,112,84],[1,105,123,80,140,67],[1,136,109,94,126,81],[1,64,78,62,101,148],[1,79,92,158,110,41],[1,96,156,94,147,31],[1,83,123,91,155,79],[1,120,137,108,147,93],[1,110,104,106,143,65],[1,98,131,114,106,89],[1,80,156,104,96,57],[1,64,135,76,144,60],[1,108,143,114,115,62],[1,131,96,93,140,138],[1,141,127,135,106,82],[1,51,136,105,103,67],[1,103,99,70,139,105],[1,98,127,102,123,61],[1,100,130,104,134,83],[1,109,126,125,134,66],[1,129,142,93,123,68],[1,52,155,128,125,62],[1,88,117,90,128,57],[1,107,103,112,156,83],[1,112,127,128,125,47],[1,111,127,129,133,67],[1,99,98,118,130,125],[1,124,113,105,131,71],[1,77,113,82,125,94],[1,79,123,86,126,54],[1,80,156,103,146,51],[1,112,138,110,135,57],[1,77,140,122,103,68],[1,111,114,111,113,89],[1,94,121,97,106,57],[1,138,116,136,138,61],[1,102,133,81,138,73],[1,112,134,123,148,95],[1,89,103,123,117,93],[1,89,136,94,112,112],[1,101,100,110,107,79],[1,91,96,85,127,93],[1,100,136,99,141,69],[1,147,121,143,112,88],[1,102,151,149,118,82],[1,116,116,107,100,111],[1,112,145,118,112,76],[1,91,149,87,115,44],[1,133,133,107,149,72],[1,142,123,136,138,76],[1,77,91,102,73,97],[1,121,110,155,118,50],[1,118,102,109,78,125],[1,96,157,115,139,75],[1,111,141,144,124,119],[1,115,144,99,122,60],[1,90,117,102,138,75],[1,111,107,112,123,65],[1,133,140,136,128,74],[1,124,159,130,136,75],[1,123,129,133,132,72],[1,94,123,100,89,93],[1,139,132,141,119,30],[1,64,127,72,153,126],[1,131,111,92,121,98],[1,137,126,119,110,98],[1,128,124,124,93,117],[1,108,141,121,124,74],[1,97,135,91,117,92],[1,130,131,103,103,86],[1,82,141,117,123,67],[1,131,113,138,99,126],[1,86,118,117,122,82],[1,129,116,109,135,55],[1,91,89,72,105,122],[1,73,134,59,143,94],[1,111,127,103,139,72],[1,109,122,115,145,94],[1,161,96,137,126,76],[1,76,140,100,139,60],[1,98,147,103,136,53],[1,105,131,97,113,70],[1,149,89,133,123,83],[1,80,157,62,106,150],[1,131,131,81,104,74],[1,97,129,114,115,64],[1,102,150,90,137,127],[1,110,133,111,113,69],[1,141,99,115,129,71],[1,124,91,112,112,89],[1,126,127,124,117,66],[1,114,130,118,103,65],[1,122,127,110,129,79],[1,111,120,98,120,114],[1,109,138,121,153,87],[1,86,134,125,128,75],[1,93,133,91,134,69],[1,152,98,122,137,71],[1,70,130,70,122,114],[1,110,105,109,123,89],[1,138,119,110,127,73],[1,101,91,96,96,102],[1,130,131,99,99,94],[1,112,118,74,123,69],[1,130,89,96,111,125],[1,111,95,94,88,116],[1,128,114,115,130,51],[1,58,155,129,143,45],[1,126,123,92,127,50],[1,121,150,130,126,66],[1,112,110,110,96,113],[1,112,140,122,109,90],[1,144,110,104,141,76],[1,74,123,87,127,68],[1,114,119,79,130,103],[1,142,164,155,124,59],[1,103,108,94,116,129],[1,125,125,129,122,78],[1,108,113,134,121,76],[1,81,163,118,147,27],[1,103,151,92,127,61],[1,91,127,107,119,66],[1,101,121,103,86,142],[1,128,100,108,129,127],[1,88,122,141,152,58],[1,137,101,76,119,94],[1,111,117,129,127,74],[1,159,101,105,153,84],[1,112,125,130,133,66],[1,105,127,100,123,92],[1,159,180,100,143,63],[1,134,140,89,133,111],[1,73,155,92,137,85],[1,110,146,105,129,103],[1,132,107,114,129,45],[1,106,125,105,145,91],[1,140,125,116,131,63],[1,78,136,91,171,118],[1,89,126,52,139,100],[1,120,121,123,124,82],[1,110,117,106,143,73],[1,115,140,113,145,105],[1,91,129,97,137,66],[1,127,124,118,113,106],[1,145,119,74,135,73],[1,133,145,121,133,38],[1,127,132,130,134,70],[1,97,129,117,150,75],[1,99,136,86,147,71],[1,135,113,113,125,72],[1,135,120,129,139,73],[1,146,95,95,122,90],[1,94,144,128,135,74],[1,157,115,115,128,78],[1,123,123,92,90,103],[1,95,158,143,140,46],[1,159,126,134,130,128],[1,129,133,126,121,80],[1,108,119,111,124,70],[1,129,121,113,132,73],[1,131,129,119,135,89],[1,121,44,135,131,102],[1,116,133,119,137,77],[1,126,128,113,121,124],[1,107,113,99,136,85],[1,135,93,70,113,83],[1,135,81,92,139,101],[1,120,121,119,118,56],[1,117,156,79,121,27],[1,109,116,120,132,74],[1,135,132,102,147,45],[1,111,111,115,151,90],[1,116,159,128,136,66],[1,127,127,116,108,115],[1,137,145,120,160,55],[1,124,119,97,90,121],[1,127,142,92,143,87],[1,117,141,94,122,115],[1,72,131,105,153,102],[1,139,136,100,106,67],[1,112,134,105,115,64],[1,117,118,111,132,75],[1,131,94,109,124,75],[1,99,99,91,120,71],[1,138,114,70,128,89],[1,80,147,50,143,75],[1,132,76,120,96,89],[1,103,130,82,122,67],[1,98,149,84,147,102],[1,129,153,121,145,24],[1,93,126,123,123,82],[1,73,141,87,95,82],[1,165,137,98,132,57],[1,135,115,115,138,80],[1,105,168,116,107,34],[1,122,133,114,131,54],[1,120,115,109,135,96],[1,133,103,102,96,112],[1,110,131,122,129,40],[1,107,122,98,125,84],[1,132,132,120,115,54],[1,124,119,119,128,73],[1,138,108,126,145,96],[1,91,117,83,140,89],[1,156,124,141,130,117],[1,113,112,105,127,83],[1,111,122,78,92,130],[1,134,136,92,126,62],[1,108,129,114,119,81],[1,104,85,114,130,94],[1,74,156,109,132,49],[1,126,142,115,126,60],[1,116,118,122,128,84],[1,125,123,134,138,71],[1,116,131,122,117,115],[1,91,114,107,117,90],[1,99,122,84,81,70],[1,94,141,108,127,59],[1,84,130,78,155,36],[1,70,125,82,134,75],[1,109,122,113,112,66],[1,93,107,87,142,92],[1,90,131,120,130,74],[1,146,107,135,148,70],[1,131,120,126,141,96],[1,132,129,140,135,77],[1,139,121,79,155,89],[1,104,128,102,114,71],[1,120,105,74,130,74],[1,124,119,116,134,68],[1,108,107,99,115,95],[1,126,100,129,169,61],[1,108,127,92,127,140],[1,151,132,117,129,84],[1,75,127,92,118,107],[1,102,112,79,99,87],[1,110,150,98,130,74],[1,115,132,114,127,58],[1,131,146,101,126,68],[1,59,154,93,118,66],[1,106,139,83,105,62],[1,141,120,127,133,67],[1,110,130,123,133,68],[1,118,102,85,130,76],[1,107,105,117,122,84],[1,123,144,101,111,103],[1,154,111,101,155,73],[1,98,132,109,117,90],[1,93,146,138,109,116],[1,107,136,105,121,74],[1,135,109,89,116,124],[1,118,148,119,147,45],[1,131,103,134,128,103],[1,131,121,124,154,64],[1,122,118,139,119,65],[1,137,128,115,112,68],[1,128,95,91,127,83],[1,77,148,110,130,56],[1,126,134,99,140,81],[1,78,120,86,125,111],[1,95,118,79,106,56],[1,100,106,109,77,141],[1,106,119,48,126,112],[1,138,136,134,154,44],[1,131,75,42,131,125],[1,109,124,76,148,93],[1,122,100,150,118,84],[1,150,131,137,149,45],[1,111,86,92,148,75],[1,162,122,123,125,103],[1,154,113,111,110,98],[1,93,115,69,63,63],[1,97,129,106,147,58],[1,122,114,101,124,108],[1,111,115,78,103,110],[1,73,151,88,138,101],[1,133,140,95,138,41],[1,112,143,75,134,71],[1,119,136,128,142,52],[1,119,152,98,96,81],[1,124,102,98,101,77],[1,92,116,83,113,123],[1,156,112,130,131,71],[1,126,133,116,112,70],[1,106,131,112,138,68],[1,145,107,104,106,105],[1,133,86,107,141,82],[1,104,93,63,117,93],[1,88,129,77,138,78],[1,101,73,104,113,78],[1,91,115,103,134,101],[1,134,148,126,119,71],[1,117,152,112,135,68],[1,161,114,106,123,68],[1,123,81,94,113,134],[1,102,83,59,147,115],[1,122,134,117,139,90],[1,99,137,98,144,75],[1,126,130,109,130,71],[1,109,136,114,128,75],[1,132,137,148,133,68],[1,114,148,134,137,73],[1,87,129,114,133,92],[1,106,155,107,123,43],[1,132,118,106,126,64],[1,151,97,120,116,101],[1,104,134,61,157,87],[1,89,104,93,115,108],[1,94,125,96,131,114],[1,110,132,98,146,58],[1,137,109,110,89,88],[1,114,126,105,133,79],[1,104,134,107,148,72],[1,105,120,89,104,96],[1,108,123,75,130,67],[1,146,130,120,137,68],[1,106,125,89,114,105],[1,113,117,84,133,86],[1,147,136,96,128,44],[1,104,142,119,147,101],[1,142,136,87,128,60],[1,152,73,98,142,74],[1,111,129,102,135,108],[1,119,119,92,112,90],[1,108,106,127,144,67],[1,105,141,98,130,55],[1,133,135,114,140,49],[1,100,131,112,132,75],[1,94,145,75,141,37],[1,113,120,113,141,67],[1,102,119,80,131,90],[1,112,121,102,137,70],[1,104,108,92,137,103],[1,101,107,86,122,81],[1,94,100,63,138,91],[1,96,98,94,98,96],[1,129,149,94,128,88],[1,129,172,129,155,55],[1,130,136,114,129,63],[1,142,101,90,135,76],[1,84,109,70,107,110],[1,140,51,100,131,117],[1,93,144,89,136,58],[1,134,113,94,136,94],[1,81,129,80,138,87],[1,91,92,81,120,132],[1,100,90,96,127,104],[1,152,123,150,139,80],[1,143,116,120,115,98],[1,127,150,114,147,92],[1,112,125,114,103,106],[1,122,113,114,124,88],[1,128,122,121,140,56],[1,135,110,120,139,90],[1,123,124,148,108,105],[1,86,92,88,133,109],[1,104,70,109,125,98],[1,161,136,145,105,53],[1,125,131,114,141,62],[1,129,103,121,137,89],[1,163,145,128,126,67],[1,151,132,153,124,100],[1,95,130,132,149,93],[1,134,136,128,159,69],[1,97,110,112,132,133],[1,174,124,158,155,33],[1,105,102,98,126,121]],"prior_only":0} \ No newline at end of file diff --git a/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model.stan b/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model.stan new file mode 100644 index 0000000..52e38ee --- /dev/null +++ b/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model.stan @@ -0,0 +1,43 @@ +// generated with brms 2.23.1 +functions { +} +data { + int N; // total number of observations + vector[N] Y; // response variable + int K; // number of population-level effects + matrix[N, K] X; // population-level design matrix + int Kc; // number of population-level effects after centering + int prior_only; // should the likelihood be ignored? +} +transformed data { + matrix[N, Kc] Xc; // centered version of X without an intercept + vector[Kc] means_X; // column means of X before centering + for (i in 2:K) { + means_X[i - 1] = mean(X[, i]); + Xc[, i - 1] = X[, i] - means_X[i - 1]; + } +} +parameters { + vector[Kc] b; // regression coefficients + real Intercept; // temporary intercept for centered predictors + real sigma; // dispersion parameter +} +transformed parameters { + // prior contributions to the log posterior + real lprior = 0; + lprior += student_t_lpdf(Intercept | 3, 2.1, 2.5); + lprior += student_t_lpdf(sigma | 3, 0, 2.5) + - 1 * student_t_lccdf(0 | 3, 0, 2.5); +} +model { + // likelihood including constants + if (!prior_only) { + target += normal_id_glm_lpdf(Y | Xc, Intercept, b, sigma); + } + // priors including constants + target += lprior; +} +generated quantities { + // actual population-level intercept + real b_Intercept = Intercept - dot_product(means_X, b); +} diff --git a/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_loop_inline.stan b/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_loop_inline.stan new file mode 100644 index 0000000..65dbc26 --- /dev/null +++ b/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_loop_inline.stan @@ -0,0 +1,39 @@ +// Variant: vectorized normal_lpdf with matrix-vector product Xc * b. +// Unlike normal_id_glm_lpdf, the linear predictor is computed separately +// (not fused into the likelihood), but still uses Eigen's matrix-vector multiply. +data { + int N; + vector[N] Y; + int K; + matrix[N, K] X; + int Kc; + int prior_only; +} +transformed data { + matrix[N, Kc] Xc; + vector[Kc] means_X; + for (i in 2:K) { + means_X[i - 1] = mean(X[, i]); + Xc[, i - 1] = X[, i] - means_X[i - 1]; + } +} +parameters { + vector[Kc] b; + real Intercept; + real sigma; +} +transformed parameters { + real lprior = 0; + lprior += student_t_lpdf(Intercept | 3, 2.1, 2.5); + lprior += student_t_lpdf(sigma | 3, 0, 2.5) + - 1 * student_t_lccdf(0 | 3, 0, 2.5); +} +model { + if (!prior_only) { + target += normal_lpdf(Y | Intercept + Xc * b, sigma); + } + target += lprior; +} +generated quantities { + real b_Intercept = Intercept - dot_product(means_X, b); +} diff --git a/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_loop_precompute.stan b/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_loop_precompute.stan new file mode 100644 index 0000000..f3e89e7 --- /dev/null +++ b/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_loop_precompute.stan @@ -0,0 +1,39 @@ +// Variant: precompute mu in a loop, then pass to vectorized normal_lpdf. +// Separates the dot-product loop from the likelihood evaluation. +data { + int N; + vector[N] Y; + int K; + matrix[N, K] X; + int Kc; + int prior_only; +} +transformed data { + matrix[N, Kc] Xc; + vector[Kc] means_X; + for (i in 2:K) { + means_X[i - 1] = mean(X[, i]); + Xc[, i - 1] = X[, i] - means_X[i - 1]; + } +} +parameters { + vector[Kc] b; + real Intercept; + real sigma; +} +transformed parameters { + real lprior = 0; + lprior += student_t_lpdf(Intercept | 3, 2.1, 2.5); + lprior += student_t_lpdf(sigma | 3, 0, 2.5) + - 1 * student_t_lccdf(0 | 3, 0, 2.5); +} +model { + if (!prior_only) { + vector[N] mu= Intercept + Xc * b; + target += normal_lpdf(Y | mu, sigma); + } + target += lprior; +} +generated quantities { + real b_Intercept = Intercept - dot_product(means_X, b); +} diff --git a/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_model.so b/scripts/Benchmarking/models/bambi/escs/drugs_o_c_e_a_n/model_model.so new file mode 100755 index 0000000000000000000000000000000000000000..ca120d98eb53a4b04a4517efe224f85578367d6e GIT binary patch literal 864280 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

)t+j}i!yXDOl(P?Zu)WZgn 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 rtol + msg = @sprintf("max|Δ|=%.2e, rel=%.2e", maxdiff, reldiff) + @printf(" %-40s WRONG (%s)\n", label, msg) + return (label=label, error=msg) + end + + # Benchmark + try + print_result(label, _benchmark(problem, :gradient; ad)) + return nothing + catch e + @printf(" %-40s FAILED\n", label) + return (label=label, error=sprint(showerror, e, catch_backtrace())) + end +end + +enzyme_rev = AutoEnzyme(; mode=Enzyme.Reverse, function_annotation=Enzyme.Duplicated) +enzyme_fwd = AutoEnzyme(; mode=Enzyme.Forward, function_annotation=Enzyme.Duplicated) +errors = [] + +# ── Reference gradient from brms (Stan) ────────────────────────────────────── +brms_problem = make_problem(formula, data, :brms; source=:bambi, key=:escs) +q_test = randn(dimension(brms_problem)) +_, ref_grad = logdensity_and_gradient(brms_problem, q_test) + +println("Reference: brms/Stan gradient at random q") +@printf(" max|grad| = %.4f\n\n", maximum(abs.(ref_grad))) + +# ── brms (Stan) ────────────────────────────────────────────────────────────── +println("brms (Stan):") +print_result(" primal", _benchmark(brms_problem, :primal)) +print_result(" gradient", _benchmark(brms_problem, :gradient)) +println() + +# ── Julia hand-written variants ────────────────────────────────────────────── +ad_backends = [ + (enzyme_fwd, "Enzyme fwd"), + (enzyme_rev, "Enzyme rev"), + (DI.AutoMooncakeForward(), "Mooncake fwd"), + (AutoMooncake(), "Mooncake rev"), +] + +for (backend, desc) in [ + (:julia3, "julia3 (BLAS mul!)"), + (:julia5, "julia5 (5-arg mul!)"), + (:julia6, "julia6 (manual gemv)"), +] + println("$desc:") + problem = make_problem(formula, data, backend) + print_result(" primal", _benchmark(problem, :primal)) + + for (ad, ad_name) in ad_backends + err = try_benchmark(" gradient ($ad_name)", problem, ad, ref_grad, q_test) + err !== nothing && push!(errors, err) + end + println() +end + +# ── julia7: fine-grained Enzyme annotations ────────────────────────────────── +println("julia7 (split Enzyme: Const closure + Duplicated buffer):") +jp7 = make_problem(formula, data, :julia7) +print_result(" primal", _benchmark(jp7, :primal)) + +# Enzyme split: Const(ℓ_inner) + Duplicated(mu) + Duplicated(q) +# Enzyme split reverse +let mode_name = "Enzyme split rev" + dmu = zeros(length(jp7._mu)); grad = zeros(dimension(jp7)) + try + Enzyme.autodiff(Enzyme.Reverse, Enzyme.Const(jp7._logdensity_split), Enzyme.Active, + Enzyme.Duplicated(jp7._mu, dmu), Enzyme.Duplicated(copy(q_test), grad)) + maxdiff = maximum(abs.(grad .- ref_grad)) + reldiff = maxdiff / max(maximum(abs.(ref_grad)), 1.0) + if reldiff > 1e-6 + msg = @sprintf("max|Δ|=%.2e, rel=%.2e", maxdiff, reldiff) + @printf(" %-40s WRONG (%s)\n", "gradient ($mode_name)", msg) + push!(errors, (label="gradient ($mode_name)", error=msg)) + else + print_result(" gradient ($mode_name)", _benchmark_enzyme_split(jp7, :gradient; enzyme_mode=Enzyme.Reverse)) + end + catch e + @printf(" %-40s FAILED\n", "gradient ($mode_name)") + push!(errors, (label="gradient ($mode_name)", error=sprint(showerror, e, catch_backtrace()))) + end +end + +# Also test Mooncake on julia7 for comparison +for (ad, ad_name) in [(AutoMooncake(), "Mooncake rev")] + err = try_benchmark(" gradient ($ad_name)", jp7, ad, ref_grad, q_test) + err !== nothing && push!(errors, err) +end +println() + +# ── Turing (DynamicPPL) ─────────────────────────────────────────────────────── +println("turing (DynamicPPL):") +tp = make_problem(formula, data, :turing) +print_result(" primal (loop ~)", _benchmark(tp, :primal)) +tp2 = make_problem(formula, data, :turing2) +print_result(" primal (@addlogprob!)", _benchmark(tp2, :primal)) +println() + +# ── Error report ───────────────────────────────────────────────────────────── +if !isempty(errors) + println("=" ^ 72) + println("ERRORS ($(length(errors))):") + println("=" ^ 72) + for e in errors + println() + println("── $(e.label) ──") + println(first(e.error, 500)) + end +end From c81f453cbf2ac1f46a623333a8a5696919dd8f20 Mon Sep 17 00:00:00 2001 From: Nikolas Siccha Date: Tue, 24 Mar 2026 16:32:19 +0100 Subject: [PATCH 7/7] Add Enzyme split fwd benchmark, update README timings Co-Authored-By: Claude Sonnet 4.6 --- scripts/Benchmarking/README.md | 52 +++++++++++++-------------- scripts/Benchmarking/run_benchmark.jl | 29 +++++++++++++++ 2 files changed, 55 insertions(+), 26 deletions(-) diff --git a/scripts/Benchmarking/README.md b/scripts/Benchmarking/README.md index 01babb5..a7aae7b 100644 --- a/scripts/Benchmarking/README.md +++ b/scripts/Benchmarking/README.md @@ -19,32 +19,32 @@ Gradient correctness is verified against brms/Stan as the reference. | Variant | Time | Allocs | vs Stan | |---|---|---|---| -| julia6 (manual gemv) | 640 ns | 0 | 3.0x faster | -| julia5 (5-arg mul!) | 670 ns | 0 | 2.8x faster | -| julia7 (split, BLAS mul!) | 680 ns | 0 | 2.8x faster | -| julia3 (BLAS mul!) | 700 ns | 0 | 2.7x faster | -| julia1 (allocating Xc*b) | 1.8 μs | 2 | 1.0x | -| **brms/Stan (glm fused)** | **1.9 μs** | **1** | **1.0x** | -| stan (matvec + vec normal) | 2.9 μs | 1 | 0.66x | -| turing2 (@addlogprob!) | 2.6 μs | 20 | 0.73x | -| stan (loop + vec normal) | 3.1 μs | 1 | 0.61x | -| julia2 (broadcasted row-dot) | 6.7 μs | 0 | 0.28x | -| turing (loop ~) | 10 μs | 20 | 0.19x | -| bambi/PyMC (pytensor) | 34 μs | 9 | 0.06x | +| julia3 (BLAS mul!) | 823 ns | 0 | 3.0x faster | +| julia5 (5-arg mul!) | 930 ns | 0 | 2.7x faster | +| julia6 (manual gemv) | 943 ns | 0 | 2.6x faster | +| julia7 (split, BLAS mul!) | 1.0 μs | 0 | 2.5x faster | +| julia1 (allocating Xc*b) | 1.8 μs | 2 | 1.4x faster | +| **brms/Stan (glm fused)** | **2.5 μs** | **1** | **1.0x** | +| stan (matvec + vec normal) | 2.9 μs | 1 | 0.86x | +| stan (loop + vec normal) | 3.1 μs | 1 | 0.81x | +| turing2 (@addlogprob!) | 6.7 μs | 24 | 0.37x | +| julia2 (broadcasted row-dot) | 6.7 μs | 0 | 0.37x | +| turing (loop ~) | 13.5 μs | 20 | 0.19x | +| bambi/PyMC (pytensor) | 34 μs | 9 | 0.07x | ### Gradient (log-density + gradient, correct results only) | Variant | Time | Allocs | vs Stan | |---|---|---|---| -| **julia7 Enzyme split rev** | **3.3 μs** | **0** | **1.0x** | -| **brms/Stan** | **3.4 μs** | **1** | **1.0x** | -| julia5 Enzyme Dup rev | 3.9 μs | 0 | 0.87x | -| julia3 Enzyme Dup rev | 4.0 μs | 0 | 0.85x | -| julia7 Enzyme split fwd | 6.1 μs | 0 | 0.56x | -| julia6 Enzyme Dup rev | 9.9 μs | 0 | 0.34x | -| julia7 Mooncake rev | 10.8 μs | 1 | 0.31x | -| julia3 Mooncake rev | 11.2 μs | 1 | 0.30x | -| julia6 Mooncake rev | 65.6 μs | 0 | 0.05x | +| **brms/Stan** | **4.2 μs** | **1** | **1.0x** | +| julia7 Enzyme split rev | 4.6 μs | 0 | 0.91x | +| julia3 Enzyme Dup rev | 4.8 μs | 0 | 0.88x | +| julia5 Enzyme Dup rev | 5.1 μs | 0 | 0.82x | +| julia7 Enzyme split fwd | 8.6 μs | 0 | 0.49x | +| julia6 Enzyme Dup rev | 13.4 μs | 0 | 0.31x | +| julia3 Mooncake rev | 15.7 μs | 1 | 0.27x | +| julia7 Mooncake rev | 16.2 μs | 1 | 0.26x | +| julia6 Mooncake rev | 91.4 μs | 0 | 0.05x | ## Implementations @@ -81,8 +81,8 @@ All implement the same log-density as the brms-generated Stan model: centered pr ### Mooncake -- **Reverse mode**: Correct gradients, ~11 μs on julia3/5/7. Automatically determines constness (uses `NoRData` for Y/Xc) but has higher per-call overhead than Enzyme's LLVM-level codegen. -- **Forward mode**: Correct but extremely slow (milliseconds, 60-500k allocs). +- **Reverse mode**: Correct gradients, ~15–16 μs on julia3/5/7. Automatically determines constness (uses `NoRData` for Y/Xc) but has higher per-call overhead than Enzyme's LLVM-level codegen. +- **Forward mode**: Correct but extremely slow (milliseconds, 60k–500k allocs). - The split approach doesn't help Mooncake — it traces through the full closure graph regardless. ### ForwardDiff @@ -97,7 +97,7 @@ Stan evaluates with autodiff-ready `var` types even for primal-only calls (`prop ### Why Stan's gradient is hard to beat -Stan's `normal_id_glm_lpdf` has a hand-written adjoint that fuses primal and gradient into one pass, reusing intermediates. Gradient/primal ratio is 1.8x. Julia + Enzyme achieves 4.7x (whole-closure `Duplicated`) but matches Stan at 4.6x with fine-grained `Const`/`Duplicated` annotations. +Stan's `normal_id_glm_lpdf` has a hand-written adjoint that fuses primal and gradient into one pass, reusing intermediates. Gradient/primal ratio is 1.7x. Julia + Enzyme achieves 5.8x (whole-closure `Duplicated`) and comes close at 4.6x with fine-grained `Const`/`Duplicated` annotations. ### Why broadcasted row-dots are slow @@ -109,8 +109,8 @@ Stan's `normal_id_glm_lpdf` has a hand-written adjoint that fuses primal and gra |---|---|---| | Empty model | 0 μs | 0 | | Parameter management + transforms + priors | 1.0 μs | 18 | -| + manual likelihood (`@addlogprob!`) | 2.6 μs | 20 | -| + loop with 604 `~` tilde statements | 10 μs | 20 | +| + manual likelihood (`@addlogprob!`) | 6.7 μs | 24 | +| + loop with 604 `~` tilde statements | 13.5 μs | 20 | DynamicPPL v0.40 is already type-stable (`@code_warntype` shows concrete types). The overhead is inherent to its generality: parameter unpacking, bijector transforms, accumulator bookkeeping. diff --git a/scripts/Benchmarking/run_benchmark.jl b/scripts/Benchmarking/run_benchmark.jl index d6af714..8ab7f5a 100644 --- a/scripts/Benchmarking/run_benchmark.jl +++ b/scripts/Benchmarking/run_benchmark.jl @@ -132,6 +132,35 @@ let mode_name = "Enzyme split rev" end end +# Enzyme split forward +let mode_name = "Enzyme split fwd" + Kc = dimension(jp7) + seeds = [zeros(Kc) for _ in 1:Kc] + for i in 1:Kc; seeds[i][i] = 1.0; end + dmus = [zeros(length(jp7._mu)) for _ in 1:Kc] + try + result = Enzyme.autodiff( + Enzyme.Forward, + Enzyme.Const(jp7._logdensity_split), + Enzyme.BatchDuplicated(jp7._mu, ntuple(i -> dmus[i], Kc)), + Enzyme.BatchDuplicated(copy(q_test), ntuple(i -> seeds[i], Kc)), + ) + grad = collect(values(result[1])) + maxdiff = maximum(abs.(grad .- ref_grad)) + reldiff = maxdiff / max(maximum(abs.(ref_grad)), 1.0) + if reldiff > 1e-6 + msg = @sprintf("max|Δ|=%.2e, rel=%.2e", maxdiff, reldiff) + @printf(" %-40s WRONG (%s)\n", "gradient ($mode_name)", msg) + push!(errors, (label="gradient ($mode_name)", error=msg)) + else + print_result(" gradient ($mode_name)", _benchmark_enzyme_split(jp7, :gradient; enzyme_mode=Enzyme.Forward)) + end + catch e + @printf(" %-40s FAILED\n", "gradient ($mode_name)") + push!(errors, (label="gradient ($mode_name)", error=sprint(showerror, e, catch_backtrace()))) + end +end + # Also test Mooncake on julia7 for comparison for (ad, ad_name) in [(AutoMooncake(), "Mooncake rev")] err = try_benchmark(" gradient ($ad_name)", jp7, ad, ref_grad, q_test)