From 60fcb09ef138aa4c192be63bb9f839f41accbea7 Mon Sep 17 00:00:00 2001 From: odunbar Date: Wed, 15 Oct 2025 14:21:03 -0700 Subject: [PATCH 01/32] remove annoying *~ files --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index 83b96794c..60388f1eb 100644 --- a/.gitignore +++ b/.gitignore @@ -15,4 +15,5 @@ docs/site/ *.vscode* *.DS_Store *.jld2 +*~ output* From 6a6e4d79210084ee677a3178beddabbf6154ff54 Mon Sep 17 00:00:00 2001 From: odunbar Date: Wed, 5 Nov 2025 20:40:41 -0800 Subject: [PATCH 02/32] added functionality for linear maps and tsvd decorrelations etc - first drafting --- Project.toml | 11 +- src/MarkovChainMonteCarlo.jl | 26 +++- src/Utilities.jl | 182 ++++++++++++++++++++++++++-- src/Utilities/decorrelator.jl | 100 ++++++++++----- src/Utilities/elementwise_scaler.jl | 5 +- 5 files changed, 273 insertions(+), 51 deletions(-) diff --git a/Project.toml b/Project.toml index 2812a22b1..dcb82c9b7 100644 --- a/Project.toml +++ b/Project.toml @@ -1,7 +1,7 @@ name = "CalibrateEmulateSample" uuid = "95e48a1f-0bec-4818-9538-3db4340308e3" -authors = ["CLIMA contributors "] version = "0.7.0" +authors = ["CLIMA contributors "] [deps] AbstractGPs = "99985d1d-32ba-4be9-9821-2ec096f28918" @@ -16,6 +16,8 @@ ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" GaussianProcesses = "891a1506-143c-57d2-908e-e1f8e92e6de9" KernelFunctions = "ec8451be-7e33-11e9-00cf-bbf324bd1392" LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +LinearMaps = "7a12625a-238d-50fd-b39a-03d52299707e" +LowRankApprox = "898213cb-b102-5a47-900c-97e73b919f73" MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" Printf = "de0858da-6303-5e67-8744-51eddeeeb8d7" @@ -28,6 +30,7 @@ ScikitLearn = "3646fa90-6ef7-5e7e-9f22-8aca16db6324" StableRNGs = "860ef19b-820b-49d6-a774-d7a799459cd3" Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" StatsBase = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +TSVD = "9449cd9e-2762-5aa3-a617-5413e99d722e" [compat] AbstractGPs = "0.5.21" @@ -41,7 +44,10 @@ EnsembleKalmanProcesses = "2" ForwardDiff = "1" GaussianProcesses = "0.12" KernelFunctions = "0.10.64" -MCMCChains = "7" +LinearMaps = "3.11.4" +LowRankApprox = "0.5.5" +MCMCChains = "4.14, 5, 6, 7" +Plots = "1.41.1" Printf = "1" ProgressBars = "1" PyCall = "1.93" @@ -52,6 +58,7 @@ ScikitLearn = "0.6, 0.7" StableRNGs = "1" Statistics = "1" StatsBase = "0.33, 0.34" +TSVD = "0.4.4" julia = "1.6, 1.7, 1.8, 1.9, 1.10, 1.11" [extras] diff --git a/src/MarkovChainMonteCarlo.jl b/src/MarkovChainMonteCarlo.jl index 31d374040..30e76d784 100644 --- a/src/MarkovChainMonteCarlo.jl +++ b/src/MarkovChainMonteCarlo.jl @@ -548,8 +548,8 @@ function MCMCWrapper( mcmc_alg::MCMCProtocol, observation::AMorAV, prior::ParameterDistribution, - em::Emulator; - init_params::AV, + em::Emulator, + init_params::AV; burnin::Int = 0, kwargs..., ) where {AV <: AbstractVector, AMorAV <: Union{AbstractVector, AbstractMatrix}} @@ -587,6 +587,28 @@ function MCMCWrapper( return MCMCWrapper(prior, obs_slice, encoded_obs, log_posterior_map, mh_proposal_sampler, sample_kwargs) end +function MCMCWrapper( + mcmc_alg::MCMCProtocol, + observation::OB, + prior::PD, + em::EM, + init_params::AV; + kwargs..., +) where {AV <: AbstractVector, OB <: Observation, PD <: ParameterDistribution, EM <: Emulator} + return MCMCWrapper(mcmc_alg, get_obs(observation), prior, em, init_params; kwargs) +end + +function MCMCWrapper( + mcmc_alg::MCMCProtocol, + observation_series::OS, + prior::PD, + em::EM, + init_params::AV; + kwargs..., +) where {AV <: AbstractVector, OS <: ObservationSeries, PD <: ParameterDistribution, EM <: Emulator} + observations = [get_obs(ob) for ob in get_observations(observation_series)] + return MCMCWrapper(mcmc_alg, observations, prior, em, init_params; kwargs) +end """ $(DocStringExtensions.FUNCTIONNAME)([rng,] mcmc::MCMCWrapper, args...; kwargs...) diff --git a/src/Utilities.jl b/src/Utilities.jl index 298926c93..d649dbd20 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -1,14 +1,14 @@ module Utilities - - using DocStringExtensions using LinearAlgebra +using LinearMaps using Statistics using StatsBase using Random using ..EnsembleKalmanProcesses -EnsembleKalmanProcess = EnsembleKalmanProcesses.EnsembleKalmanProcess +const EKP = EnsembleKalmanProcesses +using EnsembleKalmanProcesses.ParameterDistributions using ..DataContainers export get_training_points @@ -24,7 +24,7 @@ export create_encoder_schedule, decode_structure_matrix -const StructureMatrix = Union{UniformScaling, AbstractMatrix} +const StructureMatrix = Union{UniformScaling, AbstractMatrix, AbstractVector} # The vector appears due to possible block-structured matrices (build=false) const StructureVector = Union{AbstractVector, AbstractMatrix} # In case of a matrix, the columns should be seen as vectors """ @@ -38,7 +38,7 @@ Extract the training points needed to train the Gaussian process regression. """ function get_training_points( - ekp::EnsembleKalmanProcess{FT, IT, P}, + ekp::EKP.EnsembleKalmanProcess{FT, IT, P}, train_iterations::Union{IT, AbstractVector{IT}}, ) where {FT, IT, P} @@ -63,6 +63,162 @@ function get_training_points( return training_points end +# Using Observation Objects: + +function encoder_kwargs_from(obs::OB) where {OB <: Observation} + return (obs_noise_cov = get_covs(obs, build=false), observation = get_obs(obs)) +end + +function encoder_kwargs_from(os::OS) where {OS <: ObservationSeries} + obs_vec = get_observations(os) + return [encoder_kwargs_from(obs) for obs in obs_vec] +end + +function encoder_kwargs_from(prior::PD; rng=Random.default_rng(), n_samples = 100) where {PD <: ParameterDistribution} + return (prior_cov = cov(prior), prior_samples_in = sample(rng, prior, n_samples)) +end + +## multiplication with observation covariance objects without building +""" +$(TYPEDSIGNATURES) + +Left-multiply `X` by structure matrix `A` without building it (if provided in a compact form). + +This is useful when A is high dimensional and provided as an `SVD` or `SumOfCovariances` etc. object from EnsembleKalmanProcesses. +""" +function lmul_compact(A, X::AVorM) where {AVorM <: AbstractVecOrMat} + # A is presumed a vector, of (compact) matrix types. + return isa(A, AbstractVector) ? EKP.lmul_without_build(A,X) : EKP.lmul_without_build([A],X) +end + +""" +$(TYPEDSIGNATURES) + +Produces a linear map of type `LinearMap` that can evaluates the stacked actions of the structure matrix in compact form. by calling say `linear_map.f(x)` or `linear_map.fc(x)` to obtain `Ax`, or `A'x`. This particular type can be used by packages like `TSVD.jl` or `IterativeSolvers.jl` for further computations. + +This compact map constructs the following form of the Linear map f: + +1. get compact form svd-plus-d form "USVt + D" of the `blocks` +2. create the f via stacking `A.U * A.S * A.Vt * x[block] + A.D * x[block] for (A,block) in blocks` + +kwargs: +------ +When computing the svd internally from an abstract matrix +- `svd_dim_max=4000`: this switches to an approximate tsvd approach when applying to covariance matrices above dimension 4000 +- `tsvd_rank=50`: when using tsvd, what rank to truncate at. + +""" +function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank=50) + Avec = isa(A, AbstractVector) ? A : [A] + + # explicitly write the loop here: + Us = [] + Ss = [] + VTs = [] + ds = [] + batches=[] + shift = 0 + for a in Avec + if isa(a, AbstractMatrix) + if size(a,1) <= svd_dim_max + svda = svd(a) + diaga = zeros(size(a,1)) + bsize = size(a,1) + else + svda = EKP.tsvd_mat(a, min(tsvd_rank, size(a,1)-1)) # swap to tsvd for performance + diaga = zeros(size(a,1)) + bsize = size(a,1) + end + elseif isa(a, SVD) + svda = a + diaga = zeros(size(a.U,1)) + bsize = size(a.U,1) + elseif isa(a, SVDplusD) + svda = a.svd_cov + diaga = (a.diag_cov).diag + bsize = length(diaga) + end + push!(Us, svda.U) + push!(Ss, svda.S) + push!(VTs, svda.Vt) + push!(ds, diaga) + + batch = shift+1:shift+bsize + push!(batches, batch) + shift = batch[end] + end + + # then create the LinearMap with entries f(x) = A*x, f(x) = A'*x, size(A,1), size(A,2) + # LinearMaps can only be applied to vectors in general, so we only provide this argumentation + + Amap = LinearMap( + x -> reduce(vcat, [U * (S .* (Vt * x[batch])) + d .* x[batch] for (U,S,Vt,d, batch) in zip(Us,Ss,VTs,ds,batches)]), + x -> reduce(vcat, [Vt' * (S .* (U' * x[batch])) + d .* x[batch] for (U,S,Vt,d, batch) in zip(Us,Ss,VTs,ds,batches)]), + sum(size(U, 1) for U in Us), + sum(size(Vt, 2) for Vt in VTs), + ) + + return Amap + +end + + +#= +""" +$(TYPEDSIGNATURES) + +svd of a sum of two matrices `A` and `B` in svd form without building A+B directly. + +This is useful when A and B are low rank, but high dimensional and provided as SVD types. (e.g. from `EKP.tsvd_cov_from_samples`) +""" +function svd_of_sum(svdA::SS1,svdB::SS2) where { SS1 <: SVD, SS2 <: SVD} + + # treat A + B as just "low rank" + # can write A+B = L * R = [Ua Ub] * [ Sa * Va'; Sb * Vb'] + L = [svdA.U svdB.U] # N x (r1+r2) + R = [Diagonal(svdA.S) * svdA.Vt ; Diagonal(svdB.S) * svdB.Vt] # (r1+r2) x N + qrl = qr(L) # Q1 R1 + qrr = qr(R') # Q2 R2 + # A+B = Q_1 * R_1 * R_2' * Q_2' = Q1 * (ss.U * ss.S * ss.V' * Q2' = (Q1 ss.U) * ss.S * (Q2 ss.V)' + ss = svd(qrl.R*qrr.R') + + return SVD(qrl.Q*ss.U, ss.S, ss.Vt*qrr.Q') # build the new svd + +end + +function inv_sqrt_of_svdplusd(a) + D = a.diag_cov + D += sqrt(eps())*I # minimum tolerance for some operations below + iD = inv(D) # + irD = sqrt.(iD) + ss = a.svd_cov + U = ss.U + S = Diagonal(ss.S) + + # begin computing the whitening transform + M = inv(S) + U'*iD*U + riM = sqrt(inv(M)) + B = irD*U + C = riM*B'*B*riM + ev = eigen(C) + V = ev.vectors + # if A = B*riM => + # (I-AA')^{1/2} = I - A * Chat * A' + # = I - A * V * Diag(chat) * V' * A' + # LHS evals sqrt(1-σ_i^2), rhs evals 1 - chat * σ_i^2 + # => chat = (1 - sqrt(1-σ_i^2))/(σ_i^2) # where σ_i is eval of A = sqrt(ev.values) + ev_correction = Diagonal((1.0 .-sqrt.(1.0 .- ev.values)) ./ ev.values) + + # Then, (I - BM^{-1}B')^{1/2} = I - B M^{-1/2} V sv V' M^{-1/2} B' + rt_ImBiMB = I - B * riM * V * ev_correction * V' * riM * B' + # Idea is that woodbury: Σ^{-1} = D^{-1/2} * ImBiMB * D^{-1/2} + # Then W = rt_ImBiMB * D^{-1/2} satisfies W Σ W' = I + W = rt_ImBiMB * irD # perhaps keep this in a compact form until use: + return W +end +=# + + # Data processing tooling: @@ -342,9 +498,9 @@ Takes in an already initialized encoder schedule, and encodes a structure matrix """ function encode_with_schedule( encoder_schedule::VV, - structure_matrix::USorM, + structure_matrix::SM, in_or_out::AS, -) where {VV <: AbstractVector, USorM <: Union{UniformScaling, AbstractMatrix}, AS <: AbstractString} +) where {VV <: AbstractVector, SM <: StructureMatrix, AS <: AbstractString} if in_or_out ∉ ["in", "out"] bad_in_or_out(in_or_out) end @@ -368,12 +524,12 @@ Takes in an already initialized encoder schedule, and decodes a `DataContainer`, function decode_with_schedule( encoder_schedule::VV, io_pairs::PDC, - input_structure_mat::USorM1, - output_structure_mat::USorM2, + input_structure_mat::SM1, + output_structure_mat::SM2, ) where { VV <: AbstractVector, - USorM1 <: Union{UniformScaling, AbstractMatrix}, - USorM2 <: Union{UniformScaling, AbstractMatrix}, + SM1 <: StructureMatrix, + SM2 <: StructureMatrix, PDC <: PairedDataContainer, } processed_io_pairs = deepcopy(io_pairs) @@ -433,9 +589,9 @@ Takes in an already initialized encoder schedule, and decodes a structure matrix """ function decode_with_schedule( encoder_schedule::VV, - structure_matrix::USorM, + structure_matrix::SM, in_or_out::AS, -) where {VV <: AbstractVector, USorM <: Union{UniformScaling, AbstractMatrix}, AS <: AbstractString} +) where {VV <: AbstractVector, SM <: StructureMatrix, AS <: AbstractString} if in_or_out ∉ ["in", "out"] bad_in_or_out(in_or_out) end diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index 9f237a827..f2d1b727c 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -123,36 +123,32 @@ Computes and populates the `data_mean` and `encoder_mat` and `decoder_mat` field function initialize_processor!( dd::Decorrelator, data::MM, - structure_matrices::Dict{Symbol, <:StructureMatrix}, - ::Dict{Symbol, <:StructureVector}, -) where {MM <: AbstractMatrix} + structure_matrices::Dict{Symbol, SM}, + ::Dict{Symbol, SV}, +) where {MM <: AbstractMatrix, SM <: StructureMatrix, SV <: StructureVector} if length(get_data_mean(dd)) == 0 push!(get_data_mean(dd), vec(mean(data, dims = 2))) end if length(get_encoder_mat(dd)) == 0 - # Can do tsvd here for large matrices + # To unify the actions here, we use LinearMaps.jl + # Note: can only multiply Linear Maps with vectors, not matrices... decorrelate_with = get_decorrelate_with(dd) if decorrelate_with == "structure_mat" - structure_matrix = get_structure_mat(structure_matrices, dd.structure_mat_name) - if isa(structure_matrix, UniformScaling) - data_dim = size(data, 1) - svdA = svd(structure_matrix(data_dim)) - rk = data_dim - else - svdA = svd(structure_matrix) - rk = rank(structure_matrix) - end + decorrelation_action = get_structure_mat(structure_matrices, dd.structure_mat_name) + decorrelation_map = create_compact_linear_map(decorrelation_action) + elseif decorrelate_with == "sample_cov" - cd = cov(data, dims = 2) - svdA = svd(cd) - rk = rank(cd) + decorrelation_action = tsvd_cov_from_samples(cd) + decorrelation_map = create_compact_linear_map(decorrelation_action) + elseif decorrelate_with == "combined" - structure_matrix = get_structure_mat(structure_matrices, dd.structure_mat_name) - spluscd = structure_matrix + cov(data, dims = 2) - svdA = svd(spluscd) - rk = rank(spluscd) + decorrelation_action1 = get_structure_mat(structure_matrices, dd.structure_mat_name) + decorrelation_action2 = tsvd_cov_from_samples(data) + map1 = create_compact_linear_map(decorrelation_action1) + map2 = create_compact_linear_map(decorrelation_action2) + decorrelation_map = map1+map2 # x -> dm.maps[1].f(x) + dm.maps[2].f(x) else throw( ArgumentError( @@ -160,24 +156,64 @@ function initialize_processor!( ), ) end + ret_var = get_retain_var(dd) + U=[] + S=[] + Vt=[] if ret_var < 1.0 - sv_cumsum = cumsum(svdA.S) / sum(svdA.S) # variance contributions are (sing_val) for these matrices - trunc_val = minimum(findall(x -> (x > ret_var), sv_cumsum)) - @info " truncating at $(trunc_val)/$(length(sv_cumsum)) retaining $(100.0*sv_cumsum[trunc_val])% of the variance of the structure matrix" + # TODO make n_est_frobenius, rk_max_tol, rtol in psvd, parameters + + # approximate Frobenius norm of the map + n_est_frobenius = 200 # bootstrap to get approx errors. + norm_approx = zeros(10) + for i = 1:10 + samples = randn(size(decorrelation_map,1), n_est_frobenius) + norm_approx[i] = 1/n_est_frobenius * sum([sum(abs2, (decorrelation_map * x)) for x in eachcol(samples)]) + end + @info "relative error of total variance $(std(norm_approx)/mean(norm_approx))" + retain_var_max = 1 - std(norm_approx) / mean(norm_approx) + + # Two methods of truncation: partial svd or truncated svd. + # psvd truncates to dimension where resulting SVD has a cerain error (NB sing values are different) + # tsvd truncates to dimension where resulting SVD has the same coeffs + rk_max_tol = 100 + ret_var_tmp = min(ret_var, retain_var_max) + + for rk in 1:rk_max_tol + Utmp,Stmp,Vtmp = tsvd(decorrelation_map, rk) + retain_var_current = sum(Stmp.^2) / (retain_var_max * mean(norm_approx)) + if retain_var_current > ret_var_tmp + push!(U,Utmp) + push!(S,Stmp) + push!(Vt,Vtmp') + @info " truncating at $(rk)/$(size(data,1)) retaining $(retain_var_current*100)% (+/-$(100*std(norm_approx)/mean(norm_approx)))% of the variance of the structure matrix" + break + end + if rk ==rk_max_tol + @warn "Maximum tolerance of SVD truncation hit ($(rk_max_tol)), consider increasing `rk_max_tol` in decorrelator, this may also result from `retain_var` being close to 1, while `N_est_frobenius` is low. Proceeding with final iterant." + push!(U,Utmp) + push!(S,Stmp) + push!(Vt,Vtmp') + + end + + end else - trunc_val = rk - if rk < size(data, 1) + # check V or Vt + Utmp,Stmp,Vtmp = psvd(decorrelation_map, rtol=1e-3) # randomized algorithm to avoid building the matrix, but this will be big. + + if length(s) < size(data, 1) @info " truncating at $(trunc_val)/$(size(data,1)), as low-rank data detected" end + push!(U,Utmp) + push!(S,Stmp) + push!(Vt,Vtmp') + end - - sqrt_inv_sv = Diagonal(1.0 ./ sqrt.(svdA.S[1:trunc_val])) - sqrt_sv = Diagonal(sqrt.(svdA.S[1:trunc_val])) - # as we have svd of cov-matrix we can use U or Vt - encoder_mat = sqrt_inv_sv * svdA.Vt[1:trunc_val, :] - decoder_mat = svdA.Vt[1:trunc_val, :]' * sqrt_sv - + encoder_mat = Diagonal(1.0 ./ sqrt.(S[1])) * Vt[1] + decoder_mat = Vt[1]' * Diagonal(sqrt.(S[1])) + push!(get_encoder_mat(dd), encoder_mat) push!(get_decoder_mat(dd), decoder_mat) end diff --git a/src/Utilities/elementwise_scaler.jl b/src/Utilities/elementwise_scaler.jl index 6cca8a9d2..53fa3e227 100644 --- a/src/Utilities/elementwise_scaler.jl +++ b/src/Utilities/elementwise_scaler.jl @@ -170,7 +170,7 @@ $(TYPEDSIGNATURES) Apply the `ElementwiseScaler` encoder to a provided structure matrix """ function encode_structure_matrix(es::ElementwiseScaler, structure_matrix::SM) where {SM <: StructureMatrix} - return Diagonal(1 ./ get_scale(es)) * structure_matrix * Diagonal(1 ./ get_scale(es)) + return Diagonal(1 ./ get_scale(es)) * lmul_compact(structure_matrix, Diagonal(1 ./ get_scale(es))) end """ @@ -179,5 +179,6 @@ $(TYPEDSIGNATURES) Apply the `ElementwiseScaler` decoder to a provided structure matrix """ function decode_structure_matrix(es::ElementwiseScaler, enc_structure_matrix::SM) where {SM <: StructureMatrix} - return Diagonal(get_scale(es)) * enc_structure_matrix * Diagonal(get_scale(es)) + return Diagonal(get_scale(es))* lmul_compact(enc_structure_matrix, Diagonal(get_scale(es))) end + From 07b8032e7f606e1350b2b28aa7202d3d95f51e91 Mon Sep 17 00:00:00 2001 From: odunbar Date: Thu, 6 Nov 2025 15:14:31 -0800 Subject: [PATCH 03/32] initialize all encoder/decoder mats and structure matrices as linear maps --- src/Utilities.jl | 14 +++- src/Utilities/decorrelator.jl | 118 +++++++++++++++++++++------- src/Utilities/elementwise_scaler.jl | 60 +++++++++++--- 3 files changed, 147 insertions(+), 45 deletions(-) diff --git a/src/Utilities.jl b/src/Utilities.jl index d649dbd20..3fb9c9576 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -24,7 +24,7 @@ export create_encoder_schedule, decode_structure_matrix -const StructureMatrix = Union{UniformScaling, AbstractMatrix, AbstractVector} # The vector appears due to possible block-structured matrices (build=false) +const StructureMatrix = Union{UniformScaling, AbstractMatrix, AbstractVector, LinearMap} # The vector appears due to possible block-structured matrices (build=false) const StructureVector = Union{AbstractVector, AbstractMatrix} # In case of a matrix, the columns should be seen as vectors """ @@ -353,7 +353,6 @@ This function creates the encoder scheduler that is also machine readable. E.g., enc_schedule = [ (DataProcessor1(...), "in"), (DataProcessor2(...), "out"), - (DataProcessor2(...), "out"), (PairedDataProcessor3(...),"in"), (DataProcessor4(...), "in"), (DataProcessor4(...), "out"), @@ -406,16 +405,23 @@ function initialize_and_encode_with_schedule!( ) where {VV <: AbstractVector, PDC <: PairedDataContainer} processed_io_pairs = deepcopy(io_pairs) + # We additionally convert to `mats` into a linear-maps for flexible handling of massive covariances. In a matrix-free manner input_structure_mats = deepcopy(input_structure_mats) if !isnothing(prior_cov) (input_structure_mats[:prior_cov] = prior_cov) end - + for (key,val) in input_structure_mats + input_structure_mats[key] = create_compact_linear_map(mat) + end + output_structure_mats = deepcopy(output_structure_mats) if !isnothing(obs_noise_cov) (output_structure_mats[:obs_noise_cov] = obs_noise_cov) end - + for (key,val) in output_structure_mats + output_structure_mats[key] = create_compact_linear_map(mat) + end + input_structure_vecs = deepcopy(input_structure_vecs) if !isnothing(prior_samples_in) (input_structure_vecs[:prior_samples_in] = prior_samples_in) diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index f2d1b727c..80990205e 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -25,7 +25,7 @@ The SVD is taken to be the sum of structure matrix and estimated covariance. Thi # Fields $(TYPEDFIELDS) """ -struct Decorrelator{VV1, VV2, VV3, FT, AS <: AbstractString} <: DataContainerProcessor +struct Decorrelator{VV1, VV2, VV3, FT, NT <: NamedTuple, AS <: AbstractString} <: DataContainerProcessor "storage for the data mean" data_mean::VV1 "the matrix used to perform encoding" @@ -34,6 +34,12 @@ struct Decorrelator{VV1, VV2, VV3, FT, AS <: AbstractString} <: DataContainerPro decoder_mat::VV3 "the fraction of variance to be retained after truncating singular values (1 implies no truncation)" retain_var::FT + "when retain_var < 1, number of samples to estimate the total variance. Larger values reduce the error in approximation at the cost of additional matrix-vector products." + n_totvar_samples::Int + "maximum dimension of subspace for `retain_var < 1`. The search may become expensive at large ranks, and therefore can be cut-off in this way" + max_rank::Int + "when `retain_var = 1`, the `psvd` algorithm from `LowRankApprox.jl` is used to decorrelate the space. here, kwargs can be passed in as a NamedTuple" + psvd_kwargs::NT "Switch to choose what form of matrix to use to decorrelate the data" decorrelate_with::AS "When given, use the structure matrix by this name if `decorrelate_with` uses structure matrices. When `nothing`, try to use the only present structure matrix instead." @@ -50,8 +56,15 @@ Constructs the `Decorrelator` struct. Users can add optional keyword arguments: - `"sample_cov"`, see [`decorrelate_sample_cov`](@ref) - `"combined"`, sums the `"sample_cov"` and `"structure_mat"` matrices """ -decorrelate(; retain_var::FT = Float64(1.0), decorrelate_with = "combined", structure_mat_name = nothing) where {FT} = - Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), decorrelate_with, structure_mat_name) +decorrelate(; + retain_var::FT = Float64(1.0), + decorrelate_with = "combined", + structure_mat_name = nothing, + n_totvar_samples::Int=100, + max_rank::Int=100, + psvd_kwargs=(;rtol=1e-3), + ) where {FT} = + Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), n_totvar_samples, max_rank, psvd_kwargs, decorrelate_with, structure_mat_name) """ $(TYPEDSIGNATURES) @@ -59,8 +72,13 @@ $(TYPEDSIGNATURES) Constructs the `Decorrelator` struct, setting decorrelate_with = "sample_cov". Encoding data with this will ensure that the distribution of data samples after encoding will be `Normal(0,I)`. One can additionally add keywords: - `retain_var`[=`1.0`]: to project onto the leading singular vectors such that `retain_var` variance is retained """ -decorrelate_sample_cov(; retain_var::FT = Float64(1.0)) where {FT} = - Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), "sample_cov", nothing) +decorrelate_sample_cov(; + retain_var::FT = Float64(1.0), + n_totvar_samples::Int=100, + max_rank::Int=100, + psvd_kwargs=(;rtol=1e-3), + ) where {FT} = + Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), n_totvar_samples, max_rank, psvd_kwargs, "sample_cov", nothing) """ $(TYPEDSIGNATURES) @@ -68,8 +86,14 @@ $(TYPEDSIGNATURES) Constructs the `Decorrelator` struct, setting decorrelate_with = "structure_mat". This encoding will transform a provided structure matrix into `I`. One can additionally add keywords: - `retain_var`[=`1.0`]: to project onto the leading singular vectors such that `retain_var` variance is retained """ -decorrelate_structure_mat(; retain_var::FT = Float64(1.0), structure_mat_name = nothing) where {FT} = - Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), "structure_mat", structure_mat_name) +decorrelate_structure_mat(; + retain_var::FT = Float64(1.0), + structure_mat_name = nothing, + n_totvar_samples::Int=100, + max_rank::Int=100, + psvd_kwargs=(; rtol=1e-3), + ) where {FT} = + Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), n_totvar_samples, max_rank, psvd_kwargs, "structure_mat", structure_mat_name) """ $(TYPEDSIGNATURES) @@ -102,6 +126,27 @@ get_retain_var(dd::Decorrelator) = dd.retain_var """ $(TYPEDSIGNATURES) +returns the `n_totvar_samples` field of the `Decorrelator`. +""" +get_n_totvar_samples(dd::Decorrelator) = dd.n_totvar_samples + +""" +$(TYPEDSIGNATURES) + +returns the `max_rank` field of the `Decorrelator`. +""" +get_max_rank(dd::Decorrelator) = dd.max_rank + +""" +$(TYPEDSIGNATURES) + +returns the `psvd_kwargs` field of the `Decorrelator`. +""" +get_psvd_kwargs(dd::Decorrelator) = dd.psvd_kwargs + +""" +$(TYPEDSIGNATURES) + returns the `decorrelate_with` field of the `Decorrelator`. """ get_decorrelate_with(dd::Decorrelator) = dd.decorrelate_with @@ -136,17 +181,15 @@ function initialize_processor!( # Note: can only multiply Linear Maps with vectors, not matrices... decorrelate_with = get_decorrelate_with(dd) if decorrelate_with == "structure_mat" - decorrelation_action = get_structure_mat(structure_matrices, dd.structure_mat_name) - decorrelation_map = create_compact_linear_map(decorrelation_action) + decorrelation_map = get_structure_mat(structure_matrices, dd.structure_mat_name) elseif decorrelate_with == "sample_cov" - decorrelation_action = tsvd_cov_from_samples(cd) + decorrelation_action = tsvd_cov_from_samples(data) decorrelation_map = create_compact_linear_map(decorrelation_action) elseif decorrelate_with == "combined" - decorrelation_action1 = get_structure_mat(structure_matrices, dd.structure_mat_name) + map1 = get_structure_mat(structure_matrices, dd.structure_mat_name) decorrelation_action2 = tsvd_cov_from_samples(data) - map1 = create_compact_linear_map(decorrelation_action1) map2 = create_compact_linear_map(decorrelation_action2) decorrelation_map = map1+map2 # x -> dm.maps[1].f(x) + dm.maps[2].f(x) else @@ -157,19 +200,19 @@ function initialize_processor!( ) end + n_totvar_samples = get_n_totvar_samples(dd) + max_rank = get_max_rank(dd) + psvd_kwargs = get_psvd_kwargs(dd) ret_var = get_retain_var(dd) U=[] S=[] Vt=[] if ret_var < 1.0 - # TODO make n_est_frobenius, rk_max_tol, rtol in psvd, parameters - # approximate Frobenius norm of the map - n_est_frobenius = 200 # bootstrap to get approx errors. norm_approx = zeros(10) for i = 1:10 - samples = randn(size(decorrelation_map,1), n_est_frobenius) - norm_approx[i] = 1/n_est_frobenius * sum([sum(abs2, (decorrelation_map * x)) for x in eachcol(samples)]) + samples = randn(size(decorrelation_map,1), n_totvar_samples) + norm_approx[i] = 1/n_totvar_samples * sum([sum(abs2, (decorrelation_map * x)) for x in eachcol(samples)]) end @info "relative error of total variance $(std(norm_approx)/mean(norm_approx))" retain_var_max = 1 - std(norm_approx) / mean(norm_approx) @@ -177,10 +220,9 @@ function initialize_processor!( # Two methods of truncation: partial svd or truncated svd. # psvd truncates to dimension where resulting SVD has a cerain error (NB sing values are different) # tsvd truncates to dimension where resulting SVD has the same coeffs - rk_max_tol = 100 ret_var_tmp = min(ret_var, retain_var_max) - for rk in 1:rk_max_tol + for rk in 1:max_rank Utmp,Stmp,Vtmp = tsvd(decorrelation_map, rk) retain_var_current = sum(Stmp.^2) / (retain_var_max * mean(norm_approx)) if retain_var_current > ret_var_tmp @@ -191,7 +233,7 @@ function initialize_processor!( break end if rk ==rk_max_tol - @warn "Maximum tolerance of SVD truncation hit ($(rk_max_tol)), consider increasing `rk_max_tol` in decorrelator, this may also result from `retain_var` being close to 1, while `N_est_frobenius` is low. Proceeding with final iterant." + @warn "Maximum tolerance of SVD truncation hit ($(rk_max_tol)), consider increasing `rk_max_tol` in decorrelator, this may also result from `retain_var` being close to 1, while `n_totvar_samples` is low. Proceeding with final iterant." push!(U,Utmp) push!(S,Stmp) push!(Vt,Vtmp') @@ -201,7 +243,7 @@ function initialize_processor!( end else # check V or Vt - Utmp,Stmp,Vtmp = psvd(decorrelation_map, rtol=1e-3) # randomized algorithm to avoid building the matrix, but this will be big. + Utmp,Stmp,Vtmp = psvd(decorrelation_map, psvd_kwargs...) # randomized algorithm to avoid building the matrix, but this will be big. if length(s) < size(data, 1) @info " truncating at $(trunc_val)/$(size(data,1)), as low-rank data detected" @@ -211,11 +253,25 @@ function initialize_processor!( push!(Vt,Vtmp') end - encoder_mat = Diagonal(1.0 ./ sqrt.(S[1])) * Vt[1] - decoder_mat = Vt[1]' * Diagonal(sqrt.(S[1])) - push!(get_encoder_mat(dd), encoder_mat) - push!(get_decoder_mat(dd), decoder_mat) + + # we explicitly make the encoder/decoder maps + encoder_map = LinearMap( + x -> Diagonal(1.0 ./ sqrt.(S[1])) * Vt[1] * x # Ax + x -> Vt[1]' * Diagonal(1.0 ./ sqrt.(S[1])) * x # A'x + size(Vt[1], 1), # size(A,1) + size(Vt[1], 2), # size(A,2) + ) + + decoder_map = LinearMap( + x -> Vt[1]' * Diagonal(sqrt.(S[1])) * x # Ax + x -> Diagonal(sqrt.(S[1])) * Vt[1] * x # A'x + size(Vt[1]', 1), # size(A,1) + size(Vt[1]', 2), # size(A,2) + ) + + push!(get_encoder_mat(dd), encoder_map) + push!(get_decoder_mat(dd), decoder_map) end end @@ -228,7 +284,9 @@ Apply the `Decorrelator` encoder, on a columns-are-data matrix function encode_data(dd::Decorrelator, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(dd)[1] encoder_mat = get_encoder_mat(dd)[1] - return encoder_mat * (data .- data_mean) + out = deepcopy(data) + mul!(out, encoder_mat, out .- data_mean) + return out end """ @@ -239,13 +297,15 @@ Apply the `Decorrelator` decoder, on a columns-are-data matrix function decode_data(dd::Decorrelator, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(dd)[1] decoder_mat = get_decoder_mat(dd)[1] - return decoder_mat * data .+ data_mean + out = deepcopy(data) + mul!(out, decoder_mat, out) + return out .+ data_mean end """ $(TYPEDSIGNATURES) -Apply the `Decorrelator` encoder to a provided structure matrix +Apply the `Decorrelator` encoder to a provided structure matrix. If the structure matrix is a LinearMap, then the encoded structure matrix remains a LinearMap. """ function encode_structure_matrix(dd::Decorrelator, structure_matrix::SM) where {SM <: StructureMatrix} encoder_mat = get_encoder_mat(dd)[1] @@ -255,7 +315,7 @@ end """ $(TYPEDSIGNATURES) -Apply the `Decorrelator` decoder to a provided structure matrix +Apply the `Decorrelator` decoder to a provided structure matrix. If the structure matrix is a LinearMap, then the encoded structure matrix remains a LinearMap. """ function decode_structure_matrix(dd::Decorrelator, enc_structure_matrix::SM) where {SM <: StructureMatrix} decoder_mat = get_decoder_mat(dd)[1] diff --git a/src/Utilities/elementwise_scaler.jl b/src/Utilities/elementwise_scaler.jl index 53fa3e227..74e891a12 100644 --- a/src/Utilities/elementwise_scaler.jl +++ b/src/Utilities/elementwise_scaler.jl @@ -21,6 +21,10 @@ struct ElementwiseScaler{T, VV <: AbstractVector} <: DataContainerProcessor shift::VV "storage for the scaling" scale::VV + "the matrix used to perform encoding" + encoder_mat::VV2 + "the inverse of the the matrix used to perform encoding" + decoder_mat::VV3 end abstract type UnivariateAffineScaling end @@ -78,11 +82,26 @@ Gets the `scale` field of the `ElementwiseScaler` """ get_scale(es::ElementwiseScaler) = es.scale +""" +$(TYPEDSIGNATURES) + +returns the `encoder_mat` field of the `ElementwiseScalar`. +""" +get_encoder_mat(es::ElementwiseScalar) = es.encoder_mat + +""" +$(TYPEDSIGNATURES) + +returns the `decoder_mat` field of the `ElementwiseScalar`. +""" +get_decoder_mat(es::ElementwiseScalar) = es.decoder_mat + function Base.show(io::IO, es::ElementwiseScaler) out = "ElementwiseScaler: $(get_type(es))" print(io, out) end + function initialize_processor!( es::ElementwiseScaler, data::MM, @@ -90,8 +109,12 @@ function initialize_processor!( ) where {MM <: AbstractMatrix, QS <: QuartileScaling} quartiles_vec = [quantile(dd, [0.25, 0.5, 0.75]) for dd in eachrow(data)] quartiles_mat = reduce(hcat, quartiles_vec) # 3 rows: Q1, Q2, and Q3 + + # we use these more for saving readable data append!(get_shift(es), quartiles_mat[2, :]) append!(get_scale(es), (quartiles_mat[3, :] - quartiles_mat[1, :])) + + _create_encoder_decoder!(es,data) end function initialize_processor!( @@ -120,6 +143,23 @@ function initialize_processor!(es::ElementwiseScaler, data::MM) where {MM <: Abs if length(get_shift(es)) == 0 T = get_type(es) initialize_processor!(es, data, T) + + # we explicitly make the encoder/decoder maps + encoder_map = LinearMap( + x -> (x .- get_shift(es)) ./ get_scale(es), # Ax + x -> (x .- get_shift(es)) ./ get_scale(es), # A'x + size(data, 1), # size(A,1) + size(data, 1), # size(A,2) + ) + decoder_map = LinearMap( + x -> x .* get_scale(es) .+ get_shift(es), # Ax + x -> x .* get_scale(es) .+ get_shift(es), # A'x + size(data, 1), # size(A,1) + size(data, 1), # size(A,2) + ) + + push!(get_encoder_mat(es), encoder_map) + push!(get_decoder_mat(es), decoder_map) end end @@ -130,10 +170,8 @@ Apply the `ElementwiseScaler` encoder, on a columns-are-data matrix """ function encode_data(es::ElementwiseScaler, data::MM) where {MM <: AbstractMatrix} out = deepcopy(data) - for i in 1:size(out, 1) - out[i, :] .-= get_shift(es)[i] - out[i, :] /= get_scale(es)[i] - end + enc = get_encoder_mat(es) + mul!(out, enc, out) # must use this form to get matrix output of enc*out return out end @@ -144,10 +182,8 @@ Apply the `ElementwiseScaler` decoder, on a columns-are-data matrix """ function decode_data(es::ElementwiseScaler, data::MM) where {MM <: AbstractMatrix} out = deepcopy(data) - for i in 1:size(out, 1) - out[i, :] *= get_scale(es)[i] - out[i, :] .+= get_shift(es)[i] - end + dec = get_decoder_mat(es) + mul!(out, dec, out) # must use this form to get matrix output of dec*out return out end @@ -167,18 +203,18 @@ initialize_processor!( """ $(TYPEDSIGNATURES) -Apply the `ElementwiseScaler` encoder to a provided structure matrix +Apply the `ElementwiseScaler` encoder to a provided structure matrix. If the structure matrix is a LinearMap, then the encoded structure matrix remains a LinearMap. """ function encode_structure_matrix(es::ElementwiseScaler, structure_matrix::SM) where {SM <: StructureMatrix} - return Diagonal(1 ./ get_scale(es)) * lmul_compact(structure_matrix, Diagonal(1 ./ get_scale(es))) + return Diagonal(1 ./ get_scale(es)) * structure_matrix * Diagonal(1 ./ get_scale(es)) end """ $(TYPEDSIGNATURES) -Apply the `ElementwiseScaler` decoder to a provided structure matrix +Apply the `ElementwiseScaler` decoder to a provided structure matrix. If the structure matrix is a LinearMap, then the encoded structure matrix remains a LinearMap. """ function decode_structure_matrix(es::ElementwiseScaler, enc_structure_matrix::SM) where {SM <: StructureMatrix} - return Diagonal(get_scale(es))* lmul_compact(enc_structure_matrix, Diagonal(get_scale(es))) + return Diagonal(get_scale(es)) * enc_structure_matrix * Diagonal(get_scale(es)) end From e68d6e483326b1da7da3a31c3e3bdafe90d73589 Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 7 Nov 2025 14:14:00 -0800 Subject: [PATCH 04/32] safeguard against "I" covariance matrices, and fix typos so tests run --- src/Emulator.jl | 8 ++--- src/Utilities.jl | 54 +++++++++++++++++++++-------- src/Utilities/decorrelator.jl | 14 ++++---- src/Utilities/elementwise_scaler.jl | 10 +++--- 4 files changed, 55 insertions(+), 31 deletions(-) diff --git a/src/Emulator.jl b/src/Emulator.jl index b796ef508..684dcf8e3 100644 --- a/src/Emulator.jl +++ b/src/Emulator.jl @@ -195,9 +195,9 @@ Encode a new structure matrix in the input space (`"in"`) or output space (`"out """ function encode_structure_matrix( emulator::Emulator, - structure_mat::USorM, + structure_mat, in_or_out::AS, -) where {AS <: AbstractString, USorM <: Union{UniformScaling, AbstractMatrix}} +) where {AS <: AbstractString} return encode_with_schedule(get_encoder_schedule(emulator), structure_mat, in_or_out) end @@ -226,9 +226,9 @@ Decode a new structure matrix in the input space (`"in"`) or output space (`"out """ function decode_structure_matrix( emulator::Emulator, - structure_mat::USorM, + structure_mat, in_or_out::AS, -) where {AS <: AbstractString, USorM <: Union{UniformScaling, AbstractMatrix}} +) where {AS <: AbstractString} return decode_with_schedule(get_encoder_schedule(emulator), structure_mat, in_or_out) end diff --git a/src/Utilities.jl b/src/Utilities.jl index 3fb9c9576..1383c45aa 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -10,6 +10,7 @@ using ..EnsembleKalmanProcesses const EKP = EnsembleKalmanProcesses using EnsembleKalmanProcesses.ParameterDistributions using ..DataContainers +using LowRankApprox export get_training_points @@ -119,36 +120,49 @@ function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank=50) batches=[] shift = 0 for a in Avec + bsize=[0] + if isa(a, UniformScaling) + throw(ArgumentError("Detected `UniformScaling` (i.e. \"λI\") StructureMatrix, and unable to infer dimensionality. \n Please recast this as a diagonal matrix, defining \"λI(d)\" for dimension d")) + end if isa(a, AbstractMatrix) if size(a,1) <= svd_dim_max svda = svd(a) - diaga = zeros(size(a,1)) - bsize = size(a,1) + push!(Us, svda.U) + push!(Ss, svda.S) + push!(VTs, svda.Vt) + push!(ds, zeros(size(a,1))) + bsize[1] = size(a,1) else svda = EKP.tsvd_mat(a, min(tsvd_rank, size(a,1)-1)) # swap to tsvd for performance - diaga = zeros(size(a,1)) - bsize = size(a,1) + push!(Us, svda.U) + push!(Ss, svda.S) + push!(VTs, svda.Vt) + push!(ds, zeros(size(a,1))) + bsize[1] = size(a,1) end elseif isa(a, SVD) svda = a - diaga = zeros(size(a.U,1)) - bsize = size(a.U,1) + push!(Us, svda.U) + push!(Ss, svda.S) + push!(VTs, svda.Vt) + push!(ds, zeros(size(a.U,1))) + bsize[1] = size(a.U,1) elseif isa(a, SVDplusD) svda = a.svd_cov diaga = (a.diag_cov).diag - bsize = length(diaga) + push!(Us, svda.U) + push!(Ss, svda.S) + push!(VTs, svda.Vt) + push!(ds, diaga) + bsize[1] = length(diaga) end - push!(Us, svda.U) - push!(Ss, svda.S) - push!(VTs, svda.Vt) - push!(ds, diaga) - batch = shift+1:shift+bsize + batch = shift+1:shift+bsize[1] push!(batches, batch) shift = batch[end] end - # then create the LinearMap with entries f(x) = A*x, f(x) = A'*x, size(A,1), size(A,2) + # then create the LinearMap with entries (f(x) = A*x, f(x) = A'*x, size(A,1), size(A,2)) # LinearMaps can only be applied to vectors in general, so we only provide this argumentation Amap = LinearMap( @@ -411,7 +425,12 @@ function initialize_and_encode_with_schedule!( (input_structure_mats[:prior_cov] = prior_cov) end for (key,val) in input_structure_mats - input_structure_mats[key] = create_compact_linear_map(mat) + if isa(val, UniformScaling) # remove this annoying case immediately + input_dim = size(get_inputs(io_pairs),1) + input_structure_mats[key] = create_compact_linear_map(val(input_dim)) + else + input_structure_mats[key] = create_compact_linear_map(val) + end end output_structure_mats = deepcopy(output_structure_mats) @@ -419,7 +438,12 @@ function initialize_and_encode_with_schedule!( (output_structure_mats[:obs_noise_cov] = obs_noise_cov) end for (key,val) in output_structure_mats - output_structure_mats[key] = create_compact_linear_map(mat) + if isa(val, UniformScaling) # remove this annoying case immediately + output_dim = size(get_outputs(io_pairs),1) + output_structure_mats[key] = create_compact_linear_map(val(output_dim)) + else + output_structure_mats[key] = create_compact_linear_map(val) + end end input_structure_vecs = deepcopy(input_structure_vecs) diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index 80990205e..cd2309637 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -243,10 +243,10 @@ function initialize_processor!( end else # check V or Vt - Utmp,Stmp,Vtmp = psvd(decorrelation_map, psvd_kwargs...) # randomized algorithm to avoid building the matrix, but this will be big. + Utmp,Stmp,Vtmp = psvd(decorrelation_map; psvd_kwargs...) # randomized algorithm to avoid building the matrix, but this will be big. - if length(s) < size(data, 1) - @info " truncating at $(trunc_val)/$(size(data,1)), as low-rank data detected" + if length(Stmp) < size(data, 1) + @info " truncating at $(length(Stmp))/$(size(data,1)), as low-rank data detected" end push!(U,Utmp) push!(S,Stmp) @@ -257,15 +257,15 @@ function initialize_processor!( # we explicitly make the encoder/decoder maps encoder_map = LinearMap( - x -> Diagonal(1.0 ./ sqrt.(S[1])) * Vt[1] * x # Ax - x -> Vt[1]' * Diagonal(1.0 ./ sqrt.(S[1])) * x # A'x + x -> Diagonal(1.0 ./ sqrt.(S[1])) * Vt[1] * x, # Ax + x -> Vt[1]' * Diagonal(1.0 ./ sqrt.(S[1])) * x, # A'x size(Vt[1], 1), # size(A,1) size(Vt[1], 2), # size(A,2) ) decoder_map = LinearMap( - x -> Vt[1]' * Diagonal(sqrt.(S[1])) * x # Ax - x -> Diagonal(sqrt.(S[1])) * Vt[1] * x # A'x + x -> Vt[1]' * Diagonal(sqrt.(S[1])) * x, # Ax + x -> Diagonal(sqrt.(S[1])) * Vt[1] * x, # A'x size(Vt[1]', 1), # size(A,1) size(Vt[1]', 2), # size(A,2) ) diff --git a/src/Utilities/elementwise_scaler.jl b/src/Utilities/elementwise_scaler.jl index 74e891a12..dae5c6c82 100644 --- a/src/Utilities/elementwise_scaler.jl +++ b/src/Utilities/elementwise_scaler.jl @@ -16,7 +16,7 @@ Different methods `T` will build different transformations: and are accessed with [`get_type`](@ref) """ -struct ElementwiseScaler{T, VV <: AbstractVector} <: DataContainerProcessor +struct ElementwiseScaler{T, VV <: AbstractVector, VV2 <: AbstractVector, VV3 <: AbstractVector} <: DataContainerProcessor "storage for the shift applied to data" shift::VV "storage for the scaling" @@ -85,16 +85,16 @@ get_scale(es::ElementwiseScaler) = es.scale """ $(TYPEDSIGNATURES) -returns the `encoder_mat` field of the `ElementwiseScalar`. +returns the `encoder_mat` field of the `ElementwiseScaler`. """ -get_encoder_mat(es::ElementwiseScalar) = es.encoder_mat +get_encoder_mat(es::ElementwiseScaler) = es.encoder_mat """ $(TYPEDSIGNATURES) -returns the `decoder_mat` field of the `ElementwiseScalar`. +returns the `decoder_mat` field of the `ElementwiseScaler`. """ -get_decoder_mat(es::ElementwiseScalar) = es.decoder_mat +get_decoder_mat(es::ElementwiseScaler) = es.decoder_mat function Base.show(io::IO, es::ElementwiseScaler) out = "ElementwiseScaler: $(get_type(es))" From 4ef520a0083acae9560fcdfc7d6dbbd887ab7402 Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 7 Nov 2025 15:49:38 -0800 Subject: [PATCH 05/32] resizing bug --- src/Utilities/decorrelator.jl | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index cd2309637..487d7233e 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -60,7 +60,7 @@ decorrelate(; retain_var::FT = Float64(1.0), decorrelate_with = "combined", structure_mat_name = nothing, - n_totvar_samples::Int=100, + n_totvar_samples::Int=500, max_rank::Int=100, psvd_kwargs=(;rtol=1e-3), ) where {FT} = @@ -74,7 +74,7 @@ Constructs the `Decorrelator` struct, setting decorrelate_with = "sample_cov". E """ decorrelate_sample_cov(; retain_var::FT = Float64(1.0), - n_totvar_samples::Int=100, + n_totvar_samples::Int=500, max_rank::Int=100, psvd_kwargs=(;rtol=1e-3), ) where {FT} = @@ -89,7 +89,7 @@ Constructs the `Decorrelator` struct, setting decorrelate_with = "structure_mat" decorrelate_structure_mat(; retain_var::FT = Float64(1.0), structure_mat_name = nothing, - n_totvar_samples::Int=100, + n_totvar_samples::Int=500, max_rank::Int=100, psvd_kwargs=(; rtol=1e-3), ) where {FT} = @@ -232,8 +232,8 @@ function initialize_processor!( @info " truncating at $(rk)/$(size(data,1)) retaining $(retain_var_current*100)% (+/-$(100*std(norm_approx)/mean(norm_approx)))% of the variance of the structure matrix" break end - if rk ==rk_max_tol - @warn "Maximum tolerance of SVD truncation hit ($(rk_max_tol)), consider increasing `rk_max_tol` in decorrelator, this may also result from `retain_var` being close to 1, while `n_totvar_samples` is low. Proceeding with final iterant." + if rk == max_rank + @warn "Maximum tolerance of SVD truncation hit ($(rank_max)), consider increasing `rank_max` in decorrelator, this may also result from `retain_var` being close to 1, while `n_totvar_samples` is low. Proceeding with final iterant." push!(U,Utmp) push!(S,Stmp) push!(Vt,Vtmp') @@ -284,8 +284,8 @@ Apply the `Decorrelator` encoder, on a columns-are-data matrix function encode_data(dd::Decorrelator, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(dd)[1] encoder_mat = get_encoder_mat(dd)[1] - out = deepcopy(data) - mul!(out, encoder_mat, out .- data_mean) + out = zeros(size(encoder_mat,1), size(data,2)) + mul!(out, encoder_mat, deepcopy(data).- data_mean) return out end @@ -297,8 +297,8 @@ Apply the `Decorrelator` decoder, on a columns-are-data matrix function decode_data(dd::Decorrelator, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(dd)[1] decoder_mat = get_decoder_mat(dd)[1] - out = deepcopy(data) - mul!(out, decoder_mat, out) + out = zeros(size(decoder_mat,1), size(data,2)) + mul!(out, decoder_mat, deepcopy(data)) return out .+ data_mean end From a925fd4dbe05e0601c0d68974799fcff9cbc71c6 Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 7 Nov 2025 15:49:52 -0800 Subject: [PATCH 06/32] add TSVD --- src/Utilities.jl | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/Utilities.jl b/src/Utilities.jl index 1383c45aa..4e2e77489 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -10,7 +10,9 @@ using ..EnsembleKalmanProcesses const EKP = EnsembleKalmanProcesses using EnsembleKalmanProcesses.ParameterDistributions using ..DataContainers + using LowRankApprox +using TSVD export get_training_points From 0bc504d717d1130edd4c4c8b669611f85a5e2272 Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 7 Nov 2025 16:12:17 -0800 Subject: [PATCH 07/32] works for canonical correlation --- src/Utilities/canonical_correlation.jl | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/Utilities/canonical_correlation.jl b/src/Utilities/canonical_correlation.jl index c7ab6a47c..9ca6e5c9c 100644 --- a/src/Utilities/canonical_correlation.jl +++ b/src/Utilities/canonical_correlation.jl @@ -186,7 +186,9 @@ Apply the `CanonicalCorrelation` encoder, on a columns-are-data matrix function encode_data(cc::CanonicalCorrelation, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(cc)[1] encoder_mat = get_encoder_mat(cc)[1] - return encoder_mat * (data .- data_mean) + out = zeros(size(encoder_mat,1), size(data,2)) + mul!(out, encoder_mat, deepcopy(data).- data_mean) + return out end """ @@ -197,7 +199,9 @@ Apply the `CanonicalCorrelation` decoder, on a columns-are-data matrix function decode_data(cc::CanonicalCorrelation, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(cc)[1] decoder_mat = get_decoder_mat(cc)[1] - return decoder_mat * data .+ data_mean + out = zeros(size(decoder_mat,1), size(data,2)) + mul!(out, decoder_mat, deepcopy(data)) + return out .+ data_mean end """ From 76e479fd62c4b27d363558a29499f31b37e3e34a Mon Sep 17 00:00:00 2001 From: odunbar Date: Thu, 13 Nov 2025 16:45:59 -0800 Subject: [PATCH 08/32] added == for encoder-decoder schedule --- src/Utilities.jl | 124 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 119 insertions(+), 5 deletions(-) diff --git a/src/Utilities.jl b/src/Utilities.jl index 4e2e77489..0da4397d6 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -241,14 +241,128 @@ end abstract type DataProcessor end abstract type PairedDataContainerProcessor <: DataProcessor end # tools that operate on inputs and outputs abstract type DataContainerProcessor <: DataProcessor end # tools that operate on only inputs or outputs - # define how to have equality -Base.:(==)(a::DCP, b::DCP) where {DCP <: DataContainerProcessor} = - all(getfield(a, f) == getfield(b, f) for f in fieldnames(DCP)) -Base.:(==)(a::PDCP, b::PDCP) where {PDCP <: PairedDataContainerProcessor} = - all(getfield(a, f) == getfield(b, f) for f in fieldnames(PDCP)) +# this gets messy with LinearMaps, + +""" +$(TYPEDSIGNATURES) + +Tests equality for a LinearMap on a standard basis of the input space. Note that this operation requires a matrix multiply per input dimension so can be expensive. + +Kwargs: +------- +- n_eval (=nothing): the number of basis vectors to compare against (randomly selected without replacement if `n_eval < size(A,1)`) +- tol (=2*eps()): the tolerance for equality on evaluation per entry +- rng (=default_rng()): When provided, and `n_eval < size(A,1)`; a random subset of the basis is compared, using this `rng`. +- up_to_sign(=false): Only assess equality up to a sign-error (sufficient for e.g. encoder/decoder matrices) +""" +function isequal_linear(A::LM1, B::LM2; tol=2*eps(), n_eval=nothing, rng = Random.default_rng(), up_to_sign=false) where {LM1 <: LinearMap, LM2 <: LinearMap} + m, n = size(A) + if !(n == size(B, 2)) + return false + end + if !(m == size(B, 1)) + return false + end + + # test on standard basis (up to n_eval tests) + basis_id = isa(n_eval, Nothing) ? collect(1:n) : randperm(rng, n)[1:n_eval] + + e = vec(zeros(eltype(A), n)) + for j in basis_id + e[j] += 1 + if up_to_sign + AmB = abs.(A * e) - abs.(B * e) + else + AmB = A * e - B * e + end + @info AmB + if !(norm(AmB) <= n * tol) + return false + end + e[j] -= 1 + end + return true +end + +function isequal_linear(A::AMorV1, B::AMorV2; kwargs...) where {AMorV1 <: AbstractVecOrMat, AMorV2 <: AbstractVecOrMat} + if !(size(A) == size(B)) + return false + end + + return all(isequal_linear(a,b; kwargs...) for (a,b) in zip(A[:],B[:])) +end + +function Base.:(==)(a::LM1, b::LM2) where {LM1 <: LinearMap, LM2 <: LinearMap} + n=size(a,2) + if n < 1e4 # gets expensive + return isequal_linear(a,b; tol=1e-12) + else + return isequal_linear(a,b; n_eval=Int(floor(sqrt(n))), tol=1e-12) # 1e4 compares ~ 100 evals, 1e7 compares ~ 3000 evals + end +end + +function isequal_encoder_decoder(a::LM1, b::LM2) where {LM1 <: LinearMap, LM2 <: LinearMap} + n=size(a,2) + if n < 1e4 # gets expensive + return isequal_linear(a,b, up_to_sign=true, tol=1e-12) + else + return isequal_linear(a,b; n_eval=Int(floor(sqrt(n))), up_to_sign=true, tol=1e-12) # 1e4 compares ~ 100 evals, 1e7 compares ~ 3000 evals + end +end +function isequal_encoder_decoder(A::AMorV1, B::AMorV2; kwargs...) where {AMorV1 <: AbstractVecOrMat, AMorV2 <: AbstractVecOrMat} + if !(size(A) == size(B)) + return false + end + + return all(isequal_encoder_decoder(a,b) for (a,b) in zip(A[:],B[:])) +end + +function Base.:(==)(a::DCP1, b::DCP2) where {DCP1 <: DataContainerProcessor, DCP2 <: DataContainerProcessor} + out = BitVector(repeat([false],length(fieldnames(DCP1)))) + for (idx,f) in enumerate(fieldnames(DCP1)) + af = getfield(a,f) + bf = getfield(b,f) + if !(typeof(af) == typeof(bf)) + out[idx] = 0 + elseif isa(af, LinearMap) + out[idx] = isequal_encoder_decoder(af,bf) ? 1 : 0 + elseif isa(af, AbstractVecOrMat) + if isa(af[1], LinearMap) + out[idx] = isequal_encoder_decoder(af, bf) ? 1 : 0 + else + out[idx] = (af == bf) ? 1 : 0 + end + else + out[idx] = (af == bf) ? 1 : 0 + end + end + return all(out) +end + +function Base.:(==)(a::PDCP1, b::PDCP2) where {PDCP1 <: PairedDataContainerProcessor, PDCP2 <: PairedDataContainerProcessor} + out = BitVector(repeat([false],length(fieldnames(DCP1)))) + for (idx,f) in enumerate(fieldnames(PDCP1)) + af = getfield(a,f) + bf = getfield(b,f) + if !(typeof(af) == typeof(bf)) + out[idx] = 0 + elseif isa(af, LinearMap) + out[idx] = isequal_encoder_decoder(af,bf) ? 1 : 0 + elseif isa(af, AbstractVecOrMat) + if isa(af[1], LinearMap) + out[idx] = isequal_encoder_decoder(af, bf) ? 1 : 0 + else + out[idx] = (af == bf) ? 1 : 0 + end + else + out[idx] = (af == bf) ? 1 : 0 + end + end + return all(out) +end #### function get_structure_vec(structure_vecs, name = nothing) From 4380bf2190c022cb607e6ed99e3603c3ec1cbca5 Mon Sep 17 00:00:00 2001 From: odunbar Date: Thu, 13 Nov 2025 19:12:30 -0800 Subject: [PATCH 09/32] instilled sign convention for singular vectors in encode/decode --- src/Utilities.jl | 7 +++---- src/Utilities/decorrelator.jl | 10 ++++++++-- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/src/Utilities.jl b/src/Utilities.jl index 0da4397d6..edb9dcb95 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -15,7 +15,7 @@ using LowRankApprox using TSVD export get_training_points - +export create_compact_linear_map export PairedDataContainerProcessor, DataContainerProcessor export create_encoder_schedule, initialize_and_encode_with_schedule!, @@ -163,10 +163,10 @@ function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank=50) push!(batches, batch) shift = batch[end] end - + # then create the LinearMap with entries (f(x) = A*x, f(x) = A'*x, size(A,1), size(A,2)) # LinearMaps can only be applied to vectors in general, so we only provide this argumentation - + Amap = LinearMap( x -> reduce(vcat, [U * (S .* (Vt * x[batch])) + d .* x[batch] for (U,S,Vt,d, batch) in zip(Us,Ss,VTs,ds,batches)]), x -> reduce(vcat, [Vt' * (S .* (U' * x[batch])) + d .* x[batch] for (U,S,Vt,d, batch) in zip(Us,Ss,VTs,ds,batches)]), @@ -276,7 +276,6 @@ function isequal_linear(A::LM1, B::LM2; tol=2*eps(), n_eval=nothing, rng = Rando else AmB = A * e - B * e end - @info AmB if !(norm(AmB) <= n * tol) return false end diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index 487d7233e..8a0c392c5 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -253,8 +253,14 @@ function initialize_processor!( push!(Vt,Vtmp') end - - + + # Enforce a sign convention for the singular vectors (rows Vt have positive first entry) + for (j,row) in enumerate(eachrow(Vt[1])) + if row[1] < 0 + Vt[1][j,:] *= -1 + end + end + # we explicitly make the encoder/decoder maps encoder_map = LinearMap( x -> Diagonal(1.0 ./ sqrt.(S[1])) * Vt[1] * x, # Ax From bd53ef9c62606d41314ae3a2f5329d4b6b5f769d Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 14 Nov 2025 17:31:57 -0800 Subject: [PATCH 10/32] many more tests passing, updates to decode back into matrices on transform_to_real=true --- src/Emulator.jl | 4 +- src/GaussianProcess.jl | 7 +- src/ScalarRandomFeature.jl | 2 +- src/Utilities.jl | 79 +++++------------- src/Utilities/decorrelator.jl | 125 ++++++++++++++++++---------- src/Utilities/elementwise_scaler.jl | 79 +++++++++++++----- src/VectorRandomFeature.jl | 2 +- test/Emulator/runtests.jl | 19 ++--- test/RandomFeature/runtests.jl | 4 +- test/Utilities/runtests.jl | 87 +++++++++++++++++-- 10 files changed, 261 insertions(+), 147 deletions(-) diff --git a/src/Emulator.jl b/src/Emulator.jl index 684dcf8e3..af9c7e99a 100644 --- a/src/Emulator.jl +++ b/src/Emulator.jl @@ -281,11 +281,11 @@ function predict( decoded_covariances = zeros(eltype(encoded_outputs), output_dim, output_dim, size(encoded_uncertainties)[end]) if var_or_cov == "var" for (i, col) in enumerate(eachcol(encoded_uncertainties)) - decoded_covariances[:, :, i] .= decode_structure_matrix(emulator, Diagonal(col), "out") + decoded_covariances[:, :, i] .= Matrix(decode_structure_matrix(emulator, Diagonal(col), "out")) end else # == "cov" for (i, mat) in enumerate(eachslice(encoded_uncertainties, dims = 3)) - decoded_covariances[:, :, i] .= decode_structure_matrix(emulator, mat, "out") + decoded_covariances[:, :, i] .= Matrix(decode_structure_matrix(emulator, mat, "out")) end end diff --git a/src/GaussianProcess.jl b/src/GaussianProcess.jl index 7f267216f..0f2148885 100644 --- a/src/GaussianProcess.jl +++ b/src/GaussianProcess.jl @@ -194,7 +194,8 @@ function build_models!( regularization = if isempty(output_structure_mats) 1.0 * ones(N_models) else - output_structure_mat = get_structure_mat(output_structure_mats) + output_structure_mat = Matrix(get_structure_mat(output_structure_mats)) + # in small space one can convert to a matrix if isa(output_structure_mat, UniformScaling) output_structure_mat.λ * ones(N_models) else @@ -329,7 +330,7 @@ function build_models!( regularization = if isempty(output_structure_mats) 1.0 * ones(N_models) else - output_structure_mat = get_structure_mat(output_structure_mats) + output_structure_mat = Matrix(get_structure_mat(output_structure_mats)) if isa(output_structure_mat, UniformScaling) output_structure_mat.λ * ones(N_models) else @@ -435,7 +436,7 @@ AbstractGP currently does not (yet) learn hyperparameters internally. The follow regularization = if isempty(output_structure_mats) 1.0 * ones(N_models) else - output_structure_mat = get_structure_mat(output_structure_mats) + output_structure_mat = Matrix(get_structure_mat(output_structure_mats)) if isa(output_structure_mat, UniformScaling) output_structure_mat.λ * ones(N_models) else diff --git a/src/ScalarRandomFeature.jl b/src/ScalarRandomFeature.jl index 0599b09a0..2e2b3bfd7 100644 --- a/src/ScalarRandomFeature.jl +++ b/src/ScalarRandomFeature.jl @@ -404,7 +404,7 @@ function build_models!( regularization = if isempty(output_structure_mats) 1.0 * I(n_rfms) else - output_structure_mat = get_structure_mat(output_structure_mats) + output_structure_mat = Matrix(get_structure_mat(output_structure_mats)) if isa(output_structure_mat, UniformScaling) output_structure_mat else diff --git a/src/Utilities.jl b/src/Utilities.jl index edb9dcb95..613b40726 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -14,6 +14,8 @@ using ..DataContainers using LowRankApprox using TSVD +import LinearAlgebra: norm + export get_training_points export create_compact_linear_map export PairedDataContainerProcessor, DataContainerProcessor @@ -24,7 +26,8 @@ export create_encoder_schedule, encode_data, encode_structure_matrix, decode_data, - decode_structure_matrix + decode_structure_matrix, + norm const StructureMatrix = Union{UniformScaling, AbstractMatrix, AbstractVector, LinearMap} # The vector appears due to possible block-structured matrices (build=false) @@ -301,67 +304,29 @@ function Base.:(==)(a::LM1, b::LM2) where {LM1 <: LinearMap, LM2 <: LinearMap} end end -function isequal_encoder_decoder(a::LM1, b::LM2) where {LM1 <: LinearMap, LM2 <: LinearMap} - n=size(a,2) - if n < 1e4 # gets expensive - return isequal_linear(a,b, up_to_sign=true, tol=1e-12) - else - return isequal_linear(a,b; n_eval=Int(floor(sqrt(n))), up_to_sign=true, tol=1e-12) # 1e4 compares ~ 100 evals, 1e7 compares ~ 3000 evals - end -end +Base.:(==)(a::DCP1, b::DCP2) where {DCP1 <: DataContainerProcessor, DCP2 <: DataContainerProcessor} = + all(getfield(a,f) == getfield(b,f) for f in fieldnames(DCP1)) -function isequal_encoder_decoder(A::AMorV1, B::AMorV2; kwargs...) where {AMorV1 <: AbstractVecOrMat, AMorV2 <: AbstractVecOrMat} - if !(size(A) == size(B)) - return false - end - - return all(isequal_encoder_decoder(a,b) for (a,b) in zip(A[:],B[:])) -end +Base.:(==)(a::PDCP1, b::PDCP2) where {PDCP1 <: PairedDataContainerProcessor, PDCP2 <: PairedDataContainerProcessor} = + all(getfield(a,f) == getfield(b,f) for f in fieldnames(PDCP1)) -function Base.:(==)(a::DCP1, b::DCP2) where {DCP1 <: DataContainerProcessor, DCP2 <: DataContainerProcessor} - out = BitVector(repeat([false],length(fieldnames(DCP1)))) - for (idx,f) in enumerate(fieldnames(DCP1)) - af = getfield(a,f) - bf = getfield(b,f) - if !(typeof(af) == typeof(bf)) - out[idx] = 0 - elseif isa(af, LinearMap) - out[idx] = isequal_encoder_decoder(af,bf) ? 1 : 0 - elseif isa(af, AbstractVecOrMat) - if isa(af[1], LinearMap) - out[idx] = isequal_encoder_decoder(af, bf) ? 1 : 0 - else - out[idx] = (af == bf) ? 1 : 0 - end - else - out[idx] = (af == bf) ? 1 : 0 - end - end +function norm_linear_map(A::LM, p::Real=2; n_eval=nothing) where {LM <: LinearMap} + m, n = size(A) + # test on standard basis (up to n_eval tests) + basis_id = isa(n_eval, Nothing) ? collect(1:n) : randperm(rng, n)[1:n_eval] - return all(out) -end - -function Base.:(==)(a::PDCP1, b::PDCP2) where {PDCP1 <: PairedDataContainerProcessor, PDCP2 <: PairedDataContainerProcessor} - out = BitVector(repeat([false],length(fieldnames(DCP1)))) - for (idx,f) in enumerate(fieldnames(PDCP1)) - af = getfield(a,f) - bf = getfield(b,f) - if !(typeof(af) == typeof(bf)) - out[idx] = 0 - elseif isa(af, LinearMap) - out[idx] = isequal_encoder_decoder(af,bf) ? 1 : 0 - elseif isa(af, AbstractVecOrMat) - if isa(af[1], LinearMap) - out[idx] = isequal_encoder_decoder(af, bf) ? 1 : 0 - else - out[idx] = (af == bf) ? 1 : 0 - end - else - out[idx] = (af == bf) ? 1 : 0 - end + e = vec(zeros(eltype(A), n)) + norm_val = [0.0] + for j in basis_id + e[j] += 1 + norm_val[1] += 1.0 / n * norm(A * e, p) + e[j] -= 1 end - return all(out) + return norm_val[1] end + +LinearAlgebra.norm(A::LM, p::Real = 2; lm_kwargs...) where {LM <: LinearMap} = norm_linear_map(A, p; lm_kwargs...) + #### function get_structure_vec(structure_vecs, name = nothing) diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index 8a0c392c5..299c6b954 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -1,7 +1,7 @@ # included in Utilities.jl export Decorrelator, decorrelate_sample_cov, decorrelate_structure_mat, decorrelate -export get_data_mean, get_encoder_mat, get_decoder_mat, get_retain_var, get_decorrelate_with +export get_data_mean, get_encoder_mat, get_decoder_mat, get_retain_var, get_decorrelate_with, get_n_totvar_samples, get_max_rank, get_psvd_kwargs """ $(TYPEDEF) @@ -22,6 +22,17 @@ The SVD is taken over the estimated covariance of the data. The data samples wil For `decorrelate(;decorrelate_with="combined")` (default): The SVD is taken to be the sum of structure matrix and estimated covariance. This may be more robust to ill-specification of structure matrix, or poor estimation of the sample covariance. +Depending on the size of the matrix, we perform different options of SVD: + +Small Matrix (dim < 3000): + use LinearAlgebra.svd(Matrix) +Large Matrix (dim > 3000): + if retain_var = 1.0 + use LowRankApprox.psvd(LinearMap; psvd_kwargs...) + if retain_var < 1.0 + use TSVD.tsvd(LinearMap) + + # Fields $(TYPEDFIELDS) """ @@ -62,7 +73,7 @@ decorrelate(; structure_mat_name = nothing, n_totvar_samples::Int=500, max_rank::Int=100, - psvd_kwargs=(;rtol=1e-3), + psvd_kwargs=(;rtol=1e-5), ) where {FT} = Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), n_totvar_samples, max_rank, psvd_kwargs, decorrelate_with, structure_mat_name) @@ -76,7 +87,7 @@ decorrelate_sample_cov(; retain_var::FT = Float64(1.0), n_totvar_samples::Int=500, max_rank::Int=100, - psvd_kwargs=(;rtol=1e-3), + psvd_kwargs=(;rtol=1e-5), ) where {FT} = Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), n_totvar_samples, max_rank, psvd_kwargs, "sample_cov", nothing) @@ -204,63 +215,89 @@ function initialize_processor!( max_rank = get_max_rank(dd) psvd_kwargs = get_psvd_kwargs(dd) ret_var = get_retain_var(dd) - U=[] + S=[] - Vt=[] - if ret_var < 1.0 - # approximate Frobenius norm of the map - norm_approx = zeros(10) - for i = 1:10 - samples = randn(size(decorrelation_map,1), n_totvar_samples) - norm_approx[i] = 1/n_totvar_samples * sum([sum(abs2, (decorrelation_map * x)) for x in eachcol(samples)]) + Vt=[] + + # Three methods of performing: svd, partial svd or truncated svd. + # svd: convert to matrix and perform actual SVD. [good for small matrix (d < ~3000)] + # psvd: approximates SVD to a given error tolerance (can truncate too) [good for full svd approx] + # tsvd: truncates to dimension where resulting SVD has the same s.vals as the true [good of low rank approx] + max_svd_size = 3000 + if max(size(decorrelation_map)...) < max_svd_size + # svd options + svdA = svd(Matrix(decorrelation_map)) + rk = rank(Matrix(decorrelation_map)) + + ret_var = get_retain_var(dd) + if ret_var < 1.0 + sv_cumsum = cumsum(svdA.S) / sum(svdA.S) # variance contributions are (sing_val) for these matrices + trunc_val = minimum(findall(x -> (x > ret_var), sv_cumsum)) + @info " truncating at $(trunc_val)/$(length(sv_cumsum)) retaining $(100.0*sv_cumsum[trunc_val])% of the variance of the structure matrix" + else + trunc_val = rk + if rk < size(data, 1) + @info " truncating at $(trunc_val)/$(size(data,1)), as low-rank data detected" + end end - @info "relative error of total variance $(std(norm_approx)/mean(norm_approx))" - retain_var_max = 1 - std(norm_approx) / mean(norm_approx) - # Two methods of truncation: partial svd or truncated svd. - # psvd truncates to dimension where resulting SVD has a cerain error (NB sing values are different) - # tsvd truncates to dimension where resulting SVD has the same coeffs - ret_var_tmp = min(ret_var, retain_var_max) + push!(S, svdA.S[1:trunc_val]) + push!(Vt, svdA.Vt[1:trunc_val,:]) - for rk in 1:max_rank - Utmp,Stmp,Vtmp = tsvd(decorrelation_map, rk) - retain_var_current = sum(Stmp.^2) / (retain_var_max * mean(norm_approx)) - if retain_var_current > ret_var_tmp - push!(U,Utmp) - push!(S,Stmp) - push!(Vt,Vtmp') - @info " truncating at $(rk)/$(size(data,1)) retaining $(retain_var_current*100)% (+/-$(100*std(norm_approx)/mean(norm_approx)))% of the variance of the structure matrix" + else + if ret_var < 1.0 + # tsvd option + # approximate Frobenius norm of the map + norm_approx = zeros(10) + for i = 1:10 + samples = randn(size(decorrelation_map,1), n_totvar_samples) + norm_approx[i] = 1/n_totvar_samples * sum([sum(abs2, (decorrelation_map * x)) for x in eachcol(samples)]) + end + @info "relative error of total variance $(std(norm_approx)/mean(norm_approx))" + retain_var_max = 1 - std(norm_approx) / mean(norm_approx) + + ret_var_tmp = min(ret_var, retain_var_max) + + for rk in 1:max_rank + _,Stmp,Vtmp = tsvd(decorrelation_map, rk) + retain_var_current = sum(Stmp.^2) / (retain_var_max * mean(norm_approx)) + if retain_var_current > ret_var_tmp + push!(S,Stmp) + push!(Vt,Vtmp') + @info " truncating at $(rk)/$(size(data,1)) retaining $(retain_var_current*100)% (+/-$(100*std(norm_approx)/mean(norm_approx)))% of the variance of the structure matrix" break + end + if rk == max_rank + @warn "Maximum tolerance of SVD truncation hit ($(rank_max)), consider increasing `rank_max` in decorrelator, this may also result from `retain_var` being close to 1, while `n_totvar_samples` is low. Proceeding with final iterant." + push!(S,Stmp) + push!(Vt,Vtmp') + + end + end - if rk == max_rank - @warn "Maximum tolerance of SVD truncation hit ($(rank_max)), consider increasing `rank_max` in decorrelator, this may also result from `retain_var` being close to 1, while `n_totvar_samples` is low. Proceeding with final iterant." - push!(U,Utmp) - push!(S,Stmp) - push!(Vt,Vtmp') - + else + # psvd option + # check V or Vt + _,Stmp,Vtmp = psvd(decorrelation_map; psvd_kwargs...) # randomized algorithm to avoid building the matrix, but this will be big. + + if length(Stmp) < size(data, 1) + @info " truncating at $(length(Stmp))/$(size(data,1)), as low-rank data detected" end - - end - else - # check V or Vt - Utmp,Stmp,Vtmp = psvd(decorrelation_map; psvd_kwargs...) # randomized algorithm to avoid building the matrix, but this will be big. - - if length(Stmp) < size(data, 1) - @info " truncating at $(length(Stmp))/$(size(data,1)), as low-rank data detected" + push!(S,Stmp) + push!(Vt,Vtmp') + end - push!(U,Utmp) - push!(S,Stmp) - push!(Vt,Vtmp') - end + + # Enforce a sign convention for the singular vectors (rows Vt have positive first entry) for (j,row) in enumerate(eachrow(Vt[1])) if row[1] < 0 Vt[1][j,:] *= -1 end end - + # we explicitly make the encoder/decoder maps encoder_map = LinearMap( x -> Diagonal(1.0 ./ sqrt.(S[1])) * Vt[1] * x, # Ax diff --git a/src/Utilities/elementwise_scaler.jl b/src/Utilities/elementwise_scaler.jl index dae5c6c82..7ad44d710 100644 --- a/src/Utilities/elementwise_scaler.jl +++ b/src/Utilities/elementwise_scaler.jl @@ -2,7 +2,7 @@ export UnivariateAffineScaling, ElementwiseScaler, QuartileScaling, MinMaxScaling, ZScoreScaling export quartile_scale, minmax_scale, zscore_scale -export get_type, get_shift, get_scale +export get_type, get_shift, get_scale, get_data_encoder_mat, get_data_decoder_mat, get_struct_encoder_mat, get_struct_decoder_mat """ $(TYPEDEF) @@ -16,15 +16,19 @@ Different methods `T` will build different transformations: and are accessed with [`get_type`](@ref) """ -struct ElementwiseScaler{T, VV <: AbstractVector, VV2 <: AbstractVector, VV3 <: AbstractVector} <: DataContainerProcessor +struct ElementwiseScaler{T, VV <: AbstractVector, VV2 <: AbstractVector, VV3 <: AbstractVector, VV4 <: AbstractVector, VV5 <: AbstractVector} <: DataContainerProcessor "storage for the shift applied to data" shift::VV "storage for the scaling" scale::VV - "the matrix used to perform encoding" - encoder_mat::VV2 - "the inverse of the the matrix used to perform encoding" - decoder_mat::VV3 + "the matrix used to perform encoding of data samples" + data_encoder_mat::VV2 + "the inverse of the the matrix used to perform encoding of data samples" + data_decoder_mat::VV3 + "the matrix used to perform encoding of structure_matrices" + struct_encoder_mat::VV4 + "the inverse of the the matrix used to perform encoding of structure_matrices" + struct_decoder_mat::VV5 end abstract type UnivariateAffineScaling end @@ -59,7 +63,7 @@ For multivariate standardization, see [`Decorrelator`](@ref) zscore_scale() = ElementwiseScaler(ZScoreScaling) ElementwiseScaler(::Type{UAS}) where {UAS <: UnivariateAffineScaling} = - ElementwiseScaler{UAS, Vector{Float64}}(Float64[], Float64[]) + ElementwiseScaler{UAS, Vector{Float64}, Vector, Vector, Vector, Vector}(Float64[], Float64[], [], [], [], []) """ $(TYPEDSIGNATURES) @@ -85,16 +89,30 @@ get_scale(es::ElementwiseScaler) = es.scale """ $(TYPEDSIGNATURES) -returns the `encoder_mat` field of the `ElementwiseScaler`. +returns the `data_encoder_mat` field of the `ElementwiseScaler`. """ -get_encoder_mat(es::ElementwiseScaler) = es.encoder_mat +get_data_encoder_mat(es::ElementwiseScaler) = es.data_encoder_mat """ $(TYPEDSIGNATURES) -returns the `decoder_mat` field of the `ElementwiseScaler`. +returns the `data_decoder_mat` field of the `ElementwiseScaler`. """ -get_decoder_mat(es::ElementwiseScaler) = es.decoder_mat +get_data_decoder_mat(es::ElementwiseScaler) = es.data_decoder_mat + +""" +$(TYPEDSIGNATURES) + +returns the `struct_encoder_mat` field of the `ElementwiseScaler`. +""" +get_struct_encoder_mat(es::ElementwiseScaler) = es.struct_encoder_mat + +""" +$(TYPEDSIGNATURES) + +returns the `struct_decoder_mat` field of the `ElementwiseScaler`. +""" +get_struct_decoder_mat(es::ElementwiseScaler) = es.struct_decoder_mat function Base.show(io::IO, es::ElementwiseScaler) out = "ElementwiseScaler: $(get_type(es))" @@ -113,8 +131,6 @@ function initialize_processor!( # we use these more for saving readable data append!(get_shift(es), quartiles_mat[2, :]) append!(get_scale(es), (quartiles_mat[3, :] - quartiles_mat[1, :])) - - _create_encoder_decoder!(es,data) end function initialize_processor!( @@ -145,21 +161,36 @@ function initialize_processor!(es::ElementwiseScaler, data::MM) where {MM <: Abs initialize_processor!(es, data, T) # we explicitly make the encoder/decoder maps - encoder_map = LinearMap( + data_encoder_map = LinearMap( x -> (x .- get_shift(es)) ./ get_scale(es), # Ax x -> (x .- get_shift(es)) ./ get_scale(es), # A'x size(data, 1), # size(A,1) size(data, 1), # size(A,2) ) - decoder_map = LinearMap( + data_decoder_map = LinearMap( x -> x .* get_scale(es) .+ get_shift(es), # Ax x -> x .* get_scale(es) .+ get_shift(es), # A'x size(data, 1), # size(A,1) size(data, 1), # size(A,2) ) - - push!(get_encoder_mat(es), encoder_map) - push!(get_decoder_mat(es), decoder_map) + # the encoder for the structure matrix does not have a shift + struct_encoder_map = LinearMap( + x -> x ./ get_scale(es), # Ax + x -> x ./ get_scale(es), # A'x + size(data, 1), # size(A,1) + size(data, 1), # size(A,2) + ) + struct_decoder_map = LinearMap( + x -> x .* get_scale(es), # Ax + x -> x .* get_scale(es), # A'x + size(data, 1), # size(A,1) + size(data, 1), # size(A,2) + ) + push!(get_data_encoder_mat(es), data_encoder_map) + push!(get_data_decoder_mat(es), data_decoder_map) + push!(get_struct_encoder_mat(es), struct_encoder_map) + push!(get_struct_decoder_mat(es), struct_decoder_map) + end end @@ -170,7 +201,7 @@ Apply the `ElementwiseScaler` encoder, on a columns-are-data matrix """ function encode_data(es::ElementwiseScaler, data::MM) where {MM <: AbstractMatrix} out = deepcopy(data) - enc = get_encoder_mat(es) + enc = get_data_encoder_mat(es)[1] mul!(out, enc, out) # must use this form to get matrix output of enc*out return out end @@ -182,7 +213,7 @@ Apply the `ElementwiseScaler` decoder, on a columns-are-data matrix """ function decode_data(es::ElementwiseScaler, data::MM) where {MM <: AbstractMatrix} out = deepcopy(data) - dec = get_decoder_mat(es) + dec = get_data_decoder_mat(es)[1] mul!(out, dec, out) # must use this form to get matrix output of dec*out return out end @@ -206,7 +237,9 @@ $(TYPEDSIGNATURES) Apply the `ElementwiseScaler` encoder to a provided structure matrix. If the structure matrix is a LinearMap, then the encoded structure matrix remains a LinearMap. """ function encode_structure_matrix(es::ElementwiseScaler, structure_matrix::SM) where {SM <: StructureMatrix} - return Diagonal(1 ./ get_scale(es)) * structure_matrix * Diagonal(1 ./ get_scale(es)) + encoder_mat = get_struct_encoder_mat(es)[1] + return encoder_mat * structure_matrix * encoder_mat' + #return Diagonal(1 ./ get_scale(es)) * structure_matrix * Diagonal(1 ./ get_scale(es)) end """ @@ -215,6 +248,8 @@ $(TYPEDSIGNATURES) Apply the `ElementwiseScaler` decoder to a provided structure matrix. If the structure matrix is a LinearMap, then the encoded structure matrix remains a LinearMap. """ function decode_structure_matrix(es::ElementwiseScaler, enc_structure_matrix::SM) where {SM <: StructureMatrix} - return Diagonal(get_scale(es)) * enc_structure_matrix * Diagonal(get_scale(es)) + decoder_mat = get_struct_decoder_mat(es)[1] + return decoder_mat * enc_structure_matrix * decoder_mat' +# return Diagonal(get_scale(es)) * enc_structure_matrix * Diagonal(get_scale(es)) end diff --git a/src/VectorRandomFeature.jl b/src/VectorRandomFeature.jl index 6d5d4f5a8..05eeccb2f 100644 --- a/src/VectorRandomFeature.jl +++ b/src/VectorRandomFeature.jl @@ -461,7 +461,7 @@ function build_models!( regularization = if isempty(output_structure_mats) 1.0 * I else - output_structure_mat = get_structure_mat(output_structure_mats) + output_structure_mat = Matrix(get_structure_mat(output_structure_mats)) if !isposdef(output_structure_mat) println("RF output structure matrix is not positive definite, correcting for use as a regularizer") posdef_correct(output_structure_mat) diff --git a/test/Emulator/runtests.jl b/test/Emulator/runtests.jl index 5eec9a6c0..0211dc4d2 100644 --- a/test/Emulator/runtests.jl +++ b/test/Emulator/runtests.jl @@ -10,7 +10,7 @@ using LinearAlgebra using CalibrateEmulateSample.Emulators using CalibrateEmulateSample.DataContainers using CalibrateEmulateSample.Utilities - +using CalibrateEmulateSample.EnsembleKalmanProcesses #build an unknown type struct MLTester <: Emulators.MachineLearningTool end @@ -24,7 +24,7 @@ struct MLTester <: Emulators.MachineLearningTool end # "noise" μ = zeros(d) - Σ = rand(d, d) + Σ = rand(d,d) Σ = Σ' * Σ noise_samples = rand(MvNormal(μ, Σ), m) y += noise_samples @@ -45,12 +45,11 @@ struct MLTester <: Emulators.MachineLearningTool end default_encoder = (decorrelate_sample_cov(), "in_and_out") # for these inputs this is the default enc_sch = create_encoder_schedule(default_encoder) enc_io_pairs, enc_I_in, enc_I_out = initialize_and_encode_with_schedule!(enc_sch, io_pairs; obs_noise_cov = 1.0 * I) - @test get_encoder_schedule(em)[1][1] == enc_sch[1][1] # inputs: proc - @test get_encoder_schedule(em)[1][2] == enc_sch[1][2] # inputs: apply_to - @test get_encoder_schedule(em)[2][1] == enc_sch[2][1] # outputs... - @test get_encoder_schedule(em)[2][2] == enc_sch[2][2] - @test get_data(get_encoded_io_pairs(em)) == get_data(enc_io_pairs) - @test get_data(get_encoded_io_pairs(em)) == get_data(enc_io_pairs) + # NB this gives encoder up to sign + tol = 1e-12 + @test get_encoder_schedule(em) == enc_sch # inputs: proc + @test all(isapprox.(get_inputs(get_encoded_io_pairs(em)), get_inputs(enc_io_pairs), atol=tol)) + @test all(isapprox.(get_outputs(get_encoded_io_pairs(em)), get_outputs(enc_io_pairs), atol=tol)) @test isempty(enc_I_in) #NB - encoders all tested in Utilities here just testing some API @@ -70,8 +69,8 @@ struct MLTester <: Emulators.MachineLearningTool end @test isapprox(norm(decoded_I - 1.0 * I), 0, atol = tol * d * d) # test obs_noise_cov (check the warning at the start) - @test_logs (:warn,) (:info,) (:info,) (:warn,) Emulator(gp, io_pairs, obs_noise_cov = Σ) - @test_logs (:warn,) (:info,) (:info,) (:warn,) Emulator( + @test_logs (:warn,) (:info,) (:warn,) (:info,) (:warn,) Emulator(gp, io_pairs, obs_noise_cov = Σ) + @test_logs (:warn,) (:info,) (:warn,) (:info,) (:warn,) Emulator( gp, io_pairs; encoder_kwargs = (; prior_cov = 4.0 * I, obs_noise_cov = 2.0 * I), diff --git a/test/RandomFeature/runtests.jl b/test/RandomFeature/runtests.jl index 3778e8c25..52863fcaf 100644 --- a/test/RandomFeature/runtests.jl +++ b/test/RandomFeature/runtests.jl @@ -340,14 +340,14 @@ rng = Random.MersenneTwister(seed) @test_throws ArgumentError Emulator(srfi_bad, iopairs) # test under repeats - @test_logs (:info,) (:info,) (:warn,) Emulator( + @test_logs (:info,) (:warn,) (:info,) (:warn,) Emulator( srfi, iopairs; encoder_kwargs = (; obs_noise_cov = obs_noise_cov), ) Emulator(srfi, iopairs; encoder_kwargs = (; obs_noise_cov = obs_noise_cov)) @test length(get_rfms(srfi)) == n_srfi - @test_logs (:info,) (:info,) (:warn,) Emulator( + @test_logs (:info,) (:warn,) (:info,) (:warn,) Emulator( vrfi, iopairs; encoder_kwargs = (; obs_noise_cov = obs_noise_cov), diff --git a/test/Utilities/runtests.jl b/test/Utilities/runtests.jl index f235ed0f3..9a8191752 100644 --- a/test/Utilities/runtests.jl +++ b/test/Utilities/runtests.jl @@ -72,7 +72,7 @@ end zs = zscore_scale() mm = minmax_scale() qq = quartile_scale() - QQ = ElementwiseScaler{QuartileScaling, Vector{Int}}([1], [2]) + QQ = ElementwiseScaler{QuartileScaling, Vector{Int},Vector,Vector, Vector, Vector}([1], [2],[3],[4], [5], [6]) @test isa(zs, ElementwiseScaler) @test get_type(zs) == ZScoreScaling @test isa(mm, ElementwiseScaler) @@ -81,7 +81,10 @@ end @test get_type(qq) == QuartileScaling @test get_shift(QQ) == [1] @test get_scale(QQ) == [2] - + @test get_data_encoder_mat(QQ) == [3] + @test get_data_decoder_mat(QQ) == [4] + @test get_struct_encoder_mat(QQ) == [5] + @test get_struct_decoder_mat(QQ) == [6] dd = decorrelate() @test get_retain_var(dd) == 1.0 @test get_decorrelate_with(dd) == "combined" @@ -91,10 +94,13 @@ end dd3 = decorrelate_structure_mat(retain_var = 0.7) @test get_retain_var(dd3) == 0.7 @test get_decorrelate_with(dd3) == "structure_mat" - DD = Decorrelator([1], [2], [3], 1.0, "test", nothing) + DD = Decorrelator([1], [2], [3], 1.0, 4, 5, (; test=6), "test", nothing) @test get_data_mean(DD) == [1] @test get_encoder_mat(DD) == [2] @test get_decoder_mat(DD) == [3] + @test get_n_totvar_samples(DD) == 4 + @test get_max_rank(DD) == 5 + @test get_psvd_kwargs(DD) == (;test=6) cc = canonical_correlation() @@ -154,11 +160,11 @@ end (canonical_correlation(retain_var = 0.95), "in_and_out"), ] - lossless = [fill(true, 6); fill(false, 4)] # are these lossy approximations? + lossless = [fill(true, 6); fill(false, 4)] # are these lossless approximations? # functional test pipeline tol = 1e-12 - + for (name, sch, ll_flag) in zip(test_names, schedules, lossless) encoder_schedule = create_encoder_schedule(sch) (encoded_io_pairs, encoded_input_structure_mats, encoded_output_structure_mats, _, _) = @@ -381,7 +387,78 @@ end @test_throws ArgumentError encode_with_schedule(encoder_schedule, prior_cov, "bad") @test_throws ArgumentError decode_with_schedule(encoder_schedule, encoded_pc, "bad") +end + +@testset "Decorrelator: Large observational covariance" begin + + # loop over output dim + ds = [10, 10, 100, 1_000, 10_000, 100_000] # 1_000_000 + dts_struct = [] + dts_comb = [] + dts_samp = [] + for (d_idx, d) in enumerate(ds) + @info " " + @info "Testing decorrelating dimension: $d" + @info " " + #build some quick data + noise + m = 50 + p = 10 + x = rand(p, m) #R^3 + y = rand(d, m) #R^6 + + # "noise" + μ = zeros(d) + sam = rand(d,30) + Σ = tsvd_cov_from_samples(sam) + noise_samples = Σ.U * (sqrt.(Σ.S) .* Σ.Vt) * rand(MvNormal(μ, I), m) + y += noise_samples + + io_pairs = PairedDataContainer(x, y, data_are_columns = true) + + dt = @elapsed begin + enc1 = (decorrelate_sample_cov(), "in_and_out") # for these inputs this is the default + + enc_sch1 = create_encoder_schedule(enc1) + enc_io_pairs, enc_in, enc_out = initialize_and_encode_with_schedule!(enc_sch1, io_pairs; obs_noise_cov = [Σ]) + end + push!(dts_samp, dt) + + dt = @elapsed begin + enc2 = [(decorrelate_sample_cov(), "in"), (decorrelate_structure_mat(retain_var=0.95), "out")] # for these inputs this is the default + enc_sch2 = create_encoder_schedule(enc2) + enc_io_pairs, enc_in, enc_out = initialize_and_encode_with_schedule!(enc_sch2, io_pairs; obs_noise_cov = [Σ]) + end + push!(dts_struct, dt) + + dt = @elapsed begin + enc3 = [(decorrelate_sample_cov(), "in"), (decorrelate(retain_var=0.95), "out")] # for these inputs this is the default + enc_sch3 = create_encoder_schedule(enc3) + enc_io_pairs, enc_in, enc_out = initialize_and_encode_with_schedule!(enc_sch3, io_pairs; obs_noise_cov = [Σ]) + end + push!(dts_comb, dt) + + end + + dts_tols = 2*[dts_samp[2], dts_struct[2], dts_comb[2]] + for i in 1:length(ds) + + if i == 1 + println("dimension decorr-sample decorr-structure decorr-combined") + else + + # increate the tolerances by the factor + tols = ds[i]/ds[2] * dts_tols + println("$(ds[i]), $(dts_samp[i]), $(dts_struct[i]), $(dts_comb[i])") + if [dts_samp[i], dts_struct[i], dts_comb[i]] .> tols + @error("timings have exceeded linear scaling") + end + + end + end + # @tests? + end + From 2b19fe7753c331bbdd28c1bc7e777288a8e3112c Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 14 Nov 2025 17:45:20 -0800 Subject: [PATCH 11/32] typo in error calc --- test/Utilities/runtests.jl | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/Utilities/runtests.jl b/test/Utilities/runtests.jl index 9a8191752..c5f39152d 100644 --- a/test/Utilities/runtests.jl +++ b/test/Utilities/runtests.jl @@ -442,7 +442,7 @@ end end - dts_tols = 2*[dts_samp[2], dts_struct[2], dts_comb[2]] + dts_tols = 2*[dts_samp[2], dts_struct[2], dts_comb[2]] # baseline value for i in 1:length(ds) if i == 1 @@ -452,8 +452,8 @@ end # increate the tolerances by the factor tols = ds[i]/ds[2] * dts_tols println("$(ds[i]), $(dts_samp[i]), $(dts_struct[i]), $(dts_comb[i])") - if [dts_samp[i], dts_struct[i], dts_comb[i]] .> tols - @error("timings have exceeded linear scaling") + if any([dts_samp[i], dts_struct[i], dts_comb[i]] .> tols) + @error("∟ timings have exceeded linear scaling") end end From 504ebc38ce671e16b5f4453f30d7a7677992a411 Mon Sep 17 00:00:00 2001 From: odunbar Date: Sat, 15 Nov 2025 11:49:26 -0800 Subject: [PATCH 12/32] change kwarg back --- src/MarkovChainMonteCarlo.jl | 18 ++++++++++-------- 1 file changed, 10 insertions(+), 8 deletions(-) diff --git a/src/MarkovChainMonteCarlo.jl b/src/MarkovChainMonteCarlo.jl index 30e76d784..60ae38d51 100644 --- a/src/MarkovChainMonteCarlo.jl +++ b/src/MarkovChainMonteCarlo.jl @@ -548,12 +548,16 @@ function MCMCWrapper( mcmc_alg::MCMCProtocol, observation::AMorAV, prior::ParameterDistribution, - em::Emulator, - init_params::AV; + em::Emulator; + init_params::AV=[], burnin::Int = 0, kwargs..., ) where {AV <: AbstractVector, AMorAV <: Union{AbstractVector, AbstractMatrix}} + if length(init_params)==0 + init_params = mean(prior) + end + # make into iterable over vectors obs_slice = if observation isa AbstractVector{<:AbstractVector} observation @@ -591,23 +595,21 @@ function MCMCWrapper( mcmc_alg::MCMCProtocol, observation::OB, prior::PD, - em::EM, - init_params::AV; + em::EM; kwargs..., ) where {AV <: AbstractVector, OB <: Observation, PD <: ParameterDistribution, EM <: Emulator} - return MCMCWrapper(mcmc_alg, get_obs(observation), prior, em, init_params; kwargs) + return MCMCWrapper(mcmc_alg, get_obs(observation), prior, em; kwargs...) end function MCMCWrapper( mcmc_alg::MCMCProtocol, observation_series::OS, prior::PD, - em::EM, - init_params::AV; + em::EM; kwargs..., ) where {AV <: AbstractVector, OS <: ObservationSeries, PD <: ParameterDistribution, EM <: Emulator} observations = [get_obs(ob) for ob in get_observations(observation_series)] - return MCMCWrapper(mcmc_alg, observations, prior, em, init_params; kwargs) + return MCMCWrapper(mcmc_alg, observations, prior, em; kwargs...) end """ $(DocStringExtensions.FUNCTIONNAME)([rng,] mcmc::MCMCWrapper, args...; kwargs...) From f8a693cc5c70667628e513bde86f1dae56f74c81 Mon Sep 17 00:00:00 2001 From: odunbar Date: Sun, 16 Nov 2025 17:59:17 -0800 Subject: [PATCH 13/32] linear scaling check --- test/Utilities/runtests.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/Utilities/runtests.jl b/test/Utilities/runtests.jl index c5f39152d..069d2259d 100644 --- a/test/Utilities/runtests.jl +++ b/test/Utilities/runtests.jl @@ -450,7 +450,7 @@ end else # increate the tolerances by the factor - tols = ds[i]/ds[2] * dts_tols + tols = 5 * ds[i]/ds[2] * dts_tols # should be < 5 x scaling println("$(ds[i]), $(dts_samp[i]), $(dts_struct[i]), $(dts_comb[i])") if any([dts_samp[i], dts_struct[i], dts_comb[i]] .> tols) @error("∟ timings have exceeded linear scaling") From ea247f123e781465435a8cd75e6f374f45b3f6da Mon Sep 17 00:00:00 2001 From: odunbar Date: Sun, 16 Nov 2025 18:01:21 -0800 Subject: [PATCH 14/32] julia format --- src/Emulator.jl | 12 +- src/MarkovChainMonteCarlo.jl | 6 +- src/Utilities.jl | 118 ++++++++++--------- src/Utilities/canonical_correlation.jl | 6 +- src/Utilities/decorrelator.jl | 155 +++++++++++++++---------- src/Utilities/elementwise_scaler.jl | 29 +++-- test/Emulator/runtests.jl | 6 +- test/Utilities/runtests.jl | 42 +++---- 8 files changed, 211 insertions(+), 163 deletions(-) diff --git a/src/Emulator.jl b/src/Emulator.jl index af9c7e99a..a4caa6517 100644 --- a/src/Emulator.jl +++ b/src/Emulator.jl @@ -193,11 +193,7 @@ $(TYPEDSIGNATURES) Encode a new structure matrix in the input space (`"in"`) or output space (`"out"`). with the stored and initialized encoder schedule. """ -function encode_structure_matrix( - emulator::Emulator, - structure_mat, - in_or_out::AS, -) where {AS <: AbstractString} +function encode_structure_matrix(emulator::Emulator, structure_mat, in_or_out::AS) where {AS <: AbstractString} return encode_with_schedule(get_encoder_schedule(emulator), structure_mat, in_or_out) end @@ -224,11 +220,7 @@ $(TYPEDSIGNATURES) Decode a new structure matrix in the input space (`"in"`) or output space (`"out"`). with the stored and initialized encoder schedule. """ -function decode_structure_matrix( - emulator::Emulator, - structure_mat, - in_or_out::AS, -) where {AS <: AbstractString} +function decode_structure_matrix(emulator::Emulator, structure_mat, in_or_out::AS) where {AS <: AbstractString} return decode_with_schedule(get_encoder_schedule(emulator), structure_mat, in_or_out) end diff --git a/src/MarkovChainMonteCarlo.jl b/src/MarkovChainMonteCarlo.jl index 60ae38d51..ac509a184 100644 --- a/src/MarkovChainMonteCarlo.jl +++ b/src/MarkovChainMonteCarlo.jl @@ -549,15 +549,15 @@ function MCMCWrapper( observation::AMorAV, prior::ParameterDistribution, em::Emulator; - init_params::AV=[], + init_params::AV = [], burnin::Int = 0, kwargs..., ) where {AV <: AbstractVector, AMorAV <: Union{AbstractVector, AbstractMatrix}} - if length(init_params)==0 + if length(init_params) == 0 init_params = mean(prior) end - + # make into iterable over vectors obs_slice = if observation isa AbstractVector{<:AbstractVector} observation diff --git a/src/Utilities.jl b/src/Utilities.jl index 613b40726..bc26c4582 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -72,7 +72,7 @@ end # Using Observation Objects: function encoder_kwargs_from(obs::OB) where {OB <: Observation} - return (obs_noise_cov = get_covs(obs, build=false), observation = get_obs(obs)) + return (obs_noise_cov = get_covs(obs, build = false), observation = get_obs(obs)) end function encoder_kwargs_from(os::OS) where {OS <: ObservationSeries} @@ -80,7 +80,7 @@ function encoder_kwargs_from(os::OS) where {OS <: ObservationSeries} return [encoder_kwargs_from(obs) for obs in obs_vec] end -function encoder_kwargs_from(prior::PD; rng=Random.default_rng(), n_samples = 100) where {PD <: ParameterDistribution} +function encoder_kwargs_from(prior::PD; rng = Random.default_rng(), n_samples = 100) where {PD <: ParameterDistribution} return (prior_cov = cov(prior), prior_samples_in = sample(rng, prior, n_samples)) end @@ -94,7 +94,7 @@ This is useful when A is high dimensional and provided as an `SVD` or `SumOfCova """ function lmul_compact(A, X::AVorM) where {AVorM <: AbstractVecOrMat} # A is presumed a vector, of (compact) matrix types. - return isa(A, AbstractVector) ? EKP.lmul_without_build(A,X) : EKP.lmul_without_build([A],X) + return isa(A, AbstractVector) ? EKP.lmul_without_build(A, X) : EKP.lmul_without_build([A], X) end """ @@ -114,45 +114,49 @@ When computing the svd internally from an abstract matrix - `tsvd_rank=50`: when using tsvd, what rank to truncate at. """ -function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank=50) - Avec = isa(A, AbstractVector) ? A : [A] +function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank = 50) + Avec = isa(A, AbstractVector) ? A : [A] # explicitly write the loop here: Us = [] Ss = [] VTs = [] ds = [] - batches=[] + batches = [] shift = 0 for a in Avec - bsize=[0] + bsize = [0] if isa(a, UniformScaling) - throw(ArgumentError("Detected `UniformScaling` (i.e. \"λI\") StructureMatrix, and unable to infer dimensionality. \n Please recast this as a diagonal matrix, defining \"λI(d)\" for dimension d")) + throw( + ArgumentError( + "Detected `UniformScaling` (i.e. \"λI\") StructureMatrix, and unable to infer dimensionality. \n Please recast this as a diagonal matrix, defining \"λI(d)\" for dimension d", + ), + ) end if isa(a, AbstractMatrix) - if size(a,1) <= svd_dim_max + if size(a, 1) <= svd_dim_max svda = svd(a) push!(Us, svda.U) push!(Ss, svda.S) push!(VTs, svda.Vt) - push!(ds, zeros(size(a,1))) - bsize[1] = size(a,1) + push!(ds, zeros(size(a, 1))) + bsize[1] = size(a, 1) else - svda = EKP.tsvd_mat(a, min(tsvd_rank, size(a,1)-1)) # swap to tsvd for performance + svda = EKP.tsvd_mat(a, min(tsvd_rank, size(a, 1) - 1)) # swap to tsvd for performance push!(Us, svda.U) push!(Ss, svda.S) push!(VTs, svda.Vt) - push!(ds, zeros(size(a,1))) - bsize[1] = size(a,1) - end + push!(ds, zeros(size(a, 1))) + bsize[1] = size(a, 1) + end elseif isa(a, SVD) svda = a push!(Us, svda.U) push!(Ss, svda.S) push!(VTs, svda.Vt) - push!(ds, zeros(size(a.U,1))) - bsize[1] = size(a.U,1) - elseif isa(a, SVDplusD) + push!(ds, zeros(size(a.U, 1))) + bsize[1] = size(a.U, 1) + elseif isa(a, SVDplusD) svda = a.svd_cov diaga = (a.diag_cov).diag push!(Us, svda.U) @@ -161,8 +165,8 @@ function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank=50) push!(ds, diaga) bsize[1] = length(diaga) end - - batch = shift+1:shift+bsize[1] + + batch = (shift + 1):(shift + bsize[1]) push!(batches, batch) shift = batch[end] end @@ -171,14 +175,20 @@ function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank=50) # LinearMaps can only be applied to vectors in general, so we only provide this argumentation Amap = LinearMap( - x -> reduce(vcat, [U * (S .* (Vt * x[batch])) + d .* x[batch] for (U,S,Vt,d, batch) in zip(Us,Ss,VTs,ds,batches)]), - x -> reduce(vcat, [Vt' * (S .* (U' * x[batch])) + d .* x[batch] for (U,S,Vt,d, batch) in zip(Us,Ss,VTs,ds,batches)]), + x -> reduce( + vcat, + [U * (S .* (Vt * x[batch])) + d .* x[batch] for (U, S, Vt, d, batch) in zip(Us, Ss, VTs, ds, batches)], + ), + x -> reduce( + vcat, + [Vt' * (S .* (U' * x[batch])) + d .* x[batch] for (U, S, Vt, d, batch) in zip(Us, Ss, VTs, ds, batches)], + ), sum(size(U, 1) for U in Us), sum(size(Vt, 2) for Vt in VTs), ) return Amap - + end @@ -191,7 +201,7 @@ svd of a sum of two matrices `A` and `B` in svd form without building A+B direct This is useful when A and B are low rank, but high dimensional and provided as SVD types. (e.g. from `EKP.tsvd_cov_from_samples`) """ function svd_of_sum(svdA::SS1,svdB::SS2) where { SS1 <: SVD, SS2 <: SVD} - + # treat A + B as just "low rank" # can write A+B = L * R = [Ua Ub] * [ Sa * Va'; Sb * Vb'] L = [svdA.U svdB.U] # N x (r1+r2) @@ -202,9 +212,9 @@ function svd_of_sum(svdA::SS1,svdB::SS2) where { SS1 <: SVD, SS2 <: SVD} ss = svd(qrl.R*qrr.R') return SVD(qrl.Q*ss.U, ss.S, ss.Vt*qrr.Q') # build the new svd - + end - + function inv_sqrt_of_svdplusd(a) D = a.diag_cov D += sqrt(eps())*I # minimum tolerance for some operations below @@ -213,7 +223,7 @@ function inv_sqrt_of_svdplusd(a) ss = a.svd_cov U = ss.U S = Diagonal(ss.S) - + # begin computing the whitening transform M = inv(S) + U'*iD*U riM = sqrt(inv(M)) @@ -227,7 +237,7 @@ function inv_sqrt_of_svdplusd(a) # LHS evals sqrt(1-σ_i^2), rhs evals 1 - chat * σ_i^2 # => chat = (1 - sqrt(1-σ_i^2))/(σ_i^2) # where σ_i is eval of A = sqrt(ev.values) ev_correction = Diagonal((1.0 .-sqrt.(1.0 .- ev.values)) ./ ev.values) - + # Then, (I - BM^{-1}B')^{1/2} = I - B M^{-1/2} V sv V' M^{-1/2} B' rt_ImBiMB = I - B * riM * V * ev_correction * V' * riM * B' # Idea is that woodbury: Σ^{-1} = D^{-1/2} * ImBiMB * D^{-1/2} @@ -259,15 +269,22 @@ Kwargs: - rng (=default_rng()): When provided, and `n_eval < size(A,1)`; a random subset of the basis is compared, using this `rng`. - up_to_sign(=false): Only assess equality up to a sign-error (sufficient for e.g. encoder/decoder matrices) """ -function isequal_linear(A::LM1, B::LM2; tol=2*eps(), n_eval=nothing, rng = Random.default_rng(), up_to_sign=false) where {LM1 <: LinearMap, LM2 <: LinearMap} +function isequal_linear( + A::LM1, + B::LM2; + tol = 2 * eps(), + n_eval = nothing, + rng = Random.default_rng(), + up_to_sign = false, +) where {LM1 <: LinearMap, LM2 <: LinearMap} m, n = size(A) if !(n == size(B, 2)) return false end - if !(m == size(B, 1)) + if !(m == size(B, 1)) return false end - + # test on standard basis (up to n_eval tests) basis_id = isa(n_eval, Nothing) ? collect(1:n) : randperm(rng, n)[1:n_eval] @@ -282,7 +299,7 @@ function isequal_linear(A::LM1, B::LM2; tol=2*eps(), n_eval=nothing, rng = Rando if !(norm(AmB) <= n * tol) return false end - e[j] -= 1 + e[j] -= 1 end return true end @@ -291,26 +308,26 @@ function isequal_linear(A::AMorV1, B::AMorV2; kwargs...) where {AMorV1 <: Abstra if !(size(A) == size(B)) return false end - - return all(isequal_linear(a,b; kwargs...) for (a,b) in zip(A[:],B[:])) + + return all(isequal_linear(a, b; kwargs...) for (a, b) in zip(A[:], B[:])) end function Base.:(==)(a::LM1, b::LM2) where {LM1 <: LinearMap, LM2 <: LinearMap} - n=size(a,2) + n = size(a, 2) if n < 1e4 # gets expensive - return isequal_linear(a,b; tol=1e-12) + return isequal_linear(a, b; tol = 1e-12) else - return isequal_linear(a,b; n_eval=Int(floor(sqrt(n))), tol=1e-12) # 1e4 compares ~ 100 evals, 1e7 compares ~ 3000 evals + return isequal_linear(a, b; n_eval = Int(floor(sqrt(n))), tol = 1e-12) # 1e4 compares ~ 100 evals, 1e7 compares ~ 3000 evals end end Base.:(==)(a::DCP1, b::DCP2) where {DCP1 <: DataContainerProcessor, DCP2 <: DataContainerProcessor} = - all(getfield(a,f) == getfield(b,f) for f in fieldnames(DCP1)) + all(getfield(a, f) == getfield(b, f) for f in fieldnames(DCP1)) Base.:(==)(a::PDCP1, b::PDCP2) where {PDCP1 <: PairedDataContainerProcessor, PDCP2 <: PairedDataContainerProcessor} = - all(getfield(a,f) == getfield(b,f) for f in fieldnames(PDCP1)) + all(getfield(a, f) == getfield(b, f) for f in fieldnames(PDCP1)) -function norm_linear_map(A::LM, p::Real=2; n_eval=nothing) where {LM <: LinearMap} +function norm_linear_map(A::LM, p::Real = 2; n_eval = nothing) where {LM <: LinearMap} m, n = size(A) # test on standard basis (up to n_eval tests) basis_id = isa(n_eval, Nothing) ? collect(1:n) : randperm(rng, n)[1:n_eval] @@ -320,7 +337,7 @@ function norm_linear_map(A::LM, p::Real=2; n_eval=nothing) where {LM <: LinearMa for j in basis_id e[j] += 1 norm_val[1] += 1.0 / n * norm(A * e, p) - e[j] -= 1 + e[j] -= 1 end return norm_val[1] end @@ -504,28 +521,28 @@ function initialize_and_encode_with_schedule!( if !isnothing(prior_cov) (input_structure_mats[:prior_cov] = prior_cov) end - for (key,val) in input_structure_mats + for (key, val) in input_structure_mats if isa(val, UniformScaling) # remove this annoying case immediately - input_dim = size(get_inputs(io_pairs),1) + input_dim = size(get_inputs(io_pairs), 1) input_structure_mats[key] = create_compact_linear_map(val(input_dim)) else input_structure_mats[key] = create_compact_linear_map(val) end end - + output_structure_mats = deepcopy(output_structure_mats) if !isnothing(obs_noise_cov) (output_structure_mats[:obs_noise_cov] = obs_noise_cov) end - for (key,val) in output_structure_mats + for (key, val) in output_structure_mats if isa(val, UniformScaling) # remove this annoying case immediately - output_dim = size(get_outputs(io_pairs),1) + output_dim = size(get_outputs(io_pairs), 1) output_structure_mats[key] = create_compact_linear_map(val(output_dim)) else output_structure_mats[key] = create_compact_linear_map(val) end end - + input_structure_vecs = deepcopy(input_structure_vecs) if !isnothing(prior_samples_in) (input_structure_vecs[:prior_samples_in] = prior_samples_in) @@ -636,12 +653,7 @@ function decode_with_schedule( io_pairs::PDC, input_structure_mat::SM1, output_structure_mat::SM2, -) where { - VV <: AbstractVector, - SM1 <: StructureMatrix, - SM2 <: StructureMatrix, - PDC <: PairedDataContainer, -} +) where {VV <: AbstractVector, SM1 <: StructureMatrix, SM2 <: StructureMatrix, PDC <: PairedDataContainer} processed_io_pairs = deepcopy(io_pairs) processed_input_structure_mat = deepcopy(input_structure_mat) processed_output_structure_mat = deepcopy(output_structure_mat) diff --git a/src/Utilities/canonical_correlation.jl b/src/Utilities/canonical_correlation.jl index 9ca6e5c9c..8ffe78c11 100644 --- a/src/Utilities/canonical_correlation.jl +++ b/src/Utilities/canonical_correlation.jl @@ -186,8 +186,8 @@ Apply the `CanonicalCorrelation` encoder, on a columns-are-data matrix function encode_data(cc::CanonicalCorrelation, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(cc)[1] encoder_mat = get_encoder_mat(cc)[1] - out = zeros(size(encoder_mat,1), size(data,2)) - mul!(out, encoder_mat, deepcopy(data).- data_mean) + out = zeros(size(encoder_mat, 1), size(data, 2)) + mul!(out, encoder_mat, deepcopy(data) .- data_mean) return out end @@ -199,7 +199,7 @@ Apply the `CanonicalCorrelation` decoder, on a columns-are-data matrix function decode_data(cc::CanonicalCorrelation, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(cc)[1] decoder_mat = get_decoder_mat(cc)[1] - out = zeros(size(decoder_mat,1), size(data,2)) + out = zeros(size(decoder_mat, 1), size(data, 2)) mul!(out, decoder_mat, deepcopy(data)) return out .+ data_mean end diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index 299c6b954..24f1b99b3 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -1,7 +1,14 @@ # included in Utilities.jl export Decorrelator, decorrelate_sample_cov, decorrelate_structure_mat, decorrelate -export get_data_mean, get_encoder_mat, get_decoder_mat, get_retain_var, get_decorrelate_with, get_n_totvar_samples, get_max_rank, get_psvd_kwargs +export get_data_mean, + get_encoder_mat, + get_decoder_mat, + get_retain_var, + get_decorrelate_with, + get_n_totvar_samples, + get_max_rank, + get_psvd_kwargs """ $(TYPEDEF) @@ -68,14 +75,23 @@ Constructs the `Decorrelator` struct. Users can add optional keyword arguments: - `"combined"`, sums the `"sample_cov"` and `"structure_mat"` matrices """ decorrelate(; - retain_var::FT = Float64(1.0), - decorrelate_with = "combined", - structure_mat_name = nothing, - n_totvar_samples::Int=500, - max_rank::Int=100, - psvd_kwargs=(;rtol=1e-5), - ) where {FT} = - Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), n_totvar_samples, max_rank, psvd_kwargs, decorrelate_with, structure_mat_name) + retain_var::FT = Float64(1.0), + decorrelate_with = "combined", + structure_mat_name = nothing, + n_totvar_samples::Int = 500, + max_rank::Int = 100, + psvd_kwargs = (; rtol = 1e-5), +) where {FT} = Decorrelator( + [], + [], + [], + clamp(retain_var, FT(0), FT(1)), + n_totvar_samples, + max_rank, + psvd_kwargs, + decorrelate_with, + structure_mat_name, +) """ $(TYPEDSIGNATURES) @@ -84,12 +100,21 @@ Constructs the `Decorrelator` struct, setting decorrelate_with = "sample_cov". E - `retain_var`[=`1.0`]: to project onto the leading singular vectors such that `retain_var` variance is retained """ decorrelate_sample_cov(; - retain_var::FT = Float64(1.0), - n_totvar_samples::Int=500, - max_rank::Int=100, - psvd_kwargs=(;rtol=1e-5), - ) where {FT} = - Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), n_totvar_samples, max_rank, psvd_kwargs, "sample_cov", nothing) + retain_var::FT = Float64(1.0), + n_totvar_samples::Int = 500, + max_rank::Int = 100, + psvd_kwargs = (; rtol = 1e-5), +) where {FT} = Decorrelator( + [], + [], + [], + clamp(retain_var, FT(0), FT(1)), + n_totvar_samples, + max_rank, + psvd_kwargs, + "sample_cov", + nothing, +) """ $(TYPEDSIGNATURES) @@ -98,13 +123,22 @@ Constructs the `Decorrelator` struct, setting decorrelate_with = "structure_mat" - `retain_var`[=`1.0`]: to project onto the leading singular vectors such that `retain_var` variance is retained """ decorrelate_structure_mat(; - retain_var::FT = Float64(1.0), - structure_mat_name = nothing, - n_totvar_samples::Int=500, - max_rank::Int=100, - psvd_kwargs=(; rtol=1e-3), - ) where {FT} = - Decorrelator([], [], [], clamp(retain_var, FT(0), FT(1)), n_totvar_samples, max_rank, psvd_kwargs, "structure_mat", structure_mat_name) + retain_var::FT = Float64(1.0), + structure_mat_name = nothing, + n_totvar_samples::Int = 500, + max_rank::Int = 100, + psvd_kwargs = (; rtol = 1e-3), +) where {FT} = Decorrelator( + [], + [], + [], + clamp(retain_var, FT(0), FT(1)), + n_totvar_samples, + max_rank, + psvd_kwargs, + "structure_mat", + structure_mat_name, +) """ $(TYPEDSIGNATURES) @@ -181,7 +215,7 @@ function initialize_processor!( data::MM, structure_matrices::Dict{Symbol, SM}, ::Dict{Symbol, SV}, -) where {MM <: AbstractMatrix, SM <: StructureMatrix, SV <: StructureVector} +) where {MM <: AbstractMatrix, SM <: StructureMatrix, SV <: StructureVector} if length(get_data_mean(dd)) == 0 push!(get_data_mean(dd), vec(mean(data, dims = 2))) end @@ -202,7 +236,7 @@ function initialize_processor!( map1 = get_structure_mat(structure_matrices, dd.structure_mat_name) decorrelation_action2 = tsvd_cov_from_samples(data) map2 = create_compact_linear_map(decorrelation_action2) - decorrelation_map = map1+map2 # x -> dm.maps[1].f(x) + dm.maps[2].f(x) + decorrelation_map = map1 + map2 # x -> dm.maps[1].f(x) + dm.maps[2].f(x) else throw( ArgumentError( @@ -216,8 +250,8 @@ function initialize_processor!( psvd_kwargs = get_psvd_kwargs(dd) ret_var = get_retain_var(dd) - S=[] - Vt=[] + S = [] + Vt = [] # Three methods of performing: svd, partial svd or truncated svd. # svd: convert to matrix and perform actual SVD. [good for small matrix (d < ~3000)] @@ -228,7 +262,7 @@ function initialize_processor!( # svd options svdA = svd(Matrix(decorrelation_map)) rk = rank(Matrix(decorrelation_map)) - + ret_var = get_retain_var(dd) if ret_var < 1.0 sv_cumsum = cumsum(svdA.S) / sum(svdA.S) # variance contributions are (sing_val) for these matrices @@ -240,79 +274,80 @@ function initialize_processor!( @info " truncating at $(trunc_val)/$(size(data,1)), as low-rank data detected" end end - + push!(S, svdA.S[1:trunc_val]) - push!(Vt, svdA.Vt[1:trunc_val,:]) - + push!(Vt, svdA.Vt[1:trunc_val, :]) + else if ret_var < 1.0 # tsvd option # approximate Frobenius norm of the map norm_approx = zeros(10) - for i = 1:10 - samples = randn(size(decorrelation_map,1), n_totvar_samples) - norm_approx[i] = 1/n_totvar_samples * sum([sum(abs2, (decorrelation_map * x)) for x in eachcol(samples)]) + for i in 1:10 + samples = randn(size(decorrelation_map, 1), n_totvar_samples) + norm_approx[i] = + 1 / n_totvar_samples * sum([sum(abs2, (decorrelation_map * x)) for x in eachcol(samples)]) end @info "relative error of total variance $(std(norm_approx)/mean(norm_approx))" retain_var_max = 1 - std(norm_approx) / mean(norm_approx) - + ret_var_tmp = min(ret_var, retain_var_max) - - for rk in 1:max_rank - _,Stmp,Vtmp = tsvd(decorrelation_map, rk) - retain_var_current = sum(Stmp.^2) / (retain_var_max * mean(norm_approx)) + + for rk in 1:max_rank + _, Stmp, Vtmp = tsvd(decorrelation_map, rk) + retain_var_current = sum(Stmp .^ 2) / (retain_var_max * mean(norm_approx)) if retain_var_current > ret_var_tmp - push!(S,Stmp) - push!(Vt,Vtmp') + push!(S, Stmp) + push!(Vt, Vtmp') @info " truncating at $(rk)/$(size(data,1)) retaining $(retain_var_current*100)% (+/-$(100*std(norm_approx)/mean(norm_approx)))% of the variance of the structure matrix" - break + break end if rk == max_rank @warn "Maximum tolerance of SVD truncation hit ($(rank_max)), consider increasing `rank_max` in decorrelator, this may also result from `retain_var` being close to 1, while `n_totvar_samples` is low. Proceeding with final iterant." - push!(S,Stmp) - push!(Vt,Vtmp') - + push!(S, Stmp) + push!(Vt, Vtmp') + end - + end else # psvd option # check V or Vt - _,Stmp,Vtmp = psvd(decorrelation_map; psvd_kwargs...) # randomized algorithm to avoid building the matrix, but this will be big. - + _, Stmp, Vtmp = psvd(decorrelation_map; psvd_kwargs...) # randomized algorithm to avoid building the matrix, but this will be big. + if length(Stmp) < size(data, 1) @info " truncating at $(length(Stmp))/$(size(data,1)), as low-rank data detected" end - push!(S,Stmp) - push!(Vt,Vtmp') - + push!(S, Stmp) + push!(Vt, Vtmp') + end end - + # Enforce a sign convention for the singular vectors (rows Vt have positive first entry) - for (j,row) in enumerate(eachrow(Vt[1])) + for (j, row) in enumerate(eachrow(Vt[1])) if row[1] < 0 - Vt[1][j,:] *= -1 + Vt[1][j, :] *= -1 end end - + # we explicitly make the encoder/decoder maps - encoder_map = LinearMap( + encoder_map = LinearMap( x -> Diagonal(1.0 ./ sqrt.(S[1])) * Vt[1] * x, # Ax x -> Vt[1]' * Diagonal(1.0 ./ sqrt.(S[1])) * x, # A'x size(Vt[1], 1), # size(A,1) size(Vt[1], 2), # size(A,2) ) - decoder_map = LinearMap( + decoder_map = LinearMap( x -> Vt[1]' * Diagonal(sqrt.(S[1])) * x, # Ax x -> Diagonal(sqrt.(S[1])) * Vt[1] * x, # A'x size(Vt[1]', 1), # size(A,1) size(Vt[1]', 2), # size(A,2) ) - + push!(get_encoder_mat(dd), encoder_map) push!(get_decoder_mat(dd), decoder_map) end @@ -327,8 +362,8 @@ Apply the `Decorrelator` encoder, on a columns-are-data matrix function encode_data(dd::Decorrelator, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(dd)[1] encoder_mat = get_encoder_mat(dd)[1] - out = zeros(size(encoder_mat,1), size(data,2)) - mul!(out, encoder_mat, deepcopy(data).- data_mean) + out = zeros(size(encoder_mat, 1), size(data, 2)) + mul!(out, encoder_mat, deepcopy(data) .- data_mean) return out end @@ -340,7 +375,7 @@ Apply the `Decorrelator` decoder, on a columns-are-data matrix function decode_data(dd::Decorrelator, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(dd)[1] decoder_mat = get_decoder_mat(dd)[1] - out = zeros(size(decoder_mat,1), size(data,2)) + out = zeros(size(decoder_mat, 1), size(data, 2)) mul!(out, decoder_mat, deepcopy(data)) return out .+ data_mean end diff --git a/src/Utilities/elementwise_scaler.jl b/src/Utilities/elementwise_scaler.jl index 7ad44d710..52f163081 100644 --- a/src/Utilities/elementwise_scaler.jl +++ b/src/Utilities/elementwise_scaler.jl @@ -2,7 +2,8 @@ export UnivariateAffineScaling, ElementwiseScaler, QuartileScaling, MinMaxScaling, ZScoreScaling export quartile_scale, minmax_scale, zscore_scale -export get_type, get_shift, get_scale, get_data_encoder_mat, get_data_decoder_mat, get_struct_encoder_mat, get_struct_decoder_mat +export get_type, + get_shift, get_scale, get_data_encoder_mat, get_data_decoder_mat, get_struct_encoder_mat, get_struct_decoder_mat """ $(TYPEDEF) @@ -16,7 +17,14 @@ Different methods `T` will build different transformations: and are accessed with [`get_type`](@ref) """ -struct ElementwiseScaler{T, VV <: AbstractVector, VV2 <: AbstractVector, VV3 <: AbstractVector, VV4 <: AbstractVector, VV5 <: AbstractVector} <: DataContainerProcessor +struct ElementwiseScaler{ + T, + VV <: AbstractVector, + VV2 <: AbstractVector, + VV3 <: AbstractVector, + VV4 <: AbstractVector, + VV5 <: AbstractVector, +} <: DataContainerProcessor "storage for the shift applied to data" shift::VV "storage for the scaling" @@ -161,31 +169,31 @@ function initialize_processor!(es::ElementwiseScaler, data::MM) where {MM <: Abs initialize_processor!(es, data, T) # we explicitly make the encoder/decoder maps - data_encoder_map = LinearMap( + data_encoder_map = LinearMap( x -> (x .- get_shift(es)) ./ get_scale(es), # Ax x -> (x .- get_shift(es)) ./ get_scale(es), # A'x size(data, 1), # size(A,1) size(data, 1), # size(A,2) ) - data_decoder_map = LinearMap( + data_decoder_map = LinearMap( x -> x .* get_scale(es) .+ get_shift(es), # Ax x -> x .* get_scale(es) .+ get_shift(es), # A'x size(data, 1), # size(A,1) size(data, 1), # size(A,2) ) # the encoder for the structure matrix does not have a shift - struct_encoder_map = LinearMap( - x -> x ./ get_scale(es), # Ax - x -> x ./ get_scale(es), # A'x + struct_encoder_map = LinearMap( + x -> x ./ get_scale(es), # Ax + x -> x ./ get_scale(es), # A'x size(data, 1), # size(A,1) size(data, 1), # size(A,2) ) - struct_decoder_map = LinearMap( + struct_decoder_map = LinearMap( x -> x .* get_scale(es), # Ax x -> x .* get_scale(es), # A'x size(data, 1), # size(A,1) size(data, 1), # size(A,2) - ) + ) push!(get_data_encoder_mat(es), data_encoder_map) push!(get_data_decoder_mat(es), data_decoder_map) push!(get_struct_encoder_mat(es), struct_encoder_map) @@ -250,6 +258,5 @@ Apply the `ElementwiseScaler` decoder to a provided structure matrix. If the str function decode_structure_matrix(es::ElementwiseScaler, enc_structure_matrix::SM) where {SM <: StructureMatrix} decoder_mat = get_struct_decoder_mat(es)[1] return decoder_mat * enc_structure_matrix * decoder_mat' -# return Diagonal(get_scale(es)) * enc_structure_matrix * Diagonal(get_scale(es)) + # return Diagonal(get_scale(es)) * enc_structure_matrix * Diagonal(get_scale(es)) end - diff --git a/test/Emulator/runtests.jl b/test/Emulator/runtests.jl index 0211dc4d2..898972c97 100644 --- a/test/Emulator/runtests.jl +++ b/test/Emulator/runtests.jl @@ -24,7 +24,7 @@ struct MLTester <: Emulators.MachineLearningTool end # "noise" μ = zeros(d) - Σ = rand(d,d) + Σ = rand(d, d) Σ = Σ' * Σ noise_samples = rand(MvNormal(μ, Σ), m) y += noise_samples @@ -48,8 +48,8 @@ struct MLTester <: Emulators.MachineLearningTool end # NB this gives encoder up to sign tol = 1e-12 @test get_encoder_schedule(em) == enc_sch # inputs: proc - @test all(isapprox.(get_inputs(get_encoded_io_pairs(em)), get_inputs(enc_io_pairs), atol=tol)) - @test all(isapprox.(get_outputs(get_encoded_io_pairs(em)), get_outputs(enc_io_pairs), atol=tol)) + @test all(isapprox.(get_inputs(get_encoded_io_pairs(em)), get_inputs(enc_io_pairs), atol = tol)) + @test all(isapprox.(get_outputs(get_encoded_io_pairs(em)), get_outputs(enc_io_pairs), atol = tol)) @test isempty(enc_I_in) #NB - encoders all tested in Utilities here just testing some API diff --git a/test/Utilities/runtests.jl b/test/Utilities/runtests.jl index 069d2259d..99d70ce11 100644 --- a/test/Utilities/runtests.jl +++ b/test/Utilities/runtests.jl @@ -72,7 +72,7 @@ end zs = zscore_scale() mm = minmax_scale() qq = quartile_scale() - QQ = ElementwiseScaler{QuartileScaling, Vector{Int},Vector,Vector, Vector, Vector}([1], [2],[3],[4], [5], [6]) + QQ = ElementwiseScaler{QuartileScaling, Vector{Int}, Vector, Vector, Vector, Vector}([1], [2], [3], [4], [5], [6]) @test isa(zs, ElementwiseScaler) @test get_type(zs) == ZScoreScaling @test isa(mm, ElementwiseScaler) @@ -94,13 +94,13 @@ end dd3 = decorrelate_structure_mat(retain_var = 0.7) @test get_retain_var(dd3) == 0.7 @test get_decorrelate_with(dd3) == "structure_mat" - DD = Decorrelator([1], [2], [3], 1.0, 4, 5, (; test=6), "test", nothing) + DD = Decorrelator([1], [2], [3], 1.0, 4, 5, (; test = 6), "test", nothing) @test get_data_mean(DD) == [1] @test get_encoder_mat(DD) == [2] @test get_decoder_mat(DD) == [3] @test get_n_totvar_samples(DD) == 4 @test get_max_rank(DD) == 5 - @test get_psvd_kwargs(DD) == (;test=6) + @test get_psvd_kwargs(DD) == (; test = 6) cc = canonical_correlation() @@ -164,7 +164,7 @@ end # functional test pipeline tol = 1e-12 - + for (name, sch, ll_flag) in zip(test_names, schedules, lossless) encoder_schedule = create_encoder_schedule(sch) (encoded_io_pairs, encoded_input_structure_mats, encoded_output_structure_mats, _, _) = @@ -408,41 +408,44 @@ end p = 10 x = rand(p, m) #R^3 y = rand(d, m) #R^6 - + # "noise" μ = zeros(d) - sam = rand(d,30) - Σ = tsvd_cov_from_samples(sam) + sam = rand(d, 30) + Σ = tsvd_cov_from_samples(sam) noise_samples = Σ.U * (sqrt.(Σ.S) .* Σ.Vt) * rand(MvNormal(μ, I), m) y += noise_samples - + io_pairs = PairedDataContainer(x, y, data_are_columns = true) dt = @elapsed begin enc1 = (decorrelate_sample_cov(), "in_and_out") # for these inputs this is the default - + enc_sch1 = create_encoder_schedule(enc1) - enc_io_pairs, enc_in, enc_out = initialize_and_encode_with_schedule!(enc_sch1, io_pairs; obs_noise_cov = [Σ]) + enc_io_pairs, enc_in, enc_out = + initialize_and_encode_with_schedule!(enc_sch1, io_pairs; obs_noise_cov = [Σ]) end push!(dts_samp, dt) - + dt = @elapsed begin - enc2 = [(decorrelate_sample_cov(), "in"), (decorrelate_structure_mat(retain_var=0.95), "out")] # for these inputs this is the default + enc2 = [(decorrelate_sample_cov(), "in"), (decorrelate_structure_mat(retain_var = 0.95), "out")] # for these inputs this is the default enc_sch2 = create_encoder_schedule(enc2) - enc_io_pairs, enc_in, enc_out = initialize_and_encode_with_schedule!(enc_sch2, io_pairs; obs_noise_cov = [Σ]) + enc_io_pairs, enc_in, enc_out = + initialize_and_encode_with_schedule!(enc_sch2, io_pairs; obs_noise_cov = [Σ]) end push!(dts_struct, dt) dt = @elapsed begin - enc3 = [(decorrelate_sample_cov(), "in"), (decorrelate(retain_var=0.95), "out")] # for these inputs this is the default + enc3 = [(decorrelate_sample_cov(), "in"), (decorrelate(retain_var = 0.95), "out")] # for these inputs this is the default enc_sch3 = create_encoder_schedule(enc3) - enc_io_pairs, enc_in, enc_out = initialize_and_encode_with_schedule!(enc_sch3, io_pairs; obs_noise_cov = [Σ]) + enc_io_pairs, enc_in, enc_out = + initialize_and_encode_with_schedule!(enc_sch3, io_pairs; obs_noise_cov = [Σ]) end push!(dts_comb, dt) - + end - dts_tols = 2*[dts_samp[2], dts_struct[2], dts_comb[2]] # baseline value + dts_tols = 2 * [dts_samp[2], dts_struct[2], dts_comb[2]] # baseline value for i in 1:length(ds) if i == 1 @@ -450,15 +453,14 @@ end else # increate the tolerances by the factor - tols = 5 * ds[i]/ds[2] * dts_tols # should be < 5 x scaling + tols = 5 * ds[i] / ds[2] * dts_tols # should be < 5 x scaling println("$(ds[i]), $(dts_samp[i]), $(dts_struct[i]), $(dts_comb[i])") if any([dts_samp[i], dts_struct[i], dts_comb[i]] .> tols) @error("∟ timings have exceeded linear scaling") end - + end end # @tests? end - From a9533712642fc9e619304238fc7e8f4fedbf4790 Mon Sep 17 00:00:00 2001 From: odunbar Date: Mon, 17 Nov 2025 11:03:13 -0800 Subject: [PATCH 15/32] docs manifest --- docs/Manifest.toml | 101 ++++++++++++++++++++++++++++++--------------- 1 file changed, 67 insertions(+), 34 deletions(-) diff --git a/docs/Manifest.toml b/docs/Manifest.toml index 210f1e18e..62218709e 100644 --- a/docs/Manifest.toml +++ b/docs/Manifest.toml @@ -1,8 +1,8 @@ # This file is machine-generated - editing it directly is not advised -julia_version = "1.11.5" +julia_version = "1.12.0" manifest_format = "2.0" -project_hash = "e4d965798d55f5903483b71f545533e62ea32fdf" +project_hash = "5255fc92659f2799f0f4c5144942145e13d951ed" [[deps.ADTypes]] git-tree-sha1 = "be7ae030256b8ef14a441726c4c37766b90b93a3" @@ -221,7 +221,7 @@ uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a" version = "1.18.5+0" [[deps.CalibrateEmulateSample]] -deps = ["AbstractGPs", "AbstractMCMC", "AdvancedMH", "ChunkSplitters", "Conda", "Distributions", "DocStringExtensions", "EnsembleKalmanProcesses", "ForwardDiff", "GaussianProcesses", "KernelFunctions", "LinearAlgebra", "MCMCChains", "Pkg", "Printf", "ProgressBars", "PyCall", "Random", "RandomFeatures", "ReverseDiff", "ScikitLearn", "StableRNGs", "Statistics", "StatsBase"] +deps = ["AbstractGPs", "AbstractMCMC", "AdvancedMH", "ChunkSplitters", "Conda", "Distributions", "DocStringExtensions", "EnsembleKalmanProcesses", "ForwardDiff", "GaussianProcesses", "KernelFunctions", "LinearAlgebra", "LinearMaps", "LowRankApprox", "MCMCChains", "Pkg", "Printf", "ProgressBars", "PyCall", "Random", "RandomFeatures", "ReverseDiff", "ScikitLearn", "StableRNGs", "Statistics", "StatsBase", "TSVD"] path = ".." uuid = "95e48a1f-0bec-4818-9538-3db4340308e3" version = "0.7.0" @@ -283,7 +283,7 @@ weakdeps = ["Dates", "LinearAlgebra"] [[deps.CompilerSupportLibraries_jll]] deps = ["Artifacts", "Libdl"] uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" -version = "1.1.1+0" +version = "1.3.0+1" [[deps.CompositionsBase]] git-tree-sha1 = "802bb88cd69dfd1509f6670416bd4434015693ad" @@ -790,6 +790,11 @@ version = "1.14.3" [deps.JSON3.weakdeps] ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" +[[deps.JuliaSyntaxHighlighting]] +deps = ["StyledStrings"] +uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" +version = "1.12.0" + [[deps.KernelDensity]] deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"] git-tree-sha1 = "7d703202e65efa1369de1279c162b915e245eed1" @@ -859,24 +864,24 @@ uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" version = "0.6.4" [[deps.LibCURL_jll]] -deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll", "Zlib_jll", "nghttp2_jll"] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "OpenSSL_jll", "Zlib_jll", "nghttp2_jll"] uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" -version = "8.6.0+0" +version = "8.11.1+1" [[deps.LibGit2]] -deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" version = "1.11.0" [[deps.LibGit2_jll]] -deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "OpenSSL_jll"] uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" -version = "1.7.2+0" +version = "1.9.0+0" [[deps.LibSSH2_jll]] -deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +deps = ["Artifacts", "Libdl", "OpenSSL_jll"] uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" -version = "1.11.0+1" +version = "1.11.3+1" [[deps.Libdl]] uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" @@ -915,7 +920,19 @@ version = "7.4.0" [[deps.LinearAlgebra]] deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" -version = "1.11.0" +version = "1.12.0" + +[[deps.LinearMaps]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "7f6be2e4cdaaf558623d93113d6ddade7b916209" +uuid = "7a12625a-238d-50fd-b39a-03d52299707e" +version = "3.11.4" +weakdeps = ["ChainRulesCore", "SparseArrays", "Statistics"] + + [deps.LinearMaps.extensions] + LinearMapsChainRulesCoreExt = "ChainRulesCore" + LinearMapsSparseArraysExt = "SparseArrays" + LinearMapsStatisticsExt = "Statistics" [[deps.LogDensityProblems]] deps = ["ArgCheck", "DocStringExtensions", "Random"] @@ -960,6 +977,22 @@ weakdeps = ["ChainRulesCore", "ForwardDiff", "SpecialFunctions"] ForwardDiffExt = ["ChainRulesCore", "ForwardDiff"] SpecialFunctionsExt = "SpecialFunctions" +[[deps.LowRankApprox]] +deps = ["FFTW", "LinearAlgebra", "LowRankMatrices", "Nullables", "Random", "SparseArrays"] +git-tree-sha1 = "031af63ba945e23424815014ba0e59c28f5aed32" +uuid = "898213cb-b102-5a47-900c-97e73b919f73" +version = "0.5.5" + +[[deps.LowRankMatrices]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "59c5bb0708be6796604caec16d4357013dc3d132" +uuid = "e65ccdef-c354-471a-8090-89bec1c20ec3" +version = "1.0.2" +weakdeps = ["FillArrays"] + + [deps.LowRankMatrices.extensions] + LowRankMatricesFillArraysExt = "FillArrays" + [[deps.MCMCChains]] deps = ["AbstractMCMC", "AxisArrays", "Dates", "Distributions", "Formatting", "IteratorInterfaceExtensions", "KernelDensity", "LinearAlgebra", "MCMCDiagnosticTools", "MLJModelInterface", "NaturalSort", "OrderedCollections", "PrettyTables", "Random", "RecipesBase", "Serialization", "Statistics", "StatsBase", "StatsFuns", "TableTraits", "Tables"] git-tree-sha1 = "c659f7508035a7bdd5102aef2de028ab035f289a" @@ -995,7 +1028,7 @@ uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" version = "0.1.8" [[deps.Markdown]] -deps = ["Base64"] +deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" version = "1.11.0" @@ -1011,11 +1044,6 @@ git-tree-sha1 = "2f2c18c6acab9042557bdb0af8c3a14dd7b64413" uuid = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" version = "1.41.0" -[[deps.MbedTLS_jll]] -deps = ["Artifacts", "Libdl"] -uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" -version = "2.28.6+0" - [[deps.MicroCollections]] deps = ["BangBang", "InitialValues", "Setfield"] git-tree-sha1 = "629afd7d10dbc6935ec59b32daeb33bc4460a42e" @@ -1034,7 +1062,7 @@ version = "1.11.0" [[deps.MozillaCACerts_jll]] uuid = "14a3606d-f60d-562e-9121-12d972cd8159" -version = "2023.12.12" +version = "2025.5.20" [[deps.MutableArithmetics]] deps = ["LinearAlgebra", "SparseArrays", "Test"] @@ -1061,7 +1089,12 @@ version = "1.0.0" [[deps.NetworkOptions]] uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" -version = "1.2.0" +version = "1.3.0" + +[[deps.Nullables]] +git-tree-sha1 = "8f87854cc8f3685a60689d8edecaa29d2251979b" +uuid = "4d1e1d77-625e-5b40-9113-a560ec7a8ecd" +version = "1.0.0" [[deps.OffsetArrays]] git-tree-sha1 = "117432e406b5c023f665fa73dc26e79ec3630151" @@ -1087,12 +1120,12 @@ version = "0.3.29+0" [[deps.OpenBLAS_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" -version = "0.3.27+1" +version = "0.3.29+0" [[deps.OpenLibm_jll]] deps = ["Artifacts", "Libdl"] uuid = "05823500-19ac-5b8b-9628-191a04bc5112" -version = "0.8.5+0" +version = "0.8.7+0" [[deps.OpenSSH_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "OpenSSL_jll", "Zlib_jll"] @@ -1101,8 +1134,7 @@ uuid = "9bd350c2-7e96-507f-8002-3f2e150b4e1b" version = "10.0.1+0" [[deps.OpenSSL_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "87510f7292a2b21aeff97912b0898f9553cc5c2c" +deps = ["Artifacts", "Libdl"] uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" version = "3.5.1+0" @@ -1136,7 +1168,7 @@ version = "1.8.1" [[deps.PCRE2_jll]] deps = ["Artifacts", "Libdl"] uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" -version = "10.42.0+1" +version = "10.44.0+1" [[deps.PDMats]] deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] @@ -1165,7 +1197,7 @@ version = "0.44.2+0" [[deps.Pkg]] deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"] uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" -version = "1.11.0" +version = "1.12.0" weakdeps = ["REPL"] [deps.Pkg.extensions] @@ -1213,6 +1245,7 @@ uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" version = "1.11.0" [[deps.Profile]] +deps = ["StyledStrings"] uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" version = "1.11.0" @@ -1258,7 +1291,7 @@ version = "2.11.2" Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" [[deps.REPL]] -deps = ["InteractiveUtils", "Markdown", "Sockets", "StyledStrings", "Unicode"] +deps = ["InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" version = "1.11.0" @@ -1417,7 +1450,7 @@ version = "1.2.1" [[deps.SparseArrays]] deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] uuid = "2f01184e-e22b-5df5-ae63-d93ebab69eaf" -version = "1.11.0" +version = "1.12.0" [[deps.SpecialFunctions]] deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] @@ -1531,7 +1564,7 @@ uuid = "4607b0f0-06f3-5cda-b6b1-a6196a1729e9" [[deps.SuiteSparse_jll]] deps = ["Artifacts", "Libdl", "libblastrampoline_jll"] uuid = "bea87d4a-7f5b-5778-9afe-8cc45184846c" -version = "7.7.0+0" +version = "7.8.3+2" [[deps.TOML]] deps = ["Dates"] @@ -1703,7 +1736,7 @@ version = "1.6.0+0" [[deps.Zlib_jll]] deps = ["Libdl"] uuid = "83775a58-1f1d-513f-b197-d71354ab007a" -version = "1.2.13+1" +version = "1.3.1+2" [[deps.ZygoteRules]] deps = ["ChainRulesCore", "MacroTools"] @@ -1726,7 +1759,7 @@ version = "0.15.2+0" [[deps.libblastrampoline_jll]] deps = ["Artifacts", "Libdl"] uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" -version = "5.11.0+0" +version = "5.13.1+1" [[deps.libfdk_aac_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] @@ -1749,10 +1782,10 @@ version = "1.3.8+0" [[deps.nghttp2_jll]] deps = ["Artifacts", "Libdl"] uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" -version = "1.59.0+0" +version = "1.64.0+1" [[deps.oneTBB_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] git-tree-sha1 = "d5a767a3bb77135a99e433afe0eb14cd7f6914c3" uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" version = "2022.0.0+0" @@ -1760,7 +1793,7 @@ version = "2022.0.0+0" [[deps.p7zip_jll]] deps = ["Artifacts", "Libdl"] uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" -version = "17.4.0+2" +version = "17.5.0+2" [[deps.x264_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] From 2c51306ce0ddbd1e44398566fc1072359f61e746 Mon Sep 17 00:00:00 2001 From: odunbar Date: Mon, 17 Nov 2025 12:24:30 -0800 Subject: [PATCH 16/32] MCMC test coverage, using observations --- src/MarkovChainMonteCarlo.jl | 9 ++++ test/MarkovChainMonteCarlo/runtests.jl | 70 +++++++++++++++++--------- 2 files changed, 55 insertions(+), 24 deletions(-) diff --git a/src/MarkovChainMonteCarlo.jl b/src/MarkovChainMonteCarlo.jl index ac509a184..fe7475e3b 100644 --- a/src/MarkovChainMonteCarlo.jl +++ b/src/MarkovChainMonteCarlo.jl @@ -33,6 +33,8 @@ export EmulatorPosteriorModel, accept_ratio, optimize_stepsize, get_posterior, + get_sample_kwargs, + get_init_params, sample, esjd @@ -518,6 +520,13 @@ struct MCMCWrapper{AVV <: AbstractVector, AV <: AbstractVector} sample_kwargs::NamedTuple end +""" +$(TYPEDSIGNATURES) + +gets the NameTuple of keywords that are passed into the Sampler algorithm +""" +get_sample_kwargs(mcmc::MCMCWrapper) = mcmc.sample_kwargs + """ $(DocStringExtensions.TYPEDSIGNATURES) diff --git a/test/MarkovChainMonteCarlo/runtests.jl b/test/MarkovChainMonteCarlo/runtests.jl index 7546c8718..dd7844136 100644 --- a/test/MarkovChainMonteCarlo/runtests.jl +++ b/test/MarkovChainMonteCarlo/runtests.jl @@ -4,6 +4,7 @@ using Distributions using GaussianProcesses using Test +using CalibrateEmulateSample.EnsembleKalmanProcesses using CalibrateEmulateSample.MarkovChainMonteCarlo const MCMC = MarkovChainMonteCarlo using CalibrateEmulateSample.ParameterDistributions @@ -242,6 +243,7 @@ function mcmc_test_template( prior::ParameterDistribution, σ2_y, em::Emulator; + extra_tests = false, exp_name = "test", mcmc_alg = RWMHSampling(), obs_sample = [1.0], @@ -251,11 +253,17 @@ function mcmc_test_template( target_acc = 0.25, return_samples = false, ) - if !isa(obs_sample, AbstractVecOrMat) + if isa(obs_sample, Real) obs_sample = reshape(collect(obs_sample), 1) # scalar -> Vector end init_params = vec(collect(init_params)) # scalar or Vector -> Vector + if extra_tests + mcmc = MCMCWrapper(mcmc_alg, obs_sample, prior, em) # without ICs + + @test all(isapprox.(getfield(get_sample_kwargs(mcmc), :init_params), mean(prior))) + end + mcmc = MCMCWrapper(mcmc_alg, obs_sample, prior, em; init_params = init_params) # First let's run a short chain to determine a good step size new_step = optimize_stepsize(mcmc; init_stepsize = step, N = 5000, target_acc = target_acc) @@ -301,7 +309,7 @@ end # mcmc setup mcmc_params = Dict( :mcmc_alg => RWMHSampling(), - :obs_sample => obs_sample, + :obs_sample => Observation(Dict("samples" => obs_sample, "covariances" => 1.0 * I, "names" => "test")), :init_params => transform_constrained_to_unconstrained(prior, [2.0]), :step => 0.25, :rng => rng, @@ -373,7 +381,7 @@ end # test various MCMC methods new_step_1, posterior_mean_1, chain_1 = - mcmc_test_template(prior, σ2_y, em_1; exp_name = "gpjl_1d", mcmc_params...) + mcmc_test_template(prior, σ2_y, em_1; extra_tests = true, exp_name = "gpjl_1d", mcmc_params...) esjd1 = esjd(chain_1) @info "ESJD [GPJL,RW] = $esjd1" @test isapprox(new_step_1, 0.125; atol = 0.125) @@ -415,30 +423,44 @@ end @info "Posterior mean: $(posterior_mean_2) ≈ $(mle)" # test with many slightly different samples - # as vec of vec - obs_sample2 = [obs_sample + 0.01 * randn(length(obs_sample)) for i in 1:100] - mcmc_params2 = deepcopy(mcmc_params) - mcmc_params2[:obs_sample] = obs_sample2 - mcmc_params2[:step] = 0.025 # less uncertainty -> smaller step - new_step, posterior_mean_1 = mcmc_test_template(prior, σ2_y, em_1; exp_name = "gpjl-samples", mcmc_params2...) - @test isapprox(new_step, 0.025; atol = 0.025) - # difference between mean_1 and ground truth comes from MCMC convergence and GP sampling - esjd2 = esjd(chain_2) - @info "ESJD (-many-samples)= $esjd2" - @info "Posterior mean: $(posterior_mean_1) ≈ $(mle)" - @test isapprox(posterior_mean_1, mle; atol = 2e-1) + obs_sample_vecs = [] + exp_vec_names = [] + # as a vec of vec + obs_sample2 = [obs_sample + 0.01 * randn(length(obs_sample)) for i in 1:100] + push!(exp_vec_names, "gpjl-samples-mat") + push!(obs_sample_vecs, obs_sample2) - # as column matrix + # as a column mat obs_sample2mat = reduce(hcat, obs_sample2) - mcmc_params2mat = deepcopy(mcmc_params) - mcmc_params2mat[:obs_sample] = obs_sample2mat - new_step, posterior_mean_1 = - mcmc_test_template(prior, σ2_y, em_1; exp_name = "gpjl-samples-mat", mcmc_params2mat...) - @test isapprox(new_step, 0.025; atol = 0.025) - # difference between mean_1 and ground truth comes from MCMC convergence and GP sampling - @info "Posterior mean: $(posterior_mean_1) ≈ $(mle)" - @test isapprox(posterior_mean_1, mle; atol = 2e-1) + push!(obs_sample_vecs, obs_sample2mat) + push!(exp_vec_names, "gpjl-samples") + + # as an observation series + obs_vec = [] + for i in 1:100 + ob = Observation( + Dict("samples" => obs_sample + 0.01 * randn(length(obs_sample)), "covariances" => I, "names" => "test"), + ) + push!(obs_vec, ob) + end + obs_series = ObservationSeries(obs_vec) + push!(obs_sample_vecs, obs_series) + push!(exp_vec_names, "gpjl-samples-series") + + # run tests... + for (os, exp_name) in zip(obs_sample_vecs, exp_vec_names) + mcmc_params2 = deepcopy(mcmc_params) + mcmc_params2[:obs_sample] = os + mcmc_params2[:step] = 0.025 # less uncertainty -> smaller step + new_step, posterior_mean_1 = mcmc_test_template(prior, σ2_y, em_1; exp_name = exp_name, mcmc_params2...) + @test isapprox(new_step, 0.025; atol = 0.025) + # difference between mean_1 and ground truth comes from MCMC convergence and GP sampling + esjd2 = esjd(chain_2) + @info "ESJD (vec:$(exp_name))= $esjd2" + @info "Posterior mean: $(posterior_mean_1) ≈ $(mle)" + @test isapprox(posterior_mean_1, mle; atol = 2e-1) + end # test with integer data obs_sample3 = [4] From e0f125e4d49444b1ee34a64bec4f348d9ac5e367 Mon Sep 17 00:00:00 2001 From: odunbar Date: Mon, 17 Nov 2025 13:32:30 -0800 Subject: [PATCH 17/32] add tests for encoder_kwargs_from --- src/MarkovChainMonteCarlo.jl | 4 ++-- src/Utilities.jl | 43 ++++++++++++++++++++++-------------- test/Utilities/runtests.jl | 24 ++++++++++++++++++++ 3 files changed, 53 insertions(+), 18 deletions(-) diff --git a/src/MarkovChainMonteCarlo.jl b/src/MarkovChainMonteCarlo.jl index fe7475e3b..e8688b266 100644 --- a/src/MarkovChainMonteCarlo.jl +++ b/src/MarkovChainMonteCarlo.jl @@ -606,7 +606,7 @@ function MCMCWrapper( prior::PD, em::EM; kwargs..., -) where {AV <: AbstractVector, OB <: Observation, PD <: ParameterDistribution, EM <: Emulator} +) where {OB <: Observation, PD <: ParameterDistribution, EM <: Emulator} return MCMCWrapper(mcmc_alg, get_obs(observation), prior, em; kwargs...) end @@ -616,7 +616,7 @@ function MCMCWrapper( prior::PD, em::EM; kwargs..., -) where {AV <: AbstractVector, OS <: ObservationSeries, PD <: ParameterDistribution, EM <: Emulator} +) where {OS <: ObservationSeries, PD <: ParameterDistribution, EM <: Emulator} observations = [get_obs(ob) for ob in get_observations(observation_series)] return MCMCWrapper(mcmc_alg, observations, prior, em; kwargs...) end diff --git a/src/Utilities.jl b/src/Utilities.jl index bc26c4582..0fbaf2587 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -27,7 +27,8 @@ export create_encoder_schedule, encode_structure_matrix, decode_data, decode_structure_matrix, - norm + norm, + encoder_kwargs_from const StructureMatrix = Union{UniformScaling, AbstractMatrix, AbstractVector, LinearMap} # The vector appears due to possible block-structured matrices (build=false) @@ -71,32 +72,42 @@ end # Using Observation Objects: +""" +$(TYPEDSIGNATURES) + +Extracts the relevant encoder kwargs from the observation as a NamedTuple. Contains, +- `:obs_noise_cov` as (unbuilt) noise covariance +- `:observation` as obs vector +""" function encoder_kwargs_from(obs::OB) where {OB <: Observation} - return (obs_noise_cov = get_covs(obs, build = false), observation = get_obs(obs)) + return (; obs_noise_cov = get_obs_noise_cov(obs, build = false), observation = get_obs(obs)) end -function encoder_kwargs_from(os::OS) where {OS <: ObservationSeries} - obs_vec = get_observations(os) - return [encoder_kwargs_from(obs) for obs in obs_vec] -end +""" +$(TYPEDSIGNATURES) -function encoder_kwargs_from(prior::PD; rng = Random.default_rng(), n_samples = 100) where {PD <: ParameterDistribution} - return (prior_cov = cov(prior), prior_samples_in = sample(rng, prior, n_samples)) +Extracts the relevant encoder kwargs from the ObservationSeries as a NamedTuple. Assumes the same noise covariance for all observation vectors. Contains, +- `:obs_noise_cov` as (unbuilt) noise covariance of FIRST observation +- `:observation` as obs vector from all observations +""" +function encoder_kwargs_from(os::OS) where {OS <: ObservationSeries} + observations = get_observations(os) + obs_vec = [get_obs(obs) for obs in observations] + obs_noise_cov = get_obs_noise_cov(observations[1], build = false) + return (; obs_noise_cov = obs_noise_cov, observation = obs_vec) end -## multiplication with observation covariance objects without building """ $(TYPEDSIGNATURES) -Left-multiply `X` by structure matrix `A` without building it (if provided in a compact form). - -This is useful when A is high dimensional and provided as an `SVD` or `SumOfCovariances` etc. object from EnsembleKalmanProcesses. +Extracts the relevant encoder kwargs from the ParameterDistribution prior. Contains, +- `:prior_cov` as prior covariance """ -function lmul_compact(A, X::AVorM) where {AVorM <: AbstractVecOrMat} - # A is presumed a vector, of (compact) matrix types. - return isa(A, AbstractVector) ? EKP.lmul_without_build(A, X) : EKP.lmul_without_build([A], X) +function encoder_kwargs_from(prior::PD) where {PD <: ParameterDistribution} + return (; prior_cov = cov(prior)) end +## multiplication with observation covariance objects without building """ $(TYPEDSIGNATURES) @@ -105,7 +116,7 @@ Produces a linear map of type `LinearMap` that can evaluates the stacked actions This compact map constructs the following form of the Linear map f: 1. get compact form svd-plus-d form "USVt + D" of the `blocks` -2. create the f via stacking `A.U * A.S * A.Vt * x[block] + A.D * x[block] for (A,block) in blocks` +2. create the f via stacking `A.U * A.S * A.Vt * xblock + A.D * xblock for (A,xblock) in (As, x)` kwargs: ------ diff --git a/test/Utilities/runtests.jl b/test/Utilities/runtests.jl index 99d70ce11..7784a969b 100644 --- a/test/Utilities/runtests.jl +++ b/test/Utilities/runtests.jl @@ -7,6 +7,7 @@ using LinearAlgebra using CalibrateEmulateSample.Utilities using CalibrateEmulateSample.EnsembleKalmanProcesses using CalibrateEmulateSample.DataContainers +using CalibrateEmulateSample.ParameterDistributions @testset "Utilities" begin @@ -49,6 +50,29 @@ end # Seed for pseudo-random number generator rng = Random.MersenneTwister(4154) + # test getting encoder kwargs from observations and series + # from prior + pd = constrained_gaussian("name", 0.0, 2.0, -10, Inf, repeat = 5) + encoder_kwargs = encoder_kwargs_from(pd) + @test isapprox(norm(encoder_kwargs.prior_cov - cov(pd)), 0, atol = 1e-12) + + # from observation + osample = [1.0, 2.0] + ocov = 4.0 * I(2) + obs = Observation(Dict("samples" => osample, "covariances" => ocov, "names" => "test")) + encoder_kwargs = encoder_kwargs_from(obs) + @test all(isapprox.(norm.(encoder_kwargs.obs_noise_cov - get_obs_noise_cov(obs, build = false)), 0.0, atol = 1e-12)) + @test all(isapprox.(encoder_kwargs.observation - get_obs(obs), 0.0, atol = 1e-12)) + + # from observation series + obs2 = Observation(Dict("samples" => osample .+ 1.0, "covariances" => 2.0 .* ocov, "names" => "test")) + obs_series = ObservationSeries([obs, obs2]) + encoder_kwargs = encoder_kwargs_from(obs_series) + @test all(isapprox.(norm.(encoder_kwargs.obs_noise_cov - get_obs_noise_cov(obs, build = false)), 0, atol = 1e-12)) + diff = encoder_kwargs.observation - [get_obs(obs), get_obs(obs2)] + @test all([all(isapprox.(dd, 0.0, atol = 1e-12)) for dd in diff]) + + # Tests for get_structure_vec and get_structure_mat structure_vecs = Dict("a" => [1, 2, 3], "b" => [4, 5, 6]) structure_mats = Dict("c" => [1 2; 3 4], "d" => [5 6; 7 8]) From 6b927ee3f555c7d61311c349f47b2caab312be8c Mon Sep 17 00:00:00 2001 From: odunbar Date: Mon, 17 Nov 2025 14:12:31 -0800 Subject: [PATCH 18/32] docs manifest --- docs/Manifest.toml | 330 ++++++++++++++++++++++++++------------------- 1 file changed, 188 insertions(+), 142 deletions(-) diff --git a/docs/Manifest.toml b/docs/Manifest.toml index 62218709e..ebe74b13a 100644 --- a/docs/Manifest.toml +++ b/docs/Manifest.toml @@ -5,9 +5,9 @@ manifest_format = "2.0" project_hash = "5255fc92659f2799f0f4c5144942145e13d951ed" [[deps.ADTypes]] -git-tree-sha1 = "be7ae030256b8ef14a441726c4c37766b90b93a3" +git-tree-sha1 = "8be2ae325471fc20b11c27bb34b518541d07dd3a" uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" -version = "1.15.0" +version = "1.19.0" [deps.ADTypes.extensions] ADTypesChainRulesCoreExt = "ChainRulesCore" @@ -60,9 +60,9 @@ version = "0.4.5" [[deps.Adapt]] deps = ["LinearAlgebra", "Requires"] -git-tree-sha1 = "f7817e2e585aa6d924fd714df1e2a84be7896c60" +git-tree-sha1 = "7e35fca2bdfba44d797c53dfe63a51fabf39bfc0" uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" -version = "4.3.0" +version = "4.4.0" weakdeps = ["SparseArrays", "StaticArrays"] [deps.Adapt.extensions] @@ -115,18 +115,19 @@ version = "3.5.1+1" [[deps.ArrayInterface]] deps = ["Adapt", "LinearAlgebra"] -git-tree-sha1 = "9606d7832795cbef89e06a550475be300364a8aa" +git-tree-sha1 = "d81ae5489e13bc03567d4fbbb06c546a5e53c857" uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" -version = "7.19.0" +version = "7.22.0" [deps.ArrayInterface.extensions] ArrayInterfaceBandedMatricesExt = "BandedMatrices" ArrayInterfaceBlockBandedMatricesExt = "BlockBandedMatrices" ArrayInterfaceCUDAExt = "CUDA" - ArrayInterfaceCUDSSExt = "CUDSS" + ArrayInterfaceCUDSSExt = ["CUDSS", "CUDA"] ArrayInterfaceChainRulesCoreExt = "ChainRulesCore" ArrayInterfaceChainRulesExt = "ChainRules" ArrayInterfaceGPUArraysCoreExt = "GPUArraysCore" + ArrayInterfaceMetalExt = "Metal" ArrayInterfaceReverseDiffExt = "ReverseDiff" ArrayInterfaceSparseArraysExt = "SparseArrays" ArrayInterfaceStaticArraysCoreExt = "StaticArraysCore" @@ -140,6 +141,7 @@ version = "7.19.0" 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" @@ -157,9 +159,9 @@ version = "1.1.0" [[deps.AxisArrays]] deps = ["Dates", "IntervalSets", "IterTools", "RangeArrays"] -git-tree-sha1 = "16351be62963a67ac4083f748fdb3cca58bfd52f" +git-tree-sha1 = "4126b08903b777c88edf1754288144a0492c05ad" uuid = "39de3d68-74b9-583c-8d2d-e117c070f3a9" -version = "0.4.7" +version = "0.4.8" [[deps.BangBang]] deps = ["Compat", "ConstructionBase", "InitialValues", "LinearAlgebra", "Requires", "Setfield", "Tables"] @@ -192,9 +194,9 @@ version = "0.1.1" [[deps.BenchmarkTools]] deps = ["Compat", "JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"] -git-tree-sha1 = "e38fbc49a620f5d0b660d7f543db1009fe0f8336" +git-tree-sha1 = "7fecfb1123b8d0232218e2da0c213004ff15358d" uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" -version = "1.6.0" +version = "1.6.3" [[deps.BitTwiddlingConvenienceFunctions]] deps = ["Static"] @@ -209,10 +211,10 @@ uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" version = "1.0.9+0" [[deps.CPUSummary]] -deps = ["CpuId", "IfElse", "PrecompileTools", "Static"] -git-tree-sha1 = "5a97e67919535d6841172016c9530fd69494e5ec" +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" -version = "0.2.6" +version = "0.2.7" [[deps.Cairo_jll]] deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"] @@ -228,9 +230,9 @@ version = "0.7.0" [[deps.ChainRulesCore]] deps = ["Compat", "LinearAlgebra"] -git-tree-sha1 = "06ee8d1aa558d2833aa799f6f0b31b30cada405f" +git-tree-sha1 = "e4c6a16e77171a5f5e25e9646617ab1c276c5607" uuid = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" -version = "1.25.2" +version = "1.26.0" weakdeps = ["SparseArrays"] [deps.ChainRulesCore.extensions] @@ -272,9 +274,9 @@ version = "1.0.0" [[deps.Compat]] deps = ["TOML", "UUIDs"] -git-tree-sha1 = "3a3dfb30697e96a440e4149c8c51bf32f818c0f3" +git-tree-sha1 = "9d8a54ce4b17aa5bdce0ea5c34bc5e7c340d16ad" uuid = "34da2185-b29b-5c13-b0c7-acf172513d20" -version = "4.17.0" +version = "4.18.1" weakdeps = ["Dates", "LinearAlgebra"] [deps.Compat.extensions] @@ -296,9 +298,9 @@ weakdeps = ["InverseFunctions"] [[deps.Conda]] deps = ["Downloads", "JSON", "VersionParsing"] -git-tree-sha1 = "b19db3927f0db4151cb86d073689f2428e524576" +git-tree-sha1 = "8f06b0cfa4c514c7b9546756dbae91fcfbc92dc9" uuid = "8f4d0f93-b110-5947-807f-2305c1781a2d" -version = "1.10.2" +version = "1.10.3" [[deps.ConsoleProgressMonitor]] deps = ["Logging", "ProgressMeter"] @@ -341,9 +343,9 @@ 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 = "fb61b4812c49343d7ef0b533ba982c46021938a6" +git-tree-sha1 = "d8928e9169ff76c6281f39a659f9bca3a573f24c" uuid = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" -version = "1.7.0" +version = "1.8.1" [[deps.DataStructures]] deps = ["Compat", "InteractiveUtils", "OrderedCollections"] @@ -380,9 +382,9 @@ version = "1.15.1" [[deps.DifferentiationInterface]] deps = ["ADTypes", "LinearAlgebra"] -git-tree-sha1 = "210933c93f39f832d92f9efbbe69a49c453db36d" +git-tree-sha1 = "80bd15222b3e8d0bc70d921d2201aa0084810ce5" uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" -version = "0.7.1" +version = "0.7.12" [deps.DifferentiationInterface.extensions] DifferentiationInterfaceChainRulesCoreExt = "ChainRulesCore" @@ -446,9 +448,9 @@ version = "1.11.0" [[deps.Distributions]] deps = ["AliasTables", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] -git-tree-sha1 = "3e6d038b77f22791b8e3472b7c633acea1ecac06" +git-tree-sha1 = "3bc002af51045ca3b47d2e1787d6ce02e68b943a" uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" -version = "0.25.120" +version = "0.25.122" [deps.Distributions.extensions] DistributionsChainRulesCoreExt = "ChainRulesCore" @@ -467,9 +469,9 @@ version = "0.9.5" [[deps.Documenter]] deps = ["ANSIColoredPrinters", "AbstractTrees", "Base64", "CodecZlib", "Dates", "DocStringExtensions", "Downloads", "Git", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "MarkdownAST", "Pkg", "PrecompileTools", "REPL", "RegistryInstances", "SHA", "TOML", "Test", "Unicode"] -git-tree-sha1 = "e25bc156a7e72f0a9f738815a4426dd01a7e914b" +git-tree-sha1 = "70c521ca3a23c576e12655d15963977c9766c26b" uuid = "e30172f5-a6a5-5a46-863b-614d45cd2de4" -version = "1.13.0" +version = "1.16.0" [[deps.Downloads]] deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] @@ -484,15 +486,21 @@ version = "1.2.12" [[deps.ElasticPDMats]] deps = ["LinearAlgebra", "MacroTools", "PDMats"] -git-tree-sha1 = "03ec11d0151e8a772b396aecd663e1c76fc8edcf" +git-tree-sha1 = "feb325f9ca96dce03ae03347ff23854205f5be3d" uuid = "2904ab23-551e-5aed-883f-487f97af5226" -version = "0.2.3" +version = "0.2.4" [[deps.EnsembleKalmanProcesses]] deps = ["Convex", "Distributions", "DocStringExtensions", "FFMPEG", "GaussianRandomFields", "Interpolations", "LinearAlgebra", "MathOptInterface", "Optim", "QuadGK", "Random", "RecipesBase", "SCS", "SparseArrays", "Statistics", "StatsBase", "TOML", "TSVD"] -git-tree-sha1 = "dd6b4b258beeef8db8024e14fea95d34305e5bb0" +git-tree-sha1 = "52faab1c57dac15c161f60f0c1d94ebb110ea3c8" uuid = "aa8a2aa5-91d8-4396-bcef-d4f2ec43552d" -version = "2.4.0" +version = "2.6.0" + + [deps.EnsembleKalmanProcesses.extensions] + EnsembleKalmanProcessesMakieExt = "Makie" + + [deps.EnsembleKalmanProcesses.weakdeps] + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" [[deps.EnumX]] git-tree-sha1 = "bddad79635af6aec424f53ed8aad5d7555dc6f00" @@ -501,27 +509,27 @@ version = "1.0.5" [[deps.Expat_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "d55dffd9ae73ff72f1c0482454dcf2ec6c6c4a63" +git-tree-sha1 = "27af30de8b5445644e8ffe3bcb0d72049c089cf1" uuid = "2e619515-83b5-522b-bb60-26c02a35a201" -version = "2.6.5+0" +version = "2.7.3+0" [[deps.FFMPEG]] deps = ["FFMPEG_jll"] -git-tree-sha1 = "53ebe7511fa11d33bec688a9178fac4e49eeee00" +git-tree-sha1 = "95ecf07c2eea562b5adbd0696af6db62c0f52560" uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" -version = "0.4.2" +version = "0.4.5" [[deps.FFMPEG_jll]] deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] -git-tree-sha1 = "466d45dc38e15794ec7d5d63ec03d776a9aff36e" +git-tree-sha1 = "ccc81ba5e42497f4e76553a5545665eed577a663" uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5" -version = "4.4.4+1" +version = "8.0.0+0" [[deps.FFTW]] -deps = ["AbstractFFTs", "FFTW_jll", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] -git-tree-sha1 = "797762812ed063b9b94f6cc7742bc8883bb5e69e" +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" -version = "1.9.0" +version = "1.10.0" [[deps.FFTW_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] @@ -541,9 +549,9 @@ version = "1.11.0" [[deps.FillArrays]] deps = ["LinearAlgebra"] -git-tree-sha1 = "6a70198746448456524cb442b8af316927ff3e1a" +git-tree-sha1 = "5bfcd42851cf2f1b303f51525a54dc5e98d408a3" uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" -version = "1.13.0" +version = "1.15.0" weakdeps = ["PDMats", "SparseArrays", "Statistics"] [deps.FillArrays.extensions] @@ -553,9 +561,9 @@ weakdeps = ["PDMats", "SparseArrays", "Statistics"] [[deps.FiniteDiff]] deps = ["ArrayInterface", "LinearAlgebra", "Setfield"] -git-tree-sha1 = "f089ab1f834470c525562030c8cfde4025d5e915" +git-tree-sha1 = "9340ca07ca27093ff68418b7558ca37b05f8aeb1" uuid = "6a86dc24-6348-571c-b903-95158fe2bd41" -version = "2.27.0" +version = "2.29.0" [deps.FiniteDiff.extensions] FiniteDiffBandedMatricesExt = "BandedMatrices" @@ -571,9 +579,9 @@ version = "2.27.0" [[deps.Fontconfig_jll]] deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Zlib_jll"] -git-tree-sha1 = "301b5d5d731a0654825f1f2e906990f7141a106b" +git-tree-sha1 = "f85dac9a96a01087df6e3a749840015a0ca3817d" uuid = "a3f928ae-7b40-5064-980b-68af3947d34b" -version = "2.16.0+0" +version = "2.17.1+0" [[deps.Formatting]] deps = ["Logging", "Printf"] @@ -583,9 +591,9 @@ version = "0.4.3" [[deps.ForwardDiff]] deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] -git-tree-sha1 = "a2df1b776752e3f344e5116c06d75a10436ab853" +git-tree-sha1 = "afb7c51ac63e40708a3071f80f5e84a752299d4f" uuid = "f6369f11-7733-5829-9624-2563aa707210" -version = "0.10.38" +version = "0.10.39" weakdeps = ["StaticArrays"] [deps.ForwardDiff.extensions] @@ -626,10 +634,10 @@ uuid = "891a1506-143c-57d2-908e-e1f8e92e6de9" version = "0.12.5" [[deps.GaussianRandomFields]] -deps = ["Arpack", "FFTW", "FastGaussQuadrature", "LinearAlgebra", "RecipesBase", "SpecialFunctions", "Statistics"] -git-tree-sha1 = "d9c335f2c06424029b2addf9abf602e0feb2f53e" +deps = ["Arpack", "FFTW", "FastGaussQuadrature", "LinearAlgebra", "Random", "RecipesBase", "SpecialFunctions", "Statistics", "StatsBase"] +git-tree-sha1 = "90f9cad110814a408c66ec7e37cfe61d579af7be" uuid = "e4b2fa32-6e09-5554-b718-106ed5adafe9" -version = "2.1.6" +version = "2.2.7" [[deps.GettextRuntime_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll"] @@ -638,22 +646,28 @@ uuid = "b0724c58-0f36-5564-988d-3bb0596ebc4a" version = "0.22.4+0" [[deps.Git]] -deps = ["Git_jll", "JLLWrappers", "OpenSSH_jll"] -git-tree-sha1 = "2230a9cc32394b11a3b3aa807a382e3bbab1198c" +deps = ["Git_LFS_jll", "Git_jll", "JLLWrappers", "OpenSSH_jll"] +git-tree-sha1 = "824a1890086880696fc908fe12a17bcf61738bd8" uuid = "d7ba0133-e1db-5d97-8f8c-041e4b3a1eb2" -version = "1.4.0" +version = "1.5.0" + +[[deps.Git_LFS_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "bb8471f313ed941f299aa53d32a94ab3bee08844" +uuid = "020c3dae-16b3-5ae5-87b3-4cb189e250b2" +version = "3.7.0+0" [[deps.Git_jll]] deps = ["Artifacts", "Expat_jll", "JLLWrappers", "LibCURL_jll", "Libdl", "Libiconv_jll", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] -git-tree-sha1 = "b981ed24de5855f20fce5b8cb767c179f93e4268" +git-tree-sha1 = "b6a684587ebe896d9f68ae777f648205940f0f70" uuid = "f8c6e375-362e-5223-8a59-34ff63f689eb" -version = "2.50.0+0" +version = "2.51.3+0" [[deps.Glib_jll]] deps = ["Artifacts", "GettextRuntime_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Zlib_jll"] -git-tree-sha1 = "35fbd0cefb04a516104b8e183ce0df11b70a3f1a" +git-tree-sha1 = "50c11ffab2a3d50192a228c313f05b5b5dc5acb2" uuid = "7746bdde-850d-59dc-9ae8-88ece973131d" -version = "2.84.3+0" +version = "2.86.0+0" [[deps.Graphite2_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] @@ -675,9 +689,9 @@ version = "0.1.17" [[deps.IOCapture]] deps = ["Logging", "Random"] -git-tree-sha1 = "b6d6bfdd7ce25b0f9b2f6b3dd56b2673a66c8770" +git-tree-sha1 = "0ee181ec08df7d7c911901ea38baf16f755114dc" uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89" -version = "0.2.5" +version = "1.0.0" [[deps.IfElse]] git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" @@ -690,9 +704,9 @@ uuid = "22cec73e-a1b8-11e9-2c92-598750a2cf9c" version = "0.3.1" [[deps.InlineStrings]] -git-tree-sha1 = "8594fac023c5ce1ef78260f24d1ad18b4327b420" +git-tree-sha1 = "8f3d257792a522b4601c24a577954b0a8cd7334d" uuid = "842dd82b-1e85-43dc-bf29-5d0ee9dffc48" -version = "1.4.4" +version = "1.4.5" [deps.InlineStrings.extensions] ArrowTypesExt = "ArrowTypes" @@ -704,9 +718,9 @@ version = "1.4.4" [[deps.IntelOpenMP_jll]] deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] -git-tree-sha1 = "0f14a5456bdc6b9731a5682f439a672750a09e48" +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" -version = "2025.0.4+0" +version = "2025.2.0+0" [[deps.InteractiveUtils]] deps = ["Markdown"] @@ -726,12 +740,13 @@ version = "0.15.1" Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" [[deps.IntervalSets]] -git-tree-sha1 = "5fbb102dcb8b1a858111ae81d56682376130517d" +git-tree-sha1 = "03b4f40b4987baa6a653a21f6f33f902af6255f3" uuid = "8197267c-284f-5f27-9208-e0e47529a953" -version = "0.7.11" -weakdeps = ["Random", "RecipesBase", "Statistics"] +version = "0.7.12" +weakdeps = ["Printf", "Random", "RecipesBase", "Statistics"] [deps.IntervalSets.extensions] + IntervalSetsPrintfExt = "Printf" IntervalSetsRandomExt = "Random" IntervalSetsRecipesBaseExt = "RecipesBase" IntervalSetsStatisticsExt = "Statistics" @@ -768,15 +783,21 @@ version = "1.0.0" [[deps.JLLWrappers]] deps = ["Artifacts", "Preferences"] -git-tree-sha1 = "a007feb38b422fbdab534406aeca1b86823cb4d6" +git-tree-sha1 = "0533e564aae234aff59ab625543145446d8b6ec2" uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" -version = "1.7.0" +version = "1.7.1" [[deps.JSON]] -deps = ["Dates", "Mmap", "Parsers", "Unicode"] -git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a" +deps = ["Dates", "Logging", "Parsers", "PrecompileTools", "StructUtils", "UUIDs", "Unicode"] +git-tree-sha1 = "5b6bb73f555bc753a6153deec3717b8904f5551c" uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" -version = "0.21.4" +version = "1.3.0" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" [[deps.JSON3]] deps = ["Dates", "Mmap", "Parsers", "PrecompileTools", "StructTypes", "UUIDs"] @@ -797,15 +818,15 @@ version = "1.12.0" [[deps.KernelDensity]] deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"] -git-tree-sha1 = "7d703202e65efa1369de1279c162b915e245eed1" +git-tree-sha1 = "ba51324b894edaf1df3ab16e2cc6bc3280a2f1a7" uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b" -version = "0.6.9" +version = "0.6.10" [[deps.KernelFunctions]] deps = ["ChainRulesCore", "Compat", "CompositionsBase", "Distances", "FillArrays", "Functors", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "Random", "Requires", "SpecialFunctions", "Statistics", "StatsBase", "TensorCore", "Test", "ZygoteRules"] -git-tree-sha1 = "0b8ef8b51580b0d87d0b7a5233bb8ea6d948feb4" +git-tree-sha1 = "0b75b447ee242254ff037402461e5593a84f9ac7" uuid = "ec8451be-7e33-11e9-00cf-bbf324bd1392" -version = "0.10.65" +version = "0.10.66" [[deps.LAME_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] @@ -854,9 +875,9 @@ version = "1.11.0" [[deps.LeftChildRightSiblingTrees]] deps = ["AbstractTrees"] -git-tree-sha1 = "fb6803dafae4a5d62ea5cab204b1e657d9737e7f" +git-tree-sha1 = "95ba48564903b43b2462318aa243ee79d81135ff" uuid = "1d6d02ad-be62-4b6b-8a6d-2f90e265016e" -version = "0.2.0" +version = "0.2.1" [[deps.LibCURL]] deps = ["LibCURL_jll", "MozillaCACerts_jll"] @@ -901,15 +922,15 @@ version = "1.18.0+0" [[deps.Libmount_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "a31572773ac1b745e0343fe5e2c8ddda7a37e997" +git-tree-sha1 = "3acf07f130a76f87c041cfb2ff7d7284ca67b072" uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9" -version = "2.41.0+0" +version = "2.41.2+0" [[deps.Libuuid_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "321ccef73a96ba828cd51f2ab5b9f917fa73945a" +git-tree-sha1 = "2a7a12fc0a4e7fb773450d17975322aa77142106" uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700" -version = "2.41.0+0" +version = "2.41.2+0" [[deps.LineSearches]] deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf"] @@ -936,9 +957,9 @@ weakdeps = ["ChainRulesCore", "SparseArrays", "Statistics"] [[deps.LogDensityProblems]] deps = ["ArgCheck", "DocStringExtensions", "Random"] -git-tree-sha1 = "4e0128c1590d23a50dcdb106c7e2dbca99df85c0" +git-tree-sha1 = "d9625f27ded4ad726ceca7819394a4cc77ed25b3" uuid = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c" -version = "2.1.2" +version = "2.2.0" [[deps.LogExpFunctions]] deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] @@ -962,21 +983,27 @@ version = "1.11.0" [[deps.LoggingExtras]] deps = ["Dates", "Logging"] -git-tree-sha1 = "f02b56007b064fbfddb4c9cd60161b6dd0f40df3" +git-tree-sha1 = "f00544d95982ea270145636c181ceda21c4e2575" uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" -version = "1.1.0" +version = "1.2.0" [[deps.LoopVectorization]] deps = ["ArrayInterface", "CPUSummary", "CloseOpenIntervals", "DocStringExtensions", "HostCPUFeatures", "IfElse", "LayoutPointers", "LinearAlgebra", "OffsetArrays", "PolyesterWeave", "PrecompileTools", "SIMDTypes", "SLEEFPirates", "Static", "StaticArrayInterface", "ThreadingUtilities", "UnPack", "VectorizationBase"] -git-tree-sha1 = "e5afce7eaf5b5ca0d444bcb4dc4fd78c54cbbac0" +git-tree-sha1 = "a9fc7883eb9b5f04f46efb9a540833d1fad974b3" uuid = "bdcacae8-1622-11e9-2a5c-532679323890" -version = "0.12.172" -weakdeps = ["ChainRulesCore", "ForwardDiff", "SpecialFunctions"] +version = "0.12.173" [deps.LoopVectorization.extensions] ForwardDiffExt = ["ChainRulesCore", "ForwardDiff"] + ForwardDiffNNlibExt = ["ForwardDiff", "NNlib"] SpecialFunctionsExt = "SpecialFunctions" + [deps.LoopVectorization.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + [[deps.LowRankApprox]] deps = ["FFTW", "LinearAlgebra", "LowRankMatrices", "Nullables", "Random", "SparseArrays"] git-tree-sha1 = "031af63ba945e23424815014ba0e59c28f5aed32" @@ -1007,15 +1034,15 @@ version = "0.2.1" [[deps.MKL_jll]] deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] -git-tree-sha1 = "5de60bc6cb3899cd318d80d627560fae2e2d99ae" +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" -version = "2025.0.1+1" +version = "2025.2.0+0" [[deps.MLJModelInterface]] -deps = ["REPL", "Random", "ScientificTypesBase", "StatisticalTraits"] -git-tree-sha1 = "66626f80d5807921045d539b4f7153b1d47c5f8a" +deps = ["InteractiveUtils", "REPL", "Random", "ScientificTypesBase", "StatisticalTraits"] +git-tree-sha1 = "ccaa3f7938890ee8042cc970ba275115428bd592" uuid = "e80e1ace-859a-464e-9ed9-23947d8ae3ea" -version = "1.11.1" +version = "1.12.0" [[deps.MacroTools]] git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" @@ -1040,9 +1067,9 @@ version = "0.1.2" [[deps.MathOptInterface]] deps = ["BenchmarkTools", "CodecBzip2", "CodecZlib", "DataStructures", "ForwardDiff", "JSON3", "LinearAlgebra", "MutableArithmetics", "NaNMath", "OrderedCollections", "PrecompileTools", "Printf", "SparseArrays", "SpecialFunctions", "Test"] -git-tree-sha1 = "2f2c18c6acab9042557bdb0af8c3a14dd7b64413" +git-tree-sha1 = "a2cbab4256690aee457d136752c404e001f27768" uuid = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" -version = "1.41.0" +version = "1.46.0" [[deps.MicroCollections]] deps = ["BangBang", "InitialValues", "Setfield"] @@ -1066,9 +1093,9 @@ version = "2025.5.20" [[deps.MutableArithmetics]] deps = ["LinearAlgebra", "SparseArrays", "Test"] -git-tree-sha1 = "491bdcdc943fcbc4c005900d7463c9f216aabf4c" +git-tree-sha1 = "22df8573f8e7c593ac205455ca088989d0a2c7a0" uuid = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" -version = "1.6.4" +version = "1.6.7" [[deps.NLSolversBase]] deps = ["ADTypes", "DifferentiationInterface", "Distributed", "FiniteDiff", "ForwardDiff"] @@ -1129,9 +1156,9 @@ version = "0.8.7+0" [[deps.OpenSSH_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "OpenSSL_jll", "Zlib_jll"] -git-tree-sha1 = "cb7acd5d10aff809b4d0191dfe1956c2edf35800" +git-tree-sha1 = "301412a644646fdc0ad67d0a87487466b491e53d" uuid = "9bd350c2-7e96-507f-8002-3f2e150b4e1b" -version = "10.0.1+0" +version = "10.2.1+0" [[deps.OpenSSL_jll]] deps = ["Artifacts", "Libdl"] @@ -1223,15 +1250,15 @@ version = "0.2.4" [[deps.PrecompileTools]] deps = ["Preferences"] -git-tree-sha1 = "5aa36f7049a63a1528fe8f7c3f2113413ffd4e1f" +git-tree-sha1 = "07a921781cab75691315adc645096ed5e370cb77" uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" -version = "1.2.1" +version = "1.3.3" [[deps.Preferences]] deps = ["TOML"] -git-tree-sha1 = "9306f6085165d270f7e3db02af26a400d580f5c6" +git-tree-sha1 = "0f27480397253da18fe2c12a4ba4eb9eb208bf3d" uuid = "21216c6a-2e73-6563-6e65-726566657250" -version = "1.4.3" +version = "1.5.0" [[deps.PrettyTables]] deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "Reexport", "StringManipulation", "Tables"] @@ -1263,9 +1290,9 @@ version = "0.1.5" [[deps.ProgressMeter]] deps = ["Distributed", "Printf"] -git-tree-sha1 = "13c5103482a8ed1536a54c08d0e742ae3dca2d42" +git-tree-sha1 = "fbb92c6c56b34e1a2c4c36058f68f332bec840e7" uuid = "92933f4c-e287-5a05-a399-4b506db050ca" -version = "1.10.4" +version = "1.11.0" [[deps.PtrArrays]] git-tree-sha1 = "1d36ef11a9aaf1e8b74dacc6a731dd1de8fd493d" @@ -1365,10 +1392,10 @@ uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" version = "0.4.3+0" [[deps.SCS]] -deps = ["MathOptInterface", "PrecompileTools", "SCS_jll", "SparseArrays"] -git-tree-sha1 = "4aed85dec0209d638c241c34160999eaaf07965a" +deps = ["LinearAlgebra", "MathOptInterface", "OpenBLAS32_jll", "PrecompileTools", "SCS_jll", "SparseArrays"] +git-tree-sha1 = "48ec3c39787bc7b278789b9af17c157ea8774dae" uuid = "c946c3f1-0d1f-5ce8-9dea-7daa1f7e2d13" -version = "2.1.0" +version = "2.4.0" [deps.SCS.extensions] SCSSCS_GPU_jllExt = ["SCS_GPU_jll"] @@ -1379,10 +1406,10 @@ version = "2.1.0" SCS_MKL_jll = "3f2553a9-4106-52be-b7dd-865123654657" [[deps.SCS_jll]] -deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl", "OpenBLAS32_jll"] -git-tree-sha1 = "902cc4e42ecca21bbd74babf899b2a5b12add323" +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl", "libblastrampoline_jll"] +git-tree-sha1 = "05d6e31efa3debae6618dabee35dbd53cf4539d8" uuid = "f4f2fc5b-1d94-523c-97ea-2ab488bedf4b" -version = "3.2.7+0" +version = "300.200.900+0" [[deps.SHA]] uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" @@ -1399,6 +1426,11 @@ git-tree-sha1 = "456f610ca2fbd1c14f5fcf31c6bfadc55e7d66e0" uuid = "476501e8-09a2-5ece-8869-fb82de89a1fa" version = "0.6.43" +[[deps.SciMLPublic]] +git-tree-sha1 = "ed647f161e8b3f2973f24979ec074e8d084f1bee" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.0.0" + [[deps.ScientificTypesBase]] git-tree-sha1 = "a8e18eb383b5ecf1b5e6fc237eb39255044fd92b" uuid = "30f210dd-8aff-4c5f-94ba-8e64358c1161" @@ -1443,9 +1475,9 @@ version = "1.11.0" [[deps.SortingAlgorithms]] deps = ["DataStructures"] -git-tree-sha1 = "66e0a8e672a0bdfca2c3f5937efb8538b9ddc085" +git-tree-sha1 = "64d974c2e6fdf07f8155b5b2ca2ffa9069b608d9" uuid = "a2af1166-a08f-5f64-846c-94a0d3cef48c" -version = "1.2.1" +version = "1.2.2" [[deps.SparseArrays]] deps = ["Libdl", "LinearAlgebra", "Random", "Serialization", "SuiteSparse_jll"] @@ -1454,9 +1486,9 @@ version = "1.12.0" [[deps.SpecialFunctions]] deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] -git-tree-sha1 = "41852b8679f78c8d8961eeadc8f62cef861a52e3" +git-tree-sha1 = "f2685b435df2613e25fc10ad8c26dddb8640f547" uuid = "276daf66-3868-5448-9aa4-cd146d93841b" -version = "2.5.1" +version = "2.6.1" weakdeps = ["ChainRulesCore"] [deps.SpecialFunctions.extensions] @@ -1470,15 +1502,15 @@ version = "0.1.15" [[deps.StableRNGs]] deps = ["Random"] -git-tree-sha1 = "95af145932c2ed859b63329952ce8d633719f091" +git-tree-sha1 = "4f96c596b8c8258cc7d3b19797854d368f243ddc" uuid = "860ef19b-820b-49d6-a774-d7a799459cd3" -version = "1.0.3" +version = "1.0.4" [[deps.Static]] -deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools"] -git-tree-sha1 = "f737d444cb0ad07e61b3c1bef8eb91203c321eff" +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "49440414711eddc7227724ae6e570c7d5559a086" uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" -version = "1.2.0" +version = "1.3.1" [[deps.StaticArrayInterface]] deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "Static"] @@ -1493,9 +1525,9 @@ weakdeps = ["OffsetArrays", "StaticArrays"] [[deps.StaticArrays]] deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] -git-tree-sha1 = "0feb6b9031bd5c51f9072393eb5ab3efd31bf9e4" +git-tree-sha1 = "b8693004b385c842357406e3af647701fe783f98" uuid = "90137ffa-7385-5640-81b9-e52037218182" -version = "1.9.13" +version = "1.9.15" weakdeps = ["ChainRulesCore", "Statistics"] [deps.StaticArrays.extensions] @@ -1503,15 +1535,15 @@ weakdeps = ["ChainRulesCore", "Statistics"] StaticArraysStatisticsExt = "Statistics" [[deps.StaticArraysCore]] -git-tree-sha1 = "192954ef1208c7019899fbf8049e717f92959682" +git-tree-sha1 = "6ab403037779dae8c514bad259f32a447262455a" uuid = "1e83bf80-4336-4d27-bf5d-d5a4f845583c" -version = "1.4.3" +version = "1.4.4" [[deps.StatisticalTraits]] deps = ["ScientificTypesBase"] -git-tree-sha1 = "542d979f6e756f13f862aa00b224f04f9e445f11" +git-tree-sha1 = "89f86d9376acd18a1a4fbef66a56335a3a7633b8" uuid = "64bff920-2084-43da-a3e6-9bb72801c0c9" -version = "3.4.0" +version = "3.5.0" [[deps.Statistics]] deps = ["LinearAlgebra"] @@ -1553,6 +1585,20 @@ git-tree-sha1 = "159331b30e94d7b11379037feeb9b690950cace8" uuid = "856f2bd8-1eba-4b0a-8007-ebc267875bd4" version = "1.11.0" +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "79529b493a44927dd5b13dde1c7ce957c2d049e4" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.6.0" + + [deps.StructUtils.extensions] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + [[deps.StyledStrings]] uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" version = "1.11.0" @@ -1676,9 +1722,9 @@ version = "1.11.0" [[deps.VectorizationBase]] deps = ["ArrayInterface", "CPUSummary", "HostCPUFeatures", "IfElse", "LayoutPointers", "Libdl", "LinearAlgebra", "SIMDTypes", "Static", "StaticArrayInterface"] -git-tree-sha1 = "4ab62a49f1d8d9548a1c8d1a75e5f55cf196f64e" +git-tree-sha1 = "d1d9a935a26c475ebffd54e9c7ad11627c43ea85" uuid = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f" -version = "0.21.71" +version = "0.21.72" [[deps.VersionParsing]] git-tree-sha1 = "58d6e80b4ee071f5efd07fda82cb9fbe17200868" @@ -1746,15 +1792,15 @@ version = "0.2.7" [[deps.libaom_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "522c1df09d05a71785765d19c9524661234738e9" +git-tree-sha1 = "371cc681c00a3ccc3fbc5c0fb91f58ba9bec1ecf" uuid = "a4ae2306-e953-59d6-aa16-d00cac43593b" -version = "3.11.0+0" +version = "3.13.1+0" [[deps.libass_jll]] deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Zlib_jll"] -git-tree-sha1 = "e17c115d55c5fbb7e52ebedb427a0dca79d4484e" +git-tree-sha1 = "125eedcb0a4a0bba65b657251ce1d27c8714e9d6" uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" -version = "0.15.2+0" +version = "0.17.4+0" [[deps.libblastrampoline_jll]] deps = ["Artifacts", "Libdl"] @@ -1786,9 +1832,9 @@ version = "1.64.0+1" [[deps.oneTBB_jll]] deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] -git-tree-sha1 = "d5a767a3bb77135a99e433afe0eb14cd7f6914c3" +git-tree-sha1 = "1350188a69a6e46f799d3945beef36435ed7262f" uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" -version = "2022.0.0+0" +version = "2022.0.0+1" [[deps.p7zip_jll]] deps = ["Artifacts", "Libdl"] @@ -1796,13 +1842,13 @@ uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" version = "17.5.0+2" [[deps.x264_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "4fea590b89e6ec504593146bf8b988b2c00922b2" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "14cc7083fc6dff3cc44f2bc435ee96d06ed79aa7" uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a" -version = "2021.5.5+0" +version = "10164.0.1+0" [[deps.x265_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] -git-tree-sha1 = "ee567a171cce03570d77ad3a43e90218e38937a9" +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e7b67590c14d487e734dcb925924c5dc43ec85f3" uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76" -version = "3.5.0+0" +version = "4.1.0+0" From 969e0c2a6ab33af765932849ab8c17456bab3d11 Mon Sep 17 00:00:00 2001 From: odunbar Date: Mon, 17 Nov 2025 14:53:20 -0800 Subject: [PATCH 19/32] rm docs manifest --- docs/Manifest.toml | 1854 -------------------------------------------- 1 file changed, 1854 deletions(-) delete mode 100644 docs/Manifest.toml diff --git a/docs/Manifest.toml b/docs/Manifest.toml deleted file mode 100644 index ebe74b13a..000000000 --- a/docs/Manifest.toml +++ /dev/null @@ -1,1854 +0,0 @@ -# This file is machine-generated - editing it directly is not advised - -julia_version = "1.12.0" -manifest_format = "2.0" -project_hash = "5255fc92659f2799f0f4c5144942145e13d951ed" - -[[deps.ADTypes]] -git-tree-sha1 = "8be2ae325471fc20b11c27bb34b518541d07dd3a" -uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" -version = "1.19.0" - - [deps.ADTypes.extensions] - ADTypesChainRulesCoreExt = "ChainRulesCore" - ADTypesConstructionBaseExt = "ConstructionBase" - ADTypesEnzymeCoreExt = "EnzymeCore" - - [deps.ADTypes.weakdeps] - ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" - ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9" - EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" - -[[deps.AMD]] -deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse_jll"] -git-tree-sha1 = "45a1272e3f809d36431e57ab22703c6896b8908f" -uuid = "14f7f29c-3bd6-536c-9a0b-7339e30b5a3e" -version = "0.5.3" - -[[deps.ANSIColoredPrinters]] -git-tree-sha1 = "574baf8110975760d391c710b6341da1afa48d8c" -uuid = "a4c015fc-c6ff-483c-b24f-f7ea428134e9" -version = "0.0.1" - -[[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.AbstractGPs]] -deps = ["ChainRulesCore", "Distributions", "FillArrays", "IrrationalConstants", "KernelFunctions", "LinearAlgebra", "PDMats", "Random", "RecipesBase", "Reexport", "Statistics", "StatsBase", "Test"] -git-tree-sha1 = "8a05cefb7c891378c89576bd4865f34d010c9ece" -uuid = "99985d1d-32ba-4be9-9821-2ec096f28918" -version = "0.5.24" - -[[deps.AbstractMCMC]] -deps = ["BangBang", "ConsoleProgressMonitor", "Distributed", "LogDensityProblems", "Logging", "LoggingExtras", "ProgressLogging", "Random", "StatsBase", "TerminalLoggers", "Transducers"] -git-tree-sha1 = "87e63dcb990029346b091b170252f3c416568afc" -uuid = "80f14c24-f653-4e6a-9b94-39d6b0f70001" -version = "4.4.2" - -[[deps.AbstractTrees]] -git-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177" -uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" -version = "0.4.5" - -[[deps.Adapt]] -deps = ["LinearAlgebra", "Requires"] -git-tree-sha1 = "7e35fca2bdfba44d797c53dfe63a51fabf39bfc0" -uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" -version = "4.4.0" -weakdeps = ["SparseArrays", "StaticArrays"] - - [deps.Adapt.extensions] - AdaptSparseArraysExt = "SparseArrays" - AdaptStaticArraysExt = "StaticArrays" - -[[deps.AdvancedMH]] -deps = ["AbstractMCMC", "Distributions", "FillArrays", "LinearAlgebra", "LogDensityProblems", "Random", "Requires"] -git-tree-sha1 = "b2a1602952739e589cf5e2daff1274a49f22c9a4" -uuid = "5b7e9947-ddc0-4b3f-9b55-0d8042f74170" -version = "0.7.5" - - [deps.AdvancedMH.extensions] - AdvancedMHForwardDiffExt = ["DiffResults", "ForwardDiff"] - AdvancedMHMCMCChainsExt = "MCMCChains" - AdvancedMHStructArraysExt = "StructArrays" - - [deps.AdvancedMH.weakdeps] - DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" - ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" - MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" - StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" - -[[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.2" - -[[deps.Arpack]] -deps = ["Arpack_jll", "Libdl", "LinearAlgebra", "Logging"] -git-tree-sha1 = "9b9b347613394885fd1c8c7729bfc60528faa436" -uuid = "7d9fca2a-8960-54d3-9f78-7d1dccf2cb97" -version = "0.5.4" - -[[deps.Arpack_jll]] -deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "OpenBLAS_jll", "Pkg"] -git-tree-sha1 = "5ba6c757e8feccf03a1554dfaf3e26b3cfc7fd5e" -uuid = "68821587-b530-5797-8361-c406ea357684" -version = "3.5.1+1" - -[[deps.ArrayInterface]] -deps = ["Adapt", "LinearAlgebra"] -git-tree-sha1 = "d81ae5489e13bc03567d4fbbb06c546a5e53c857" -uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" -version = "7.22.0" - - [deps.ArrayInterface.extensions] - 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] - 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" -version = "1.11.0" - -[[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 = ["Compat", "ConstructionBase", "InitialValues", "LinearAlgebra", "Requires", "Setfield", "Tables"] -git-tree-sha1 = "7aa7ad1682f3d5754e3491bb59b8103cae28e3a3" -uuid = "198e06fe-97b7-11e9-32a5-e1d131e6ad66" -version = "0.3.40" - - [deps.BangBang.extensions] - BangBangChainRulesCoreExt = "ChainRulesCore" - BangBangDataFramesExt = "DataFrames" - BangBangStaticArraysExt = "StaticArrays" - BangBangStructArraysExt = "StructArrays" - 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" - TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" - -[[deps.Base64]] -uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" -version = "1.11.0" - -[[deps.Baselet]] -git-tree-sha1 = "aebf55e6d7795e02ca500a689d326ac979aaf89e" -uuid = "9718e550-a3fa-408a-8086-8db961cd8217" -version = "0.1.1" - -[[deps.BenchmarkTools]] -deps = ["Compat", "JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"] -git-tree-sha1 = "7fecfb1123b8d0232218e2da0c213004ff15358d" -uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" -version = "1.6.3" - -[[deps.BitTwiddlingConvenienceFunctions]] -deps = ["Static"] -git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" -uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" -version = "0.1.6" - -[[deps.Bzip2_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "1b96ea4a01afe0ea4090c5c8039690672dd13f2e" -uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" -version = "1.0.9+0" - -[[deps.CPUSummary]] -deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] -git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" -uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" -version = "0.2.7" - -[[deps.Cairo_jll]] -deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"] -git-tree-sha1 = "fde3bf89aead2e723284a8ff9cdf5b551ed700e8" -uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a" -version = "1.18.5+0" - -[[deps.CalibrateEmulateSample]] -deps = ["AbstractGPs", "AbstractMCMC", "AdvancedMH", "ChunkSplitters", "Conda", "Distributions", "DocStringExtensions", "EnsembleKalmanProcesses", "ForwardDiff", "GaussianProcesses", "KernelFunctions", "LinearAlgebra", "LinearMaps", "LowRankApprox", "MCMCChains", "Pkg", "Printf", "ProgressBars", "PyCall", "Random", "RandomFeatures", "ReverseDiff", "ScikitLearn", "StableRNGs", "Statistics", "StatsBase", "TSVD"] -path = ".." -uuid = "95e48a1f-0bec-4818-9538-3db4340308e3" -version = "0.7.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.ChunkSplitters]] -git-tree-sha1 = "63a3903063d035260f0f6eab00f517471c5dc784" -uuid = "ae650224-84b6-46f8-82ea-d812ca08434e" -version = "3.1.2" - -[[deps.CloseOpenIntervals]] -deps = ["Static", "StaticArrayInterface"] -git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" -uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" -version = "0.1.13" - -[[deps.CodecBzip2]] -deps = ["Bzip2_jll", "TranscodingStreams"] -git-tree-sha1 = "84990fa864b7f2b4901901ca12736e45ee79068c" -uuid = "523fee87-0ab8-5b00-afb7-3ecf72e48cfd" -version = "0.8.5" - -[[deps.CodecZlib]] -deps = ["TranscodingStreams", "Zlib_jll"] -git-tree-sha1 = "962834c22b66e32aa10f7611c08c8ca4e20749a9" -uuid = "944b1d66-785c-5afd-91f1-9de20f533193" -version = "0.7.8" - -[[deps.CommonSubexpressions]] -deps = ["MacroTools"] -git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5" -uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" -version = "0.3.1" - -[[deps.CommonWorldInvalidations]] -git-tree-sha1 = "ae52d1c52048455e85a387fbee9be553ec2b68d0" -uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" -version = "1.0.0" - -[[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.3.0+1" - -[[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.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.Convex]] -deps = ["AbstractTrees", "BenchmarkTools", "LDLFactorizations", "LinearAlgebra", "MathOptInterface", "OrderedCollections", "SparseArrays", "Test"] -git-tree-sha1 = "dec769959be3af9ba94970b1f14b31c196b0fb9e" -uuid = "f65535da-76fb-5f13-bab9-19810c17039a" -version = "0.16.4" - -[[deps.CpuId]] -deps = ["Markdown"] -git-tree-sha1 = "fcbb72b032692610bfbdb15018ac16a36cf2e406" -uuid = "adafc99b-e345-5852-983c-f28acb93d879" -version = "0.3.1" - -[[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 = ["Compat", "InteractiveUtils", "OrderedCollections"] -git-tree-sha1 = "4e1fe97fdaed23e9dc21d4d664bea76b65fc50a0" -uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" -version = "0.18.22" - -[[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" -version = "1.11.0" - -[[deps.DefineSingletons]] -git-tree-sha1 = "0fba8b706d0178b4dc7fd44a96a92382c9065c2c" -uuid = "244e2a9f-e319-4986-a169-4d1fe445cd52" -version = "0.1.2" - -[[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 = "80bd15222b3e8d0bc70d921d2201aa0084810ce5" -uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" -version = "0.7.12" - - [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.Distances]] -deps = ["LinearAlgebra", "Statistics", "StatsAPI"] -git-tree-sha1 = "c7e3a542b999843086e2f29dac96a618c105be1d" -uuid = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7" -version = "0.10.12" -weakdeps = ["ChainRulesCore", "SparseArrays"] - - [deps.Distances.extensions] - DistancesChainRulesCoreExt = "ChainRulesCore" - DistancesSparseArraysExt = "SparseArrays" - -[[deps.Distributed]] -deps = ["Random", "Serialization", "Sockets"] -uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" -version = "1.11.0" - -[[deps.Distributions]] -deps = ["AliasTables", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] -git-tree-sha1 = "3bc002af51045ca3b47d2e1787d6ce02e68b943a" -uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" -version = "0.25.122" - - [deps.Distributions.extensions] - DistributionsChainRulesCoreExt = "ChainRulesCore" - DistributionsDensityInterfaceExt = "DensityInterface" - DistributionsTestExt = "Test" - - [deps.Distributions.weakdeps] - ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" - DensityInterface = "b429d917-457f-4dbc-8f4c-0cc954292b1d" - Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" - -[[deps.DocStringExtensions]] -git-tree-sha1 = "7442a5dfe1ebb773c29cc2962a8980f47221d76c" -uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" -version = "0.9.5" - -[[deps.Documenter]] -deps = ["ANSIColoredPrinters", "AbstractTrees", "Base64", "CodecZlib", "Dates", "DocStringExtensions", "Downloads", "Git", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "MarkdownAST", "Pkg", "PrecompileTools", "REPL", "RegistryInstances", "SHA", "TOML", "Test", "Unicode"] -git-tree-sha1 = "70c521ca3a23c576e12655d15963977c9766c26b" -uuid = "e30172f5-a6a5-5a46-863b-614d45cd2de4" -version = "1.16.0" - -[[deps.Downloads]] -deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] -uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" -version = "1.6.0" - -[[deps.ElasticArrays]] -deps = ["Adapt"] -git-tree-sha1 = "75e5697f521c9ab89816d3abeea806dfc5afb967" -uuid = "fdbdab4c-e67f-52f5-8c3f-e7b388dad3d4" -version = "1.2.12" - -[[deps.ElasticPDMats]] -deps = ["LinearAlgebra", "MacroTools", "PDMats"] -git-tree-sha1 = "feb325f9ca96dce03ae03347ff23854205f5be3d" -uuid = "2904ab23-551e-5aed-883f-487f97af5226" -version = "0.2.4" - -[[deps.EnsembleKalmanProcesses]] -deps = ["Convex", "Distributions", "DocStringExtensions", "FFMPEG", "GaussianRandomFields", "Interpolations", "LinearAlgebra", "MathOptInterface", "Optim", "QuadGK", "Random", "RecipesBase", "SCS", "SparseArrays", "Statistics", "StatsBase", "TOML", "TSVD"] -git-tree-sha1 = "52faab1c57dac15c161f60f0c1d94ebb110ea3c8" -uuid = "aa8a2aa5-91d8-4396-bcef-d4f2ec43552d" -version = "2.6.0" - - [deps.EnsembleKalmanProcesses.extensions] - EnsembleKalmanProcessesMakieExt = "Makie" - - [deps.EnsembleKalmanProcesses.weakdeps] - Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" - -[[deps.EnumX]] -git-tree-sha1 = "bddad79635af6aec424f53ed8aad5d7555dc6f00" -uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" -version = "1.0.5" - -[[deps.Expat_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "27af30de8b5445644e8ffe3bcb0d72049c089cf1" -uuid = "2e619515-83b5-522b-bb60-26c02a35a201" -version = "2.7.3+0" - -[[deps.FFMPEG]] -deps = ["FFMPEG_jll"] -git-tree-sha1 = "95ecf07c2eea562b5adbd0696af6db62c0f52560" -uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" -version = "0.4.5" - -[[deps.FFMPEG_jll]] -deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] -git-tree-sha1 = "ccc81ba5e42497f4e76553a5545665eed577a663" -uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5" -version = "8.0.0+0" - -[[deps.FFTW]] -deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] -git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" -uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" -version = "1.10.0" - -[[deps.FFTW_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "6d6219a004b8cf1e0b4dbe27a2860b8e04eba0be" -uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" -version = "3.3.11+0" - -[[deps.FastGaussQuadrature]] -deps = ["LinearAlgebra", "SpecialFunctions", "StaticArrays"] -git-tree-sha1 = "58d83dd5a78a36205bdfddb82b1bb67682e64487" -uuid = "442a2c76-b920-505d-bb47-c5924d526838" -version = "0.4.9" - -[[deps.FileWatching]] -uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" -version = "1.11.0" - -[[deps.FillArrays]] -deps = ["LinearAlgebra"] -git-tree-sha1 = "5bfcd42851cf2f1b303f51525a54dc5e98d408a3" -uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" -version = "1.15.0" -weakdeps = ["PDMats", "SparseArrays", "Statistics"] - - [deps.FillArrays.extensions] - FillArraysPDMatsExt = "PDMats" - FillArraysSparseArraysExt = "SparseArrays" - 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.Fontconfig_jll]] -deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Zlib_jll"] -git-tree-sha1 = "f85dac9a96a01087df6e3a749840015a0ca3817d" -uuid = "a3f928ae-7b40-5064-980b-68af3947d34b" -version = "2.17.1+0" - -[[deps.Formatting]] -deps = ["Logging", "Printf"] -git-tree-sha1 = "fb409abab2caf118986fc597ba84b50cbaf00b87" -uuid = "59287772-0a20-5a39-b81b-1366585eb4c0" -version = "0.4.3" - -[[deps.ForwardDiff]] -deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] -git-tree-sha1 = "afb7c51ac63e40708a3071f80f5e84a752299d4f" -uuid = "f6369f11-7733-5829-9624-2563aa707210" -version = "0.10.39" -weakdeps = ["StaticArrays"] - - [deps.ForwardDiff.extensions] - ForwardDiffStaticArraysExt = "StaticArrays" - -[[deps.FreeType2_jll]] -deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Zlib_jll"] -git-tree-sha1 = "2c5512e11c791d1baed2049c5652441b28fc6a31" -uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7" -version = "2.13.4+0" - -[[deps.FriBidi_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "7a214fdac5ed5f59a22c2d9a885a16da1c74bbc7" -uuid = "559328eb-81f9-559d-9380-de523a88c83c" -version = "1.0.17+0" - -[[deps.FunctionWrappers]] -git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" -uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" -version = "1.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" -version = "1.11.0" - -[[deps.GaussianProcesses]] -deps = ["Distances", "Distributions", "ElasticArrays", "ElasticPDMats", "FastGaussQuadrature", "ForwardDiff", "LinearAlgebra", "Optim", "PDMats", "Printf", "ProgressMeter", "Random", "RecipesBase", "ScikitLearnBase", "SpecialFunctions", "StaticArrays", "Statistics", "StatsFuns"] -git-tree-sha1 = "31749ff6868caf6dd50902eec652a724071dbed3" -uuid = "891a1506-143c-57d2-908e-e1f8e92e6de9" -version = "0.12.5" - -[[deps.GaussianRandomFields]] -deps = ["Arpack", "FFTW", "FastGaussQuadrature", "LinearAlgebra", "Random", "RecipesBase", "SpecialFunctions", "Statistics", "StatsBase"] -git-tree-sha1 = "90f9cad110814a408c66ec7e37cfe61d579af7be" -uuid = "e4b2fa32-6e09-5554-b718-106ed5adafe9" -version = "2.2.7" - -[[deps.GettextRuntime_jll]] -deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll"] -git-tree-sha1 = "45288942190db7c5f760f59c04495064eedf9340" -uuid = "b0724c58-0f36-5564-988d-3bb0596ebc4a" -version = "0.22.4+0" - -[[deps.Git]] -deps = ["Git_LFS_jll", "Git_jll", "JLLWrappers", "OpenSSH_jll"] -git-tree-sha1 = "824a1890086880696fc908fe12a17bcf61738bd8" -uuid = "d7ba0133-e1db-5d97-8f8c-041e4b3a1eb2" -version = "1.5.0" - -[[deps.Git_LFS_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "bb8471f313ed941f299aa53d32a94ab3bee08844" -uuid = "020c3dae-16b3-5ae5-87b3-4cb189e250b2" -version = "3.7.0+0" - -[[deps.Git_jll]] -deps = ["Artifacts", "Expat_jll", "JLLWrappers", "LibCURL_jll", "Libdl", "Libiconv_jll", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] -git-tree-sha1 = "b6a684587ebe896d9f68ae777f648205940f0f70" -uuid = "f8c6e375-362e-5223-8a59-34ff63f689eb" -version = "2.51.3+0" - -[[deps.Glib_jll]] -deps = ["Artifacts", "GettextRuntime_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Zlib_jll"] -git-tree-sha1 = "50c11ffab2a3d50192a228c313f05b5b5dc5acb2" -uuid = "7746bdde-850d-59dc-9ae8-88ece973131d" -version = "2.86.0+0" - -[[deps.Graphite2_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "8a6dbda1fd736d60cc477d99f2e7a042acfa46e8" -uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472" -version = "1.3.15+0" - -[[deps.HarfBuzz_jll]] -deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll"] -git-tree-sha1 = "f923f9a774fcf3f5cb761bfa43aeadd689714813" -uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566" -version = "8.5.1+0" - -[[deps.HostCPUFeatures]] -deps = ["BitTwiddlingConvenienceFunctions", "IfElse", "Libdl", "Static"] -git-tree-sha1 = "8e070b599339d622e9a081d17230d74a5c473293" -uuid = "3e5b6fbb-0976-4d2c-9146-d79de83f2fb0" -version = "0.1.17" - -[[deps.IOCapture]] -deps = ["Logging", "Random"] -git-tree-sha1 = "0ee181ec08df7d7c911901ea38baf16f755114dc" -uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89" -version = "1.0.0" - -[[deps.IfElse]] -git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" -uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" -version = "0.1.1" - -[[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.IntelOpenMP_jll]] -deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] -git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" -uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" -version = "2025.2.0+0" - -[[deps.InteractiveUtils]] -deps = ["Markdown"] -uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" -version = "1.11.0" - -[[deps.Interpolations]] -deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"] -git-tree-sha1 = "88a101217d7cb38a7b481ccd50d21876e1d1b0e0" -uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" -version = "0.15.1" - - [deps.Interpolations.extensions] - InterpolationsUnitfulExt = "Unitful" - - [deps.Interpolations.weakdeps] - Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" - -[[deps.IntervalSets]] -git-tree-sha1 = "03b4f40b4987baa6a653a21f6f33f902af6255f3" -uuid = "8197267c-284f-5f27-9208-e0e47529a953" -version = "0.7.12" -weakdeps = ["Printf", "Random", "RecipesBase", "Statistics"] - - [deps.IntervalSets.extensions] - IntervalSetsPrintfExt = "Printf" - 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 = "7fd44fd4ff43fc60815f8e764c0f352b83c49151" -uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" -version = "0.1.1" - -[[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 = "5b6bb73f555bc753a6153deec3717b8904f5551c" -uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" -version = "1.3.0" - - [deps.JSON.extensions] - JSONArrowExt = ["ArrowTypes"] - - [deps.JSON.weakdeps] - ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" - -[[deps.JSON3]] -deps = ["Dates", "Mmap", "Parsers", "PrecompileTools", "StructTypes", "UUIDs"] -git-tree-sha1 = "411eccfe8aba0814ffa0fdf4860913ed09c34975" -uuid = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" -version = "1.14.3" - - [deps.JSON3.extensions] - JSON3ArrowExt = ["ArrowTypes"] - - [deps.JSON3.weakdeps] - ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" - -[[deps.JuliaSyntaxHighlighting]] -deps = ["StyledStrings"] -uuid = "ac6e5ff7-fb65-4e79-a425-ec3bc9c03011" -version = "1.12.0" - -[[deps.KernelDensity]] -deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"] -git-tree-sha1 = "ba51324b894edaf1df3ab16e2cc6bc3280a2f1a7" -uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b" -version = "0.6.10" - -[[deps.KernelFunctions]] -deps = ["ChainRulesCore", "Compat", "CompositionsBase", "Distances", "FillArrays", "Functors", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "Random", "Requires", "SpecialFunctions", "Statistics", "StatsBase", "TensorCore", "Test", "ZygoteRules"] -git-tree-sha1 = "0b75b447ee242254ff037402461e5593a84f9ac7" -uuid = "ec8451be-7e33-11e9-00cf-bbf324bd1392" -version = "0.10.66" - -[[deps.LAME_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "059aabebaa7c82ccb853dd4a0ee9d17796f7e1bc" -uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" -version = "3.100.3+0" - -[[deps.LDLFactorizations]] -deps = ["AMD", "LinearAlgebra", "SparseArrays", "Test"] -git-tree-sha1 = "70f582b446a1c3ad82cf87e62b878668beef9d13" -uuid = "40e66cde-538c-5869-a4ad-c39174c6795b" -version = "0.10.1" - -[[deps.LLVMOpenMP_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "eb62a3deb62fc6d8822c0c4bef73e4412419c5d8" -uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" -version = "18.1.8+0" - -[[deps.LZO_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "1c602b1127f4751facb671441ca72715cc95938a" -uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac" -version = "2.10.3+0" - -[[deps.LaTeXStrings]] -git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" -uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" -version = "1.4.0" - -[[deps.LayoutPointers]] -deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] -git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" -uuid = "10f19ff3-798f-405d-979b-55457f8fc047" -version = "0.1.17" - -[[deps.LazilyInitializedFields]] -git-tree-sha1 = "0f2da712350b020bc3957f269c9caad516383ee0" -uuid = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" -version = "1.3.0" - -[[deps.LazyArtifacts]] -deps = ["Artifacts", "Pkg"] -uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" -version = "1.11.0" - -[[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", "OpenSSL_jll", "Zlib_jll", "nghttp2_jll"] -uuid = "deac9b47-8bc7-5906-a0fe-35ac56dc84c0" -version = "8.11.1+1" - -[[deps.LibGit2]] -deps = ["LibGit2_jll", "NetworkOptions", "Printf", "SHA"] -uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" -version = "1.11.0" - -[[deps.LibGit2_jll]] -deps = ["Artifacts", "LibSSH2_jll", "Libdl", "OpenSSL_jll"] -uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" -version = "1.9.0+0" - -[[deps.LibSSH2_jll]] -deps = ["Artifacts", "Libdl", "OpenSSL_jll"] -uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" -version = "1.11.3+1" - -[[deps.Libdl]] -uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" -version = "1.11.0" - -[[deps.Libffi_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "c8da7e6a91781c41a863611c7e966098d783c57a" -uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490" -version = "3.4.7+0" - -[[deps.Libiconv_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" -uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" -version = "1.18.0+0" - -[[deps.Libmount_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "3acf07f130a76f87c041cfb2ff7d7284ca67b072" -uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9" -version = "2.41.2+0" - -[[deps.Libuuid_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "2a7a12fc0a4e7fb773450d17975322aa77142106" -uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700" -version = "2.41.2+0" - -[[deps.LineSearches]] -deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf"] -git-tree-sha1 = "4adee99b7262ad2a1a4bbbc59d993d24e55ea96f" -uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" -version = "7.4.0" - -[[deps.LinearAlgebra]] -deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] -uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" -version = "1.12.0" - -[[deps.LinearMaps]] -deps = ["LinearAlgebra"] -git-tree-sha1 = "7f6be2e4cdaaf558623d93113d6ddade7b916209" -uuid = "7a12625a-238d-50fd-b39a-03d52299707e" -version = "3.11.4" -weakdeps = ["ChainRulesCore", "SparseArrays", "Statistics"] - - [deps.LinearMaps.extensions] - LinearMapsChainRulesCoreExt = "ChainRulesCore" - LinearMapsSparseArraysExt = "SparseArrays" - LinearMapsStatisticsExt = "Statistics" - -[[deps.LogDensityProblems]] -deps = ["ArgCheck", "DocStringExtensions", "Random"] -git-tree-sha1 = "d9625f27ded4ad726ceca7819394a4cc77ed25b3" -uuid = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c" -version = "2.2.0" - -[[deps.LogExpFunctions]] -deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] -git-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f" -uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" -version = "0.3.29" - - [deps.LogExpFunctions.extensions] - LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" - LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" - LogExpFunctionsInverseFunctionsExt = "InverseFunctions" - - [deps.LogExpFunctions.weakdeps] - ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" - ChangesOfVariables = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" - InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" - -[[deps.Logging]] -uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" -version = "1.11.0" - -[[deps.LoggingExtras]] -deps = ["Dates", "Logging"] -git-tree-sha1 = "f00544d95982ea270145636c181ceda21c4e2575" -uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" -version = "1.2.0" - -[[deps.LoopVectorization]] -deps = ["ArrayInterface", "CPUSummary", "CloseOpenIntervals", "DocStringExtensions", "HostCPUFeatures", "IfElse", "LayoutPointers", "LinearAlgebra", "OffsetArrays", "PolyesterWeave", "PrecompileTools", "SIMDTypes", "SLEEFPirates", "Static", "StaticArrayInterface", "ThreadingUtilities", "UnPack", "VectorizationBase"] -git-tree-sha1 = "a9fc7883eb9b5f04f46efb9a540833d1fad974b3" -uuid = "bdcacae8-1622-11e9-2a5c-532679323890" -version = "0.12.173" - - [deps.LoopVectorization.extensions] - ForwardDiffExt = ["ChainRulesCore", "ForwardDiff"] - ForwardDiffNNlibExt = ["ForwardDiff", "NNlib"] - SpecialFunctionsExt = "SpecialFunctions" - - [deps.LoopVectorization.weakdeps] - ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" - ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" - NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" - SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" - -[[deps.LowRankApprox]] -deps = ["FFTW", "LinearAlgebra", "LowRankMatrices", "Nullables", "Random", "SparseArrays"] -git-tree-sha1 = "031af63ba945e23424815014ba0e59c28f5aed32" -uuid = "898213cb-b102-5a47-900c-97e73b919f73" -version = "0.5.5" - -[[deps.LowRankMatrices]] -deps = ["LinearAlgebra"] -git-tree-sha1 = "59c5bb0708be6796604caec16d4357013dc3d132" -uuid = "e65ccdef-c354-471a-8090-89bec1c20ec3" -version = "1.0.2" -weakdeps = ["FillArrays"] - - [deps.LowRankMatrices.extensions] - LowRankMatricesFillArraysExt = "FillArrays" - -[[deps.MCMCChains]] -deps = ["AbstractMCMC", "AxisArrays", "Dates", "Distributions", "Formatting", "IteratorInterfaceExtensions", "KernelDensity", "LinearAlgebra", "MCMCDiagnosticTools", "MLJModelInterface", "NaturalSort", "OrderedCollections", "PrettyTables", "Random", "RecipesBase", "Serialization", "Statistics", "StatsBase", "StatsFuns", "TableTraits", "Tables"] -git-tree-sha1 = "c659f7508035a7bdd5102aef2de028ab035f289a" -uuid = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" -version = "5.7.1" - -[[deps.MCMCDiagnosticTools]] -deps = ["AbstractFFTs", "DataAPI", "DataStructures", "Distributions", "LinearAlgebra", "MLJModelInterface", "Random", "SpecialFunctions", "Statistics", "StatsBase", "Tables"] -git-tree-sha1 = "d1737c39191aa26f42a64e320de313f1d1fd74b1" -uuid = "be115224-59cd-429b-ad48-344e309966f0" -version = "0.2.1" - -[[deps.MKL_jll]] -deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] -git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" -uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" -version = "2025.2.0+0" - -[[deps.MLJModelInterface]] -deps = ["InteractiveUtils", "REPL", "Random", "ScientificTypesBase", "StatisticalTraits"] -git-tree-sha1 = "ccaa3f7938890ee8042cc970ba275115428bd592" -uuid = "e80e1ace-859a-464e-9ed9-23947d8ae3ea" -version = "1.12.0" - -[[deps.MacroTools]] -git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" -uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" -version = "0.5.16" - -[[deps.ManualMemory]] -git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" -uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" -version = "0.1.8" - -[[deps.Markdown]] -deps = ["Base64", "JuliaSyntaxHighlighting", "StyledStrings"] -uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" -version = "1.11.0" - -[[deps.MarkdownAST]] -deps = ["AbstractTrees", "Markdown"] -git-tree-sha1 = "465a70f0fc7d443a00dcdc3267a497397b8a3899" -uuid = "d0879d2d-cac2-40c8-9cee-1863dc0c7391" -version = "0.1.2" - -[[deps.MathOptInterface]] -deps = ["BenchmarkTools", "CodecBzip2", "CodecZlib", "DataStructures", "ForwardDiff", "JSON3", "LinearAlgebra", "MutableArithmetics", "NaNMath", "OrderedCollections", "PrecompileTools", "Printf", "SparseArrays", "SpecialFunctions", "Test"] -git-tree-sha1 = "a2cbab4256690aee457d136752c404e001f27768" -uuid = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" -version = "1.46.0" - -[[deps.MicroCollections]] -deps = ["BangBang", "InitialValues", "Setfield"] -git-tree-sha1 = "629afd7d10dbc6935ec59b32daeb33bc4460a42e" -uuid = "128add7d-3638-4c79-886c-908ea0c25c34" -version = "0.1.4" - -[[deps.Missings]] -deps = ["DataAPI"] -git-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d" -uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" -version = "1.2.0" - -[[deps.Mmap]] -uuid = "a63ad114-7e13-5084-954f-fe012c677804" -version = "1.11.0" - -[[deps.MozillaCACerts_jll]] -uuid = "14a3606d-f60d-562e-9121-12d972cd8159" -version = "2025.5.20" - -[[deps.MutableArithmetics]] -deps = ["LinearAlgebra", "SparseArrays", "Test"] -git-tree-sha1 = "22df8573f8e7c593ac205455ca088989d0a2c7a0" -uuid = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" -version = "1.6.7" - -[[deps.NLSolversBase]] -deps = ["ADTypes", "DifferentiationInterface", "Distributed", "FiniteDiff", "ForwardDiff"] -git-tree-sha1 = "25a6638571a902ecfb1ae2a18fc1575f86b1d4df" -uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" -version = "7.10.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.3.0" - -[[deps.Nullables]] -git-tree-sha1 = "8f87854cc8f3685a60689d8edecaa29d2251979b" -uuid = "4d1e1d77-625e-5b40-9113-a560ec7a8ecd" -version = "1.0.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.Ogg_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "b6aa4566bb7ae78498a5e68943863fa8b5231b59" -uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051" -version = "1.3.6+0" - -[[deps.OpenBLAS32_jll]] -deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] -git-tree-sha1 = "ece4587683695fe4c5f20e990da0ed7e83c351e7" -uuid = "656ef2d0-ae68-5445-9ca0-591084a874a2" -version = "0.3.29+0" - -[[deps.OpenBLAS_jll]] -deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] -uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" -version = "0.3.29+0" - -[[deps.OpenLibm_jll]] -deps = ["Artifacts", "Libdl"] -uuid = "05823500-19ac-5b8b-9628-191a04bc5112" -version = "0.8.7+0" - -[[deps.OpenSSH_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "OpenSSL_jll", "Zlib_jll"] -git-tree-sha1 = "301412a644646fdc0ad67d0a87487466b491e53d" -uuid = "9bd350c2-7e96-507f-8002-3f2e150b4e1b" -version = "10.2.1+0" - -[[deps.OpenSSL_jll]] -deps = ["Artifacts", "Libdl"] -uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" -version = "3.5.1+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 = ["Compat", "EnumX", "FillArrays", "ForwardDiff", "LineSearches", "LinearAlgebra", "NLSolversBase", "NaNMath", "PositiveFactorizations", "Printf", "SparseArrays", "StatsBase"] -git-tree-sha1 = "61942645c38dd2b5b78e2082c9b51ab315315d10" -uuid = "429524aa-4258-5aef-a3af-852621145aeb" -version = "1.13.2" -weakdeps = ["MathOptInterface"] - - [deps.Optim.extensions] - OptimMOIExt = "MathOptInterface" - -[[deps.Opus_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "c392fc5dd032381919e3b22dd32d6443760ce7ea" -uuid = "91d4177d-7536-5919-b921-800302f37372" -version = "1.5.2+0" - -[[deps.OrderedCollections]] -git-tree-sha1 = "05868e21324cede2207c6f0f466b4bfef6d5e7ee" -uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" -version = "1.8.1" - -[[deps.PCRE2_jll]] -deps = ["Artifacts", "Libdl"] -uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" -version = "10.44.0+1" - -[[deps.PDMats]] -deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] -git-tree-sha1 = "f07c06228a1c670ae4c87d1276b92c7c597fdda0" -uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" -version = "0.11.35" - -[[deps.Parameters]] -deps = ["OrderedCollections", "UnPack"] -git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe" -uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" -version = "0.12.3" - -[[deps.Parsers]] -deps = ["Dates", "PrecompileTools", "UUIDs"] -git-tree-sha1 = "7d2f8f21da5db6a806faf7b9b292296da42b2810" -uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" -version = "2.8.3" - -[[deps.Pixman_jll]] -deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] -git-tree-sha1 = "db76b1ecd5e9715f3d043cec13b2ec93ce015d53" -uuid = "30392449-352a-5448-841d-b1acce4e97dc" -version = "0.44.2+0" - -[[deps.Pkg]] -deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"] -uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" -version = "1.12.0" -weakdeps = ["REPL"] - - [deps.Pkg.extensions] - REPLExt = "REPL" - -[[deps.PolyesterWeave]] -deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] -git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" -uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" -version = "0.2.2" - -[[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.PrecompileTools]] -deps = ["Preferences"] -git-tree-sha1 = "07a921781cab75691315adc645096ed5e370cb77" -uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" -version = "1.3.3" - -[[deps.Preferences]] -deps = ["TOML"] -git-tree-sha1 = "0f27480397253da18fe2c12a4ba4eb9eb208bf3d" -uuid = "21216c6a-2e73-6563-6e65-726566657250" -version = "1.5.0" - -[[deps.PrettyTables]] -deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "Reexport", "StringManipulation", "Tables"] -git-tree-sha1 = "1101cd475833706e4d0e7b122218257178f48f34" -uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" -version = "2.4.0" - -[[deps.Printf]] -deps = ["Unicode"] -uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" -version = "1.11.0" - -[[deps.Profile]] -deps = ["StyledStrings"] -uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" -version = "1.11.0" - -[[deps.ProgressBars]] -deps = ["Printf"] -git-tree-sha1 = "b437cdb0385ed38312d91d9c00c20f3798b30256" -uuid = "49802e3a-d2f1-5c88-81d8-b72133a6f568" -version = "1.5.1" - -[[deps.ProgressLogging]] -deps = ["Logging", "SHA", "UUIDs"] -git-tree-sha1 = "d95ed0324b0799843ac6f7a6a85e65fe4e5173f0" -uuid = "33c8b6b6-d38a-422a-b730-caa89a2f386c" -version = "0.1.5" - -[[deps.ProgressMeter]] -deps = ["Distributed", "Printf"] -git-tree-sha1 = "fbb92c6c56b34e1a2c4c36058f68f332bec840e7" -uuid = "92933f4c-e287-5a05-a399-4b506db050ca" -version = "1.11.0" - -[[deps.PtrArrays]] -git-tree-sha1 = "1d36ef11a9aaf1e8b74dacc6a731dd1de8fd493d" -uuid = "43287f4e-b6f4-7ad1-bb20-aadabca52c3d" -version = "1.3.0" - -[[deps.PyCall]] -deps = ["Conda", "Dates", "Libdl", "LinearAlgebra", "MacroTools", "Serialization", "VersionParsing"] -git-tree-sha1 = "9816a3826b0ebf49ab4926e2b18842ad8b5c8f04" -uuid = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" -version = "1.96.4" - -[[deps.QuadGK]] -deps = ["DataStructures", "LinearAlgebra"] -git-tree-sha1 = "9da16da70037ba9d701192e27befedefb91ec284" -uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" -version = "2.11.2" - - [deps.QuadGK.extensions] - QuadGKEnzymeExt = "Enzyme" - - [deps.QuadGK.weakdeps] - Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" - -[[deps.REPL]] -deps = ["InteractiveUtils", "JuliaSyntaxHighlighting", "Markdown", "Sockets", "StyledStrings", "Unicode"] -uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" -version = "1.11.0" - -[[deps.Random]] -deps = ["SHA"] -uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" -version = "1.11.0" - -[[deps.RandomFeatures]] -deps = ["Distributions", "DocStringExtensions", "EnsembleKalmanProcesses", "FFMPEG", "LinearAlgebra", "LoopVectorization", "Random", "SpecialFunctions", "Statistics", "StatsBase", "Tullio"] -git-tree-sha1 = "8e63cac591d3ffe80ecfa7ba189951009fb642fc" -uuid = "36c3bae2-c0c3-419d-b3b4-eebadd35c5e5" -version = "0.3.4" - -[[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.RecipesBase]] -deps = ["PrecompileTools"] -git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" -uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" -version = "1.3.4" - -[[deps.Reexport]] -git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" -uuid = "189a3867-3050-52da-a836-e630ba90ab69" -version = "1.2.2" - -[[deps.RegistryInstances]] -deps = ["LazilyInitializedFields", "Pkg", "TOML", "Tar"] -git-tree-sha1 = "ffd19052caf598b8653b99404058fce14828be51" -uuid = "2792f1a3-b283-48e8-9a74-f99dce5104f3" -version = "0.1.0" - -[[deps.Requires]] -deps = ["UUIDs"] -git-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64" -uuid = "ae029012-a4dd-5104-9daa-d747884805df" -version = "1.3.1" - -[[deps.ReverseDiff]] -deps = ["ChainRulesCore", "DiffResults", "DiffRules", "ForwardDiff", "FunctionWrappers", "LinearAlgebra", "LogExpFunctions", "MacroTools", "NaNMath", "Random", "SpecialFunctions", "StaticArrays", "Statistics"] -git-tree-sha1 = "3ab8eee3620451b09f0272c271875b4bc02146d9" -uuid = "37e2e3b7-166d-5795-8a7a-e32c996b4267" -version = "1.16.1" - -[[deps.Rmath]] -deps = ["Random", "Rmath_jll"] -git-tree-sha1 = "f65dcb5fa46aee0cf9ed6274ccbd597adc49aa7b" -uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa" -version = "0.7.1" - -[[deps.Rmath_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "e60724fd3beea548353984dc61c943ecddb0e29a" -uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" -version = "0.4.3+0" - -[[deps.SCS]] -deps = ["LinearAlgebra", "MathOptInterface", "OpenBLAS32_jll", "PrecompileTools", "SCS_jll", "SparseArrays"] -git-tree-sha1 = "48ec3c39787bc7b278789b9af17c157ea8774dae" -uuid = "c946c3f1-0d1f-5ce8-9dea-7daa1f7e2d13" -version = "2.4.0" - - [deps.SCS.extensions] - SCSSCS_GPU_jllExt = ["SCS_GPU_jll"] - SCSSCS_MKL_jllExt = ["SCS_MKL_jll"] - - [deps.SCS.weakdeps] - SCS_GPU_jll = "af6e375f-46ec-5fa0-b791-491b0dfa44a4" - SCS_MKL_jll = "3f2553a9-4106-52be-b7dd-865123654657" - -[[deps.SCS_jll]] -deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl", "libblastrampoline_jll"] -git-tree-sha1 = "05d6e31efa3debae6618dabee35dbd53cf4539d8" -uuid = "f4f2fc5b-1d94-523c-97ea-2ab488bedf4b" -version = "300.200.900+0" - -[[deps.SHA]] -uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" -version = "0.7.0" - -[[deps.SIMDTypes]] -git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" -uuid = "94e857df-77ce-4151-89e5-788b33177be4" -version = "0.1.0" - -[[deps.SLEEFPirates]] -deps = ["IfElse", "Static", "VectorizationBase"] -git-tree-sha1 = "456f610ca2fbd1c14f5fcf31c6bfadc55e7d66e0" -uuid = "476501e8-09a2-5ece-8869-fb82de89a1fa" -version = "0.6.43" - -[[deps.SciMLPublic]] -git-tree-sha1 = "ed647f161e8b3f2973f24979ec074e8d084f1bee" -uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" -version = "1.0.0" - -[[deps.ScientificTypesBase]] -git-tree-sha1 = "a8e18eb383b5ecf1b5e6fc237eb39255044fd92b" -uuid = "30f210dd-8aff-4c5f-94ba-8e64358c1161" -version = "3.0.0" - -[[deps.ScikitLearn]] -deps = ["Compat", "Conda", "DataFrames", "Distributed", "IterTools", "LinearAlgebra", "MacroTools", "Parameters", "Printf", "PyCall", "Random", "ScikitLearnBase", "SparseArrays", "StatsBase", "VersionParsing"] -git-tree-sha1 = "3df098033358431591827bb86cada0bed744105a" -uuid = "3646fa90-6ef7-5e7e-9f22-8aca16db6324" -version = "0.7.0" - -[[deps.ScikitLearnBase]] -deps = ["LinearAlgebra", "Random", "Statistics"] -git-tree-sha1 = "7877e55c1523a4b336b433da39c8e8c08d2f221f" -uuid = "6e75b9c4-186b-50bd-896f-2d2496a4843e" -version = "0.5.0" - -[[deps.SentinelArrays]] -deps = ["Dates", "Random"] -git-tree-sha1 = "712fb0231ee6f9120e005ccd56297abbc053e7e0" -uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c" -version = "1.4.8" - -[[deps.Serialization]] -uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" -version = "1.11.0" - -[[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" -version = "1.11.0" - -[[deps.Sockets]] -uuid = "6462fe0b-24de-5631-8697-dd941f90decc" -version = "1.11.0" - -[[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.12.0" - -[[deps.SpecialFunctions]] -deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] -git-tree-sha1 = "f2685b435df2613e25fc10ad8c26dddb8640f547" -uuid = "276daf66-3868-5448-9aa4-cd146d93841b" -version = "2.6.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.StableRNGs]] -deps = ["Random"] -git-tree-sha1 = "4f96c596b8c8258cc7d3b19797854d368f243ddc" -uuid = "860ef19b-820b-49d6-a774-d7a799459cd3" -version = "1.0.4" - -[[deps.Static]] -deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] -git-tree-sha1 = "49440414711eddc7227724ae6e570c7d5559a086" -uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" -version = "1.3.1" - -[[deps.StaticArrayInterface]] -deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "Static"] -git-tree-sha1 = "96381d50f1ce85f2663584c8e886a6ca97e60554" -uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" -version = "1.8.0" -weakdeps = ["OffsetArrays", "StaticArrays"] - - [deps.StaticArrayInterface.extensions] - StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" - StaticArrayInterfaceStaticArraysExt = "StaticArrays" - -[[deps.StaticArrays]] -deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] -git-tree-sha1 = "b8693004b385c842357406e3af647701fe783f98" -uuid = "90137ffa-7385-5640-81b9-e52037218182" -version = "1.9.15" -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"] -git-tree-sha1 = "ae3bb1eb3bba077cd276bc5cfc337cc65c3075c0" -uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" -version = "1.11.1" -weakdeps = ["SparseArrays"] - - [deps.Statistics.extensions] - SparseArraysExt = ["SparseArrays"] - -[[deps.StatsAPI]] -deps = ["LinearAlgebra"] -git-tree-sha1 = "9d72a13a3f4dd3795a195ac5a44d7d6ff5f552ff" -uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" -version = "1.7.1" - -[[deps.StatsBase]] -deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] -git-tree-sha1 = "d1bf48bfcc554a3761a133fe3a9bb01488e06916" -uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" -version = "0.33.21" - -[[deps.StatsFuns]] -deps = ["ChainRulesCore", "InverseFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"] -git-tree-sha1 = "5950925ff997ed6fb3e985dcce8eb1ba42a0bbe7" -uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c" -version = "0.9.18" - -[[deps.StringManipulation]] -deps = ["PrecompileTools"] -git-tree-sha1 = "725421ae8e530ec29bcbdddbe91ff8053421d023" -uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" -version = "0.4.1" - -[[deps.StructTypes]] -deps = ["Dates", "UUIDs"] -git-tree-sha1 = "159331b30e94d7b11379037feeb9b690950cace8" -uuid = "856f2bd8-1eba-4b0a-8007-ebc267875bd4" -version = "1.11.0" - -[[deps.StructUtils]] -deps = ["Dates", "UUIDs"] -git-tree-sha1 = "79529b493a44927dd5b13dde1c7ce957c2d049e4" -uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" -version = "2.6.0" - - [deps.StructUtils.extensions] - StructUtilsMeasurementsExt = ["Measurements"] - StructUtilsTablesExt = ["Tables"] - - [deps.StructUtils.weakdeps] - Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" - Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" - -[[deps.StyledStrings]] -uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" -version = "1.11.0" - -[[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.8.3+2" - -[[deps.TOML]] -deps = ["Dates"] -uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" -version = "1.0.3" - -[[deps.TSVD]] -deps = ["Adapt", "LinearAlgebra"] -git-tree-sha1 = "c39caef6bae501e5607a6caf68dd9ac6e8addbcb" -uuid = "9449cd9e-2762-5aa3-a617-5413e99d722e" -version = "0.4.4" - -[[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.TensorCore]] -deps = ["LinearAlgebra"] -git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6" -uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50" -version = "0.1.1" - -[[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" -version = "1.11.0" - -[[deps.ThreadingUtilities]] -deps = ["ManualMemory"] -git-tree-sha1 = "d969183d3d244b6c33796b5ed01ab97328f2db85" -uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" -version = "0.5.5" - -[[deps.TranscodingStreams]] -git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742" -uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" -version = "0.11.3" - -[[deps.Transducers]] -deps = ["Adapt", "ArgCheck", "BangBang", "Baselet", "CompositionsBase", "ConstructionBase", "DefineSingletons", "Distributed", "InitialValues", "Logging", "Markdown", "MicroCollections", "Requires", "Setfield", "SplittablesBase", "Tables"] -git-tree-sha1 = "3064e780dbb8a9296ebb3af8f440f787bb5332af" -uuid = "28d57a85-8fef-5791-bfe6-a80928e7c999" -version = "0.4.80" - - [deps.Transducers.extensions] - TransducersBlockArraysExt = "BlockArrays" - TransducersDataFramesExt = "DataFrames" - TransducersLazyArraysExt = "LazyArrays" - TransducersOnlineStatsBaseExt = "OnlineStatsBase" - TransducersReferenceablesExt = "Referenceables" - - [deps.Transducers.weakdeps] - 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.Tullio]] -deps = ["DiffRules", "LinearAlgebra", "Requires"] -git-tree-sha1 = "972698b132b9df8791ae74aa547268e977b55f68" -uuid = "bc48ee85-29a4-5162-ae0b-a64e1601d4bc" -version = "0.3.8" - - [deps.Tullio.extensions] - TullioCUDAExt = "CUDA" - TullioChainRulesCoreExt = "ChainRulesCore" - TullioFillArraysExt = "FillArrays" - TullioTrackerExt = "Tracker" - - [deps.Tullio.weakdeps] - CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" - ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" - FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" - Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" - -[[deps.UUIDs]] -deps = ["Random", "SHA"] -uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" -version = "1.11.0" - -[[deps.UnPack]] -git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" -uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" -version = "1.0.2" - -[[deps.Unicode]] -uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" -version = "1.11.0" - -[[deps.VectorizationBase]] -deps = ["ArrayInterface", "CPUSummary", "HostCPUFeatures", "IfElse", "LayoutPointers", "Libdl", "LinearAlgebra", "SIMDTypes", "Static", "StaticArrayInterface"] -git-tree-sha1 = "d1d9a935a26c475ebffd54e9c7ad11627c43ea85" -uuid = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f" -version = "0.21.72" - -[[deps.VersionParsing]] -git-tree-sha1 = "58d6e80b4ee071f5efd07fda82cb9fbe17200868" -uuid = "81def892-9a0e-5fdd-b105-ffc91e053289" -version = "1.3.0" - -[[deps.WoodburyMatrices]] -deps = ["LinearAlgebra", "SparseArrays"] -git-tree-sha1 = "c1a7aa6219628fcd757dede0ca95e245c5cd9511" -uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6" -version = "1.0.0" - -[[deps.Xorg_libX11_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xtrans_jll"] -git-tree-sha1 = "b5899b25d17bf1889d25906fb9deed5da0c15b3b" -uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc" -version = "1.8.12+0" - -[[deps.Xorg_libXau_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "aa1261ebbac3ccc8d16558ae6799524c450ed16b" -uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec" -version = "1.0.13+0" - -[[deps.Xorg_libXdmcp_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "52858d64353db33a56e13c341d7bf44cd0d7b309" -uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05" -version = "1.1.6+0" - -[[deps.Xorg_libXext_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] -git-tree-sha1 = "a4c0ee07ad36bf8bbce1c3bb52d21fb1e0b987fb" -uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3" -version = "1.3.7+0" - -[[deps.Xorg_libXrender_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] -git-tree-sha1 = "7ed9347888fac59a618302ee38216dd0379c480d" -uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa" -version = "0.9.12+0" - -[[deps.Xorg_libxcb_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXau_jll", "Xorg_libXdmcp_jll"] -git-tree-sha1 = "bfcaf7ec088eaba362093393fe11aa141fa15422" -uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b" -version = "1.17.1+0" - -[[deps.Xorg_xtrans_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "a63799ff68005991f9d9491b6e95bd3478d783cb" -uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10" -version = "1.6.0+0" - -[[deps.Zlib_jll]] -deps = ["Libdl"] -uuid = "83775a58-1f1d-513f-b197-d71354ab007a" -version = "1.3.1+2" - -[[deps.ZygoteRules]] -deps = ["ChainRulesCore", "MacroTools"] -git-tree-sha1 = "434b3de333c75fc446aa0d19fc394edafd07ab08" -uuid = "700de1a5-db45-46bc-99cf-38207098b444" -version = "0.2.7" - -[[deps.libaom_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "371cc681c00a3ccc3fbc5c0fb91f58ba9bec1ecf" -uuid = "a4ae2306-e953-59d6-aa16-d00cac43593b" -version = "3.13.1+0" - -[[deps.libass_jll]] -deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Zlib_jll"] -git-tree-sha1 = "125eedcb0a4a0bba65b657251ce1d27c8714e9d6" -uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" -version = "0.17.4+0" - -[[deps.libblastrampoline_jll]] -deps = ["Artifacts", "Libdl"] -uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" -version = "5.13.1+1" - -[[deps.libfdk_aac_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "646634dd19587a56ee2f1199563ec056c5f228df" -uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" -version = "2.0.4+0" - -[[deps.libpng_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] -git-tree-sha1 = "07b6a107d926093898e82b3b1db657ebe33134ec" -uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f" -version = "1.6.50+0" - -[[deps.libvorbis_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll"] -git-tree-sha1 = "11e1772e7f3cc987e9d3de991dd4f6b2602663a5" -uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a" -version = "1.3.8+0" - -[[deps.nghttp2_jll]] -deps = ["Artifacts", "Libdl"] -uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" -version = "1.64.0+1" - -[[deps.oneTBB_jll]] -deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] -git-tree-sha1 = "1350188a69a6e46f799d3945beef36435ed7262f" -uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" -version = "2022.0.0+1" - -[[deps.p7zip_jll]] -deps = ["Artifacts", "Libdl"] -uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" -version = "17.5.0+2" - -[[deps.x264_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "14cc7083fc6dff3cc44f2bc435ee96d06ed79aa7" -uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a" -version = "10164.0.1+0" - -[[deps.x265_jll]] -deps = ["Artifacts", "JLLWrappers", "Libdl"] -git-tree-sha1 = "e7b67590c14d487e734dcb925924c5dc43ec85f3" -uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76" -version = "4.1.0+0" From d1979323de730d2c363bb2aee6aca13173386955 Mon Sep 17 00:00:00 2001 From: odunbar Date: Mon, 17 Nov 2025 14:54:16 -0800 Subject: [PATCH 20/32] add julia v1.11.5 manifest --- docs/Manifest.toml | 1854 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1854 insertions(+) create mode 100644 docs/Manifest.toml diff --git a/docs/Manifest.toml b/docs/Manifest.toml new file mode 100644 index 000000000..188bad891 --- /dev/null +++ b/docs/Manifest.toml @@ -0,0 +1,1854 @@ +# This file is machine-generated - editing it directly is not advised + +julia_version = "1.11.5" +manifest_format = "2.0" +project_hash = "e4d965798d55f5903483b71f545533e62ea32fdf" + +[[deps.ADTypes]] +git-tree-sha1 = "8be2ae325471fc20b11c27bb34b518541d07dd3a" +uuid = "47edcb42-4c32-4615-8424-f2b9edc5f35b" +version = "1.19.0" + + [deps.ADTypes.extensions] + ADTypesChainRulesCoreExt = "ChainRulesCore" + ADTypesConstructionBaseExt = "ConstructionBase" + ADTypesEnzymeCoreExt = "EnzymeCore" + + [deps.ADTypes.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9" + EnzymeCore = "f151be2c-9106-41f4-ab19-57ee4f262869" + +[[deps.AMD]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse_jll"] +git-tree-sha1 = "45a1272e3f809d36431e57ab22703c6896b8908f" +uuid = "14f7f29c-3bd6-536c-9a0b-7339e30b5a3e" +version = "0.5.3" + +[[deps.ANSIColoredPrinters]] +git-tree-sha1 = "574baf8110975760d391c710b6341da1afa48d8c" +uuid = "a4c015fc-c6ff-483c-b24f-f7ea428134e9" +version = "0.0.1" + +[[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.AbstractGPs]] +deps = ["ChainRulesCore", "Distributions", "FillArrays", "IrrationalConstants", "KernelFunctions", "LinearAlgebra", "PDMats", "Random", "RecipesBase", "Reexport", "Statistics", "StatsBase", "Test"] +git-tree-sha1 = "8a05cefb7c891378c89576bd4865f34d010c9ece" +uuid = "99985d1d-32ba-4be9-9821-2ec096f28918" +version = "0.5.24" + +[[deps.AbstractMCMC]] +deps = ["BangBang", "ConsoleProgressMonitor", "Distributed", "LogDensityProblems", "Logging", "LoggingExtras", "ProgressLogging", "Random", "StatsBase", "TerminalLoggers", "Transducers"] +git-tree-sha1 = "87e63dcb990029346b091b170252f3c416568afc" +uuid = "80f14c24-f653-4e6a-9b94-39d6b0f70001" +version = "4.4.2" + +[[deps.AbstractTrees]] +git-tree-sha1 = "2d9c9a55f9c93e8887ad391fbae72f8ef55e1177" +uuid = "1520ce14-60c1-5f80-bbc7-55ef81b5835c" +version = "0.4.5" + +[[deps.Adapt]] +deps = ["LinearAlgebra", "Requires"] +git-tree-sha1 = "7e35fca2bdfba44d797c53dfe63a51fabf39bfc0" +uuid = "79e6a3ab-5dfb-504d-930d-738a2a938a0e" +version = "4.4.0" +weakdeps = ["SparseArrays", "StaticArrays"] + + [deps.Adapt.extensions] + AdaptSparseArraysExt = "SparseArrays" + AdaptStaticArraysExt = "StaticArrays" + +[[deps.AdvancedMH]] +deps = ["AbstractMCMC", "Distributions", "FillArrays", "LinearAlgebra", "LogDensityProblems", "Random", "Requires"] +git-tree-sha1 = "b2a1602952739e589cf5e2daff1274a49f22c9a4" +uuid = "5b7e9947-ddc0-4b3f-9b55-0d8042f74170" +version = "0.7.5" + + [deps.AdvancedMH.extensions] + AdvancedMHForwardDiffExt = ["DiffResults", "ForwardDiff"] + AdvancedMHMCMCChainsExt = "MCMCChains" + AdvancedMHStructArraysExt = "StructArrays" + + [deps.AdvancedMH.weakdeps] + DiffResults = "163ba53b-c6d8-5494-b064-1a9d43ac40c5" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + MCMCChains = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" + StructArrays = "09ab397b-f2b6-538f-b94a-2f83cf4a842a" + +[[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.2" + +[[deps.Arpack]] +deps = ["Arpack_jll", "Libdl", "LinearAlgebra", "Logging"] +git-tree-sha1 = "9b9b347613394885fd1c8c7729bfc60528faa436" +uuid = "7d9fca2a-8960-54d3-9f78-7d1dccf2cb97" +version = "0.5.4" + +[[deps.Arpack_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "OpenBLAS_jll", "Pkg"] +git-tree-sha1 = "5ba6c757e8feccf03a1554dfaf3e26b3cfc7fd5e" +uuid = "68821587-b530-5797-8361-c406ea357684" +version = "3.5.1+1" + +[[deps.ArrayInterface]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "d81ae5489e13bc03567d4fbbb06c546a5e53c857" +uuid = "4fba245c-0d91-5ea0-9b3e-6abc04ee57a9" +version = "7.22.0" + + [deps.ArrayInterface.extensions] + 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] + 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" +version = "1.11.0" + +[[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 = ["Compat", "ConstructionBase", "InitialValues", "LinearAlgebra", "Requires", "Setfield", "Tables"] +git-tree-sha1 = "7aa7ad1682f3d5754e3491bb59b8103cae28e3a3" +uuid = "198e06fe-97b7-11e9-32a5-e1d131e6ad66" +version = "0.3.40" + + [deps.BangBang.extensions] + BangBangChainRulesCoreExt = "ChainRulesCore" + BangBangDataFramesExt = "DataFrames" + BangBangStaticArraysExt = "StaticArrays" + BangBangStructArraysExt = "StructArrays" + 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" + TypedTables = "9d95f2ec-7b3d-5a63-8d20-e2491e220bb9" + +[[deps.Base64]] +uuid = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f" +version = "1.11.0" + +[[deps.Baselet]] +git-tree-sha1 = "aebf55e6d7795e02ca500a689d326ac979aaf89e" +uuid = "9718e550-a3fa-408a-8086-8db961cd8217" +version = "0.1.1" + +[[deps.BenchmarkTools]] +deps = ["Compat", "JSON", "Logging", "Printf", "Profile", "Statistics", "UUIDs"] +git-tree-sha1 = "7fecfb1123b8d0232218e2da0c213004ff15358d" +uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" +version = "1.6.3" + +[[deps.BitTwiddlingConvenienceFunctions]] +deps = ["Static"] +git-tree-sha1 = "f21cfd4950cb9f0587d5067e69405ad2acd27b87" +uuid = "62783981-4cbd-42fc-bca8-16325de8dc4b" +version = "0.1.6" + +[[deps.Bzip2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1b96ea4a01afe0ea4090c5c8039690672dd13f2e" +uuid = "6e34b625-4abd-537c-b88f-471c36dfa7a0" +version = "1.0.9+0" + +[[deps.CPUSummary]] +deps = ["CpuId", "IfElse", "PrecompileTools", "Preferences", "Static"] +git-tree-sha1 = "f3a21d7fc84ba618a779d1ed2fcca2e682865bab" +uuid = "2a0fbf3d-bb9c-48f3-b0a9-814d99fd7ab9" +version = "0.2.7" + +[[deps.Cairo_jll]] +deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "fde3bf89aead2e723284a8ff9cdf5b551ed700e8" +uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a" +version = "1.18.5+0" + +[[deps.CalibrateEmulateSample]] +deps = ["AbstractGPs", "AbstractMCMC", "AdvancedMH", "ChunkSplitters", "Conda", "Distributions", "DocStringExtensions", "EnsembleKalmanProcesses", "ForwardDiff", "GaussianProcesses", "KernelFunctions", "LinearAlgebra", "LinearMaps", "LowRankApprox", "MCMCChains", "Pkg", "Printf", "ProgressBars", "PyCall", "Random", "RandomFeatures", "ReverseDiff", "ScikitLearn", "StableRNGs", "Statistics", "StatsBase", "TSVD"] +path = ".." +uuid = "95e48a1f-0bec-4818-9538-3db4340308e3" +version = "0.7.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.ChunkSplitters]] +git-tree-sha1 = "63a3903063d035260f0f6eab00f517471c5dc784" +uuid = "ae650224-84b6-46f8-82ea-d812ca08434e" +version = "3.1.2" + +[[deps.CloseOpenIntervals]] +deps = ["Static", "StaticArrayInterface"] +git-tree-sha1 = "05ba0d07cd4fd8b7a39541e31a7b0254704ea581" +uuid = "fb6a15b2-703c-40df-9091-08a04967cfa9" +version = "0.1.13" + +[[deps.CodecBzip2]] +deps = ["Bzip2_jll", "TranscodingStreams"] +git-tree-sha1 = "84990fa864b7f2b4901901ca12736e45ee79068c" +uuid = "523fee87-0ab8-5b00-afb7-3ecf72e48cfd" +version = "0.8.5" + +[[deps.CodecZlib]] +deps = ["TranscodingStreams", "Zlib_jll"] +git-tree-sha1 = "962834c22b66e32aa10f7611c08c8ca4e20749a9" +uuid = "944b1d66-785c-5afd-91f1-9de20f533193" +version = "0.7.8" + +[[deps.CommonSubexpressions]] +deps = ["MacroTools"] +git-tree-sha1 = "cda2cfaebb4be89c9084adaca7dd7333369715c5" +uuid = "bbf7d656-a473-5ed7-a52c-81e309532950" +version = "0.3.1" + +[[deps.CommonWorldInvalidations]] +git-tree-sha1 = "ae52d1c52048455e85a387fbee9be553ec2b68d0" +uuid = "f70d9fcc-98c5-4d4a-abd7-e4cdeebd8ca8" +version = "1.0.0" + +[[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.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.Convex]] +deps = ["AbstractTrees", "BenchmarkTools", "LDLFactorizations", "LinearAlgebra", "MathOptInterface", "OrderedCollections", "SparseArrays", "Test"] +git-tree-sha1 = "dec769959be3af9ba94970b1f14b31c196b0fb9e" +uuid = "f65535da-76fb-5f13-bab9-19810c17039a" +version = "0.16.4" + +[[deps.CpuId]] +deps = ["Markdown"] +git-tree-sha1 = "fcbb72b032692610bfbdb15018ac16a36cf2e406" +uuid = "adafc99b-e345-5852-983c-f28acb93d879" +version = "0.3.1" + +[[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 = ["Compat", "InteractiveUtils", "OrderedCollections"] +git-tree-sha1 = "4e1fe97fdaed23e9dc21d4d664bea76b65fc50a0" +uuid = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8" +version = "0.18.22" + +[[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" +version = "1.11.0" + +[[deps.DefineSingletons]] +git-tree-sha1 = "0fba8b706d0178b4dc7fd44a96a92382c9065c2c" +uuid = "244e2a9f-e319-4986-a169-4d1fe445cd52" +version = "0.1.2" + +[[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 = "80bd15222b3e8d0bc70d921d2201aa0084810ce5" +uuid = "a0c0ee7d-e4b9-4e03-894e-1c5f64a51d63" +version = "0.7.12" + + [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.Distances]] +deps = ["LinearAlgebra", "Statistics", "StatsAPI"] +git-tree-sha1 = "c7e3a542b999843086e2f29dac96a618c105be1d" +uuid = "b4f34e82-e78d-54a5-968a-f98e89d6e8f7" +version = "0.10.12" +weakdeps = ["ChainRulesCore", "SparseArrays"] + + [deps.Distances.extensions] + DistancesChainRulesCoreExt = "ChainRulesCore" + DistancesSparseArraysExt = "SparseArrays" + +[[deps.Distributed]] +deps = ["Random", "Serialization", "Sockets"] +uuid = "8ba89e20-285c-5b6f-9357-94700520ee1b" +version = "1.11.0" + +[[deps.Distributions]] +deps = ["AliasTables", "FillArrays", "LinearAlgebra", "PDMats", "Printf", "QuadGK", "Random", "SpecialFunctions", "Statistics", "StatsAPI", "StatsBase", "StatsFuns"] +git-tree-sha1 = "3bc002af51045ca3b47d2e1787d6ce02e68b943a" +uuid = "31c24e10-a181-5473-b8eb-7969acd0382f" +version = "0.25.122" + + [deps.Distributions.extensions] + DistributionsChainRulesCoreExt = "ChainRulesCore" + DistributionsDensityInterfaceExt = "DensityInterface" + DistributionsTestExt = "Test" + + [deps.Distributions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + DensityInterface = "b429d917-457f-4dbc-8f4c-0cc954292b1d" + Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" + +[[deps.DocStringExtensions]] +git-tree-sha1 = "7442a5dfe1ebb773c29cc2962a8980f47221d76c" +uuid = "ffbed154-4ef7-542d-bbb7-c09d3a79fcae" +version = "0.9.5" + +[[deps.Documenter]] +deps = ["ANSIColoredPrinters", "AbstractTrees", "Base64", "CodecZlib", "Dates", "DocStringExtensions", "Downloads", "Git", "IOCapture", "InteractiveUtils", "JSON", "Logging", "Markdown", "MarkdownAST", "Pkg", "PrecompileTools", "REPL", "RegistryInstances", "SHA", "TOML", "Test", "Unicode"] +git-tree-sha1 = "70c521ca3a23c576e12655d15963977c9766c26b" +uuid = "e30172f5-a6a5-5a46-863b-614d45cd2de4" +version = "1.16.0" + +[[deps.Downloads]] +deps = ["ArgTools", "FileWatching", "LibCURL", "NetworkOptions"] +uuid = "f43a241f-c20a-4ad4-852c-f6b1247861c6" +version = "1.6.0" + +[[deps.ElasticArrays]] +deps = ["Adapt"] +git-tree-sha1 = "75e5697f521c9ab89816d3abeea806dfc5afb967" +uuid = "fdbdab4c-e67f-52f5-8c3f-e7b388dad3d4" +version = "1.2.12" + +[[deps.ElasticPDMats]] +deps = ["LinearAlgebra", "MacroTools", "PDMats"] +git-tree-sha1 = "feb325f9ca96dce03ae03347ff23854205f5be3d" +uuid = "2904ab23-551e-5aed-883f-487f97af5226" +version = "0.2.4" + +[[deps.EnsembleKalmanProcesses]] +deps = ["Convex", "Distributions", "DocStringExtensions", "FFMPEG", "GaussianRandomFields", "Interpolations", "LinearAlgebra", "MathOptInterface", "Optim", "QuadGK", "Random", "RecipesBase", "SCS", "SparseArrays", "Statistics", "StatsBase", "TOML", "TSVD"] +git-tree-sha1 = "52faab1c57dac15c161f60f0c1d94ebb110ea3c8" +uuid = "aa8a2aa5-91d8-4396-bcef-d4f2ec43552d" +version = "2.6.0" + + [deps.EnsembleKalmanProcesses.extensions] + EnsembleKalmanProcessesMakieExt = "Makie" + + [deps.EnsembleKalmanProcesses.weakdeps] + Makie = "ee78f7c6-11fb-53f2-987a-cfe4a2b5a57a" + +[[deps.EnumX]] +git-tree-sha1 = "bddad79635af6aec424f53ed8aad5d7555dc6f00" +uuid = "4e289a0a-7415-4d19-859d-a7e5c4648b56" +version = "1.0.5" + +[[deps.Expat_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "27af30de8b5445644e8ffe3bcb0d72049c089cf1" +uuid = "2e619515-83b5-522b-bb60-26c02a35a201" +version = "2.7.3+0" + +[[deps.FFMPEG]] +deps = ["FFMPEG_jll"] +git-tree-sha1 = "95ecf07c2eea562b5adbd0696af6db62c0f52560" +uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" +version = "0.4.5" + +[[deps.FFMPEG_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] +git-tree-sha1 = "ccc81ba5e42497f4e76553a5545665eed577a663" +uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5" +version = "8.0.0+0" + +[[deps.FFTW]] +deps = ["AbstractFFTs", "FFTW_jll", "Libdl", "LinearAlgebra", "MKL_jll", "Preferences", "Reexport"] +git-tree-sha1 = "97f08406df914023af55ade2f843c39e99c5d969" +uuid = "7a1cc6ca-52ef-59f5-83cd-3a7055c09341" +version = "1.10.0" + +[[deps.FFTW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6d6219a004b8cf1e0b4dbe27a2860b8e04eba0be" +uuid = "f5851436-0d7a-5f13-b9de-f02708fd171a" +version = "3.3.11+0" + +[[deps.FastGaussQuadrature]] +deps = ["LinearAlgebra", "SpecialFunctions", "StaticArrays"] +git-tree-sha1 = "58d83dd5a78a36205bdfddb82b1bb67682e64487" +uuid = "442a2c76-b920-505d-bb47-c5924d526838" +version = "0.4.9" + +[[deps.FileWatching]] +uuid = "7b1f6079-737a-58dc-b8bc-7a2ca5c1b5ee" +version = "1.11.0" + +[[deps.FillArrays]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "5bfcd42851cf2f1b303f51525a54dc5e98d408a3" +uuid = "1a297f60-69ca-5386-bcde-b61e274b549b" +version = "1.15.0" +weakdeps = ["PDMats", "SparseArrays", "Statistics"] + + [deps.FillArrays.extensions] + FillArraysPDMatsExt = "PDMats" + FillArraysSparseArraysExt = "SparseArrays" + 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.Fontconfig_jll]] +deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Zlib_jll"] +git-tree-sha1 = "f85dac9a96a01087df6e3a749840015a0ca3817d" +uuid = "a3f928ae-7b40-5064-980b-68af3947d34b" +version = "2.17.1+0" + +[[deps.Formatting]] +deps = ["Logging", "Printf"] +git-tree-sha1 = "fb409abab2caf118986fc597ba84b50cbaf00b87" +uuid = "59287772-0a20-5a39-b81b-1366585eb4c0" +version = "0.4.3" + +[[deps.ForwardDiff]] +deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] +git-tree-sha1 = "afb7c51ac63e40708a3071f80f5e84a752299d4f" +uuid = "f6369f11-7733-5829-9624-2563aa707210" +version = "0.10.39" +weakdeps = ["StaticArrays"] + + [deps.ForwardDiff.extensions] + ForwardDiffStaticArraysExt = "StaticArrays" + +[[deps.FreeType2_jll]] +deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "2c5512e11c791d1baed2049c5652441b28fc6a31" +uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7" +version = "2.13.4+0" + +[[deps.FriBidi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "7a214fdac5ed5f59a22c2d9a885a16da1c74bbc7" +uuid = "559328eb-81f9-559d-9380-de523a88c83c" +version = "1.0.17+0" + +[[deps.FunctionWrappers]] +git-tree-sha1 = "d62485945ce5ae9c0c48f124a84998d755bae00e" +uuid = "069b7b12-0de2-55c6-9aab-29f3d0a68a2e" +version = "1.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" +version = "1.11.0" + +[[deps.GaussianProcesses]] +deps = ["Distances", "Distributions", "ElasticArrays", "ElasticPDMats", "FastGaussQuadrature", "ForwardDiff", "LinearAlgebra", "Optim", "PDMats", "Printf", "ProgressMeter", "Random", "RecipesBase", "ScikitLearnBase", "SpecialFunctions", "StaticArrays", "Statistics", "StatsFuns"] +git-tree-sha1 = "31749ff6868caf6dd50902eec652a724071dbed3" +uuid = "891a1506-143c-57d2-908e-e1f8e92e6de9" +version = "0.12.5" + +[[deps.GaussianRandomFields]] +deps = ["Arpack", "FFTW", "FastGaussQuadrature", "LinearAlgebra", "Random", "RecipesBase", "SpecialFunctions", "Statistics", "StatsBase"] +git-tree-sha1 = "90f9cad110814a408c66ec7e37cfe61d579af7be" +uuid = "e4b2fa32-6e09-5554-b718-106ed5adafe9" +version = "2.2.7" + +[[deps.GettextRuntime_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll"] +git-tree-sha1 = "45288942190db7c5f760f59c04495064eedf9340" +uuid = "b0724c58-0f36-5564-988d-3bb0596ebc4a" +version = "0.22.4+0" + +[[deps.Git]] +deps = ["Git_LFS_jll", "Git_jll", "JLLWrappers", "OpenSSH_jll"] +git-tree-sha1 = "824a1890086880696fc908fe12a17bcf61738bd8" +uuid = "d7ba0133-e1db-5d97-8f8c-041e4b3a1eb2" +version = "1.5.0" + +[[deps.Git_LFS_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "bb8471f313ed941f299aa53d32a94ab3bee08844" +uuid = "020c3dae-16b3-5ae5-87b3-4cb189e250b2" +version = "3.7.0+0" + +[[deps.Git_jll]] +deps = ["Artifacts", "Expat_jll", "JLLWrappers", "LibCURL_jll", "Libdl", "Libiconv_jll", "OpenSSL_jll", "PCRE2_jll", "Zlib_jll"] +git-tree-sha1 = "b6a684587ebe896d9f68ae777f648205940f0f70" +uuid = "f8c6e375-362e-5223-8a59-34ff63f689eb" +version = "2.51.3+0" + +[[deps.Glib_jll]] +deps = ["Artifacts", "GettextRuntime_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Zlib_jll"] +git-tree-sha1 = "50c11ffab2a3d50192a228c313f05b5b5dc5acb2" +uuid = "7746bdde-850d-59dc-9ae8-88ece973131d" +version = "2.86.0+0" + +[[deps.Graphite2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8a6dbda1fd736d60cc477d99f2e7a042acfa46e8" +uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472" +version = "1.3.15+0" + +[[deps.HarfBuzz_jll]] +deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll"] +git-tree-sha1 = "f923f9a774fcf3f5cb761bfa43aeadd689714813" +uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566" +version = "8.5.1+0" + +[[deps.HostCPUFeatures]] +deps = ["BitTwiddlingConvenienceFunctions", "IfElse", "Libdl", "Static"] +git-tree-sha1 = "8e070b599339d622e9a081d17230d74a5c473293" +uuid = "3e5b6fbb-0976-4d2c-9146-d79de83f2fb0" +version = "0.1.17" + +[[deps.IOCapture]] +deps = ["Logging", "Random"] +git-tree-sha1 = "0ee181ec08df7d7c911901ea38baf16f755114dc" +uuid = "b5f81e59-6552-4d32-b1f0-c071b021bf89" +version = "1.0.0" + +[[deps.IfElse]] +git-tree-sha1 = "debdd00ffef04665ccbb3e150747a77560e8fad1" +uuid = "615f187c-cbe4-4ef1-ba3b-2fcf58d6d173" +version = "0.1.1" + +[[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.IntelOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "ec1debd61c300961f98064cfb21287613ad7f303" +uuid = "1d5cc7b8-4909-519e-a0f8-d0f5ad9712d0" +version = "2025.2.0+0" + +[[deps.InteractiveUtils]] +deps = ["Markdown"] +uuid = "b77e0a4c-d291-57a0-90e8-8db25a27a240" +version = "1.11.0" + +[[deps.Interpolations]] +deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArrays", "Random", "Ratios", "Requires", "SharedArrays", "SparseArrays", "StaticArrays", "WoodburyMatrices"] +git-tree-sha1 = "88a101217d7cb38a7b481ccd50d21876e1d1b0e0" +uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" +version = "0.15.1" + + [deps.Interpolations.extensions] + InterpolationsUnitfulExt = "Unitful" + + [deps.Interpolations.weakdeps] + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + +[[deps.IntervalSets]] +git-tree-sha1 = "03b4f40b4987baa6a653a21f6f33f902af6255f3" +uuid = "8197267c-284f-5f27-9208-e0e47529a953" +version = "0.7.12" +weakdeps = ["Printf", "Random", "RecipesBase", "Statistics"] + + [deps.IntervalSets.extensions] + IntervalSetsPrintfExt = "Printf" + 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 = "7fd44fd4ff43fc60815f8e764c0f352b83c49151" +uuid = "92d709cd-6900-40b7-9082-c6be49f344b6" +version = "0.1.1" + +[[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 = "5b6bb73f555bc753a6153deec3717b8904f5551c" +uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +version = "1.3.0" + + [deps.JSON.extensions] + JSONArrowExt = ["ArrowTypes"] + + [deps.JSON.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + +[[deps.JSON3]] +deps = ["Dates", "Mmap", "Parsers", "PrecompileTools", "StructTypes", "UUIDs"] +git-tree-sha1 = "411eccfe8aba0814ffa0fdf4860913ed09c34975" +uuid = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" +version = "1.14.3" + + [deps.JSON3.extensions] + JSON3ArrowExt = ["ArrowTypes"] + + [deps.JSON3.weakdeps] + ArrowTypes = "31f734f8-188a-4ce0-8406-c8a06bd891cd" + +[[deps.KernelDensity]] +deps = ["Distributions", "DocStringExtensions", "FFTW", "Interpolations", "StatsBase"] +git-tree-sha1 = "ba51324b894edaf1df3ab16e2cc6bc3280a2f1a7" +uuid = "5ab0869b-81aa-558d-bb23-cbf5423bbe9b" +version = "0.6.10" + +[[deps.KernelFunctions]] +deps = ["ChainRulesCore", "Compat", "CompositionsBase", "Distances", "FillArrays", "Functors", "IrrationalConstants", "LinearAlgebra", "LogExpFunctions", "Random", "Requires", "SpecialFunctions", "Statistics", "StatsBase", "TensorCore", "Test", "ZygoteRules"] +git-tree-sha1 = "0b75b447ee242254ff037402461e5593a84f9ac7" +uuid = "ec8451be-7e33-11e9-00cf-bbf324bd1392" +version = "0.10.66" + +[[deps.LAME_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "059aabebaa7c82ccb853dd4a0ee9d17796f7e1bc" +uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" +version = "3.100.3+0" + +[[deps.LDLFactorizations]] +deps = ["AMD", "LinearAlgebra", "SparseArrays", "Test"] +git-tree-sha1 = "70f582b446a1c3ad82cf87e62b878668beef9d13" +uuid = "40e66cde-538c-5869-a4ad-c39174c6795b" +version = "0.10.1" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "eb62a3deb62fc6d8822c0c4bef73e4412419c5d8" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "18.1.8+0" + +[[deps.LZO_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1c602b1127f4751facb671441ca72715cc95938a" +uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac" +version = "2.10.3+0" + +[[deps.LaTeXStrings]] +git-tree-sha1 = "dda21b8cbd6a6c40d9d02a73230f9d70fed6918c" +uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" +version = "1.4.0" + +[[deps.LayoutPointers]] +deps = ["ArrayInterface", "LinearAlgebra", "ManualMemory", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "a9eaadb366f5493a5654e843864c13d8b107548c" +uuid = "10f19ff3-798f-405d-979b-55457f8fc047" +version = "0.1.17" + +[[deps.LazilyInitializedFields]] +git-tree-sha1 = "0f2da712350b020bc3957f269c9caad516383ee0" +uuid = "0e77f7df-68c5-4e49-93ce-4cd80f5598bf" +version = "1.3.0" + +[[deps.LazyArtifacts]] +deps = ["Artifacts", "Pkg"] +uuid = "4af54fe1-eca0-43a8-85a7-787d91b784e3" +version = "1.11.0" + +[[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.6.0+0" + +[[deps.LibGit2]] +deps = ["Base64", "LibGit2_jll", "NetworkOptions", "Printf", "SHA"] +uuid = "76f85450-5226-5b5a-8eaa-529ad045b433" +version = "1.11.0" + +[[deps.LibGit2_jll]] +deps = ["Artifacts", "LibSSH2_jll", "Libdl", "MbedTLS_jll"] +uuid = "e37daf67-58a4-590a-8e99-b0245dd2ffc5" +version = "1.7.2+0" + +[[deps.LibSSH2_jll]] +deps = ["Artifacts", "Libdl", "MbedTLS_jll"] +uuid = "29816b5a-b9ab-546f-933c-edad1886dfa8" +version = "1.11.0+1" + +[[deps.Libdl]] +uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +version = "1.11.0" + +[[deps.Libffi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "c8da7e6a91781c41a863611c7e966098d783c57a" +uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490" +version = "3.4.7+0" + +[[deps.Libiconv_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "be484f5c92fad0bd8acfef35fe017900b0b73809" +uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" +version = "1.18.0+0" + +[[deps.Libmount_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "3acf07f130a76f87c041cfb2ff7d7284ca67b072" +uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9" +version = "2.41.2+0" + +[[deps.Libuuid_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "2a7a12fc0a4e7fb773450d17975322aa77142106" +uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700" +version = "2.41.2+0" + +[[deps.LineSearches]] +deps = ["LinearAlgebra", "NLSolversBase", "NaNMath", "Parameters", "Printf"] +git-tree-sha1 = "4adee99b7262ad2a1a4bbbc59d993d24e55ea96f" +uuid = "d3d80556-e9d4-5f37-9878-2ab0fcc64255" +version = "7.4.0" + +[[deps.LinearAlgebra]] +deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] +uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" +version = "1.11.0" + +[[deps.LinearMaps]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "7f6be2e4cdaaf558623d93113d6ddade7b916209" +uuid = "7a12625a-238d-50fd-b39a-03d52299707e" +version = "3.11.4" +weakdeps = ["ChainRulesCore", "SparseArrays", "Statistics"] + + [deps.LinearMaps.extensions] + LinearMapsChainRulesCoreExt = "ChainRulesCore" + LinearMapsSparseArraysExt = "SparseArrays" + LinearMapsStatisticsExt = "Statistics" + +[[deps.LogDensityProblems]] +deps = ["ArgCheck", "DocStringExtensions", "Random"] +git-tree-sha1 = "d9625f27ded4ad726ceca7819394a4cc77ed25b3" +uuid = "6fdf6af0-433a-55f7-b3ed-c6c6e0b8df7c" +version = "2.2.0" + +[[deps.LogExpFunctions]] +deps = ["DocStringExtensions", "IrrationalConstants", "LinearAlgebra"] +git-tree-sha1 = "13ca9e2586b89836fd20cccf56e57e2b9ae7f38f" +uuid = "2ab3a3ac-af41-5b50-aa03-7779005ae688" +version = "0.3.29" + + [deps.LogExpFunctions.extensions] + LogExpFunctionsChainRulesCoreExt = "ChainRulesCore" + LogExpFunctionsChangesOfVariablesExt = "ChangesOfVariables" + LogExpFunctionsInverseFunctionsExt = "InverseFunctions" + + [deps.LogExpFunctions.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ChangesOfVariables = "9e997f8a-9a97-42d5-a9f1-ce6bfc15e2c0" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.Logging]] +uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +version = "1.11.0" + +[[deps.LoggingExtras]] +deps = ["Dates", "Logging"] +git-tree-sha1 = "f00544d95982ea270145636c181ceda21c4e2575" +uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" +version = "1.2.0" + +[[deps.LoopVectorization]] +deps = ["ArrayInterface", "CPUSummary", "CloseOpenIntervals", "DocStringExtensions", "HostCPUFeatures", "IfElse", "LayoutPointers", "LinearAlgebra", "OffsetArrays", "PolyesterWeave", "PrecompileTools", "SIMDTypes", "SLEEFPirates", "Static", "StaticArrayInterface", "ThreadingUtilities", "UnPack", "VectorizationBase"] +git-tree-sha1 = "a9fc7883eb9b5f04f46efb9a540833d1fad974b3" +uuid = "bdcacae8-1622-11e9-2a5c-532679323890" +version = "0.12.173" + + [deps.LoopVectorization.extensions] + ForwardDiffExt = ["ChainRulesCore", "ForwardDiff"] + ForwardDiffNNlibExt = ["ForwardDiff", "NNlib"] + SpecialFunctionsExt = "SpecialFunctions" + + [deps.LoopVectorization.weakdeps] + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + ForwardDiff = "f6369f11-7733-5829-9624-2563aa707210" + NNlib = "872c559c-99b0-510c-b3b7-b6c96a88d5cd" + SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" + +[[deps.LowRankApprox]] +deps = ["FFTW", "LinearAlgebra", "LowRankMatrices", "Nullables", "Random", "SparseArrays"] +git-tree-sha1 = "031af63ba945e23424815014ba0e59c28f5aed32" +uuid = "898213cb-b102-5a47-900c-97e73b919f73" +version = "0.5.5" + +[[deps.LowRankMatrices]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "59c5bb0708be6796604caec16d4357013dc3d132" +uuid = "e65ccdef-c354-471a-8090-89bec1c20ec3" +version = "1.0.2" +weakdeps = ["FillArrays"] + + [deps.LowRankMatrices.extensions] + LowRankMatricesFillArraysExt = "FillArrays" + +[[deps.MCMCChains]] +deps = ["AbstractMCMC", "AxisArrays", "Dates", "Distributions", "Formatting", "IteratorInterfaceExtensions", "KernelDensity", "LinearAlgebra", "MCMCDiagnosticTools", "MLJModelInterface", "NaturalSort", "OrderedCollections", "PrettyTables", "Random", "RecipesBase", "Serialization", "Statistics", "StatsBase", "StatsFuns", "TableTraits", "Tables"] +git-tree-sha1 = "c659f7508035a7bdd5102aef2de028ab035f289a" +uuid = "c7f686f2-ff18-58e9-bc7b-31028e88f75d" +version = "5.7.1" + +[[deps.MCMCDiagnosticTools]] +deps = ["AbstractFFTs", "DataAPI", "DataStructures", "Distributions", "LinearAlgebra", "MLJModelInterface", "Random", "SpecialFunctions", "Statistics", "StatsBase", "Tables"] +git-tree-sha1 = "d1737c39191aa26f42a64e320de313f1d1fd74b1" +uuid = "be115224-59cd-429b-ad48-344e309966f0" +version = "0.2.1" + +[[deps.MKL_jll]] +deps = ["Artifacts", "IntelOpenMP_jll", "JLLWrappers", "LazyArtifacts", "Libdl", "oneTBB_jll"] +git-tree-sha1 = "282cadc186e7b2ae0eeadbd7a4dffed4196ae2aa" +uuid = "856f044c-d86e-5d09-b602-aeab76dc8ba7" +version = "2025.2.0+0" + +[[deps.MLJModelInterface]] +deps = ["InteractiveUtils", "REPL", "Random", "ScientificTypesBase", "StatisticalTraits"] +git-tree-sha1 = "ccaa3f7938890ee8042cc970ba275115428bd592" +uuid = "e80e1ace-859a-464e-9ed9-23947d8ae3ea" +version = "1.12.0" + +[[deps.MacroTools]] +git-tree-sha1 = "1e0228a030642014fe5cfe68c2c0a818f9e3f522" +uuid = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09" +version = "0.5.16" + +[[deps.ManualMemory]] +git-tree-sha1 = "bcaef4fc7a0cfe2cba636d84cda54b5e4e4ca3cd" +uuid = "d125e4d3-2237-4719-b19c-fa641b8a4667" +version = "0.1.8" + +[[deps.Markdown]] +deps = ["Base64"] +uuid = "d6f4376e-aef5-505a-96c1-9c027394607a" +version = "1.11.0" + +[[deps.MarkdownAST]] +deps = ["AbstractTrees", "Markdown"] +git-tree-sha1 = "465a70f0fc7d443a00dcdc3267a497397b8a3899" +uuid = "d0879d2d-cac2-40c8-9cee-1863dc0c7391" +version = "0.1.2" + +[[deps.MathOptInterface]] +deps = ["BenchmarkTools", "CodecBzip2", "CodecZlib", "DataStructures", "ForwardDiff", "JSON3", "LinearAlgebra", "MutableArithmetics", "NaNMath", "OrderedCollections", "PrecompileTools", "Printf", "SparseArrays", "SpecialFunctions", "Test"] +git-tree-sha1 = "a2cbab4256690aee457d136752c404e001f27768" +uuid = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" +version = "1.46.0" + +[[deps.MbedTLS_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" +version = "2.28.6+0" + +[[deps.MicroCollections]] +deps = ["BangBang", "InitialValues", "Setfield"] +git-tree-sha1 = "629afd7d10dbc6935ec59b32daeb33bc4460a42e" +uuid = "128add7d-3638-4c79-886c-908ea0c25c34" +version = "0.1.4" + +[[deps.Missings]] +deps = ["DataAPI"] +git-tree-sha1 = "ec4f7fbeab05d7747bdf98eb74d130a2a2ed298d" +uuid = "e1d29d7a-bbdc-5cf2-9ac0-f12de2c33e28" +version = "1.2.0" + +[[deps.Mmap]] +uuid = "a63ad114-7e13-5084-954f-fe012c677804" +version = "1.11.0" + +[[deps.MozillaCACerts_jll]] +uuid = "14a3606d-f60d-562e-9121-12d972cd8159" +version = "2023.12.12" + +[[deps.MutableArithmetics]] +deps = ["LinearAlgebra", "SparseArrays", "Test"] +git-tree-sha1 = "22df8573f8e7c593ac205455ca088989d0a2c7a0" +uuid = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" +version = "1.6.7" + +[[deps.NLSolversBase]] +deps = ["ADTypes", "DifferentiationInterface", "Distributed", "FiniteDiff", "ForwardDiff"] +git-tree-sha1 = "25a6638571a902ecfb1ae2a18fc1575f86b1d4df" +uuid = "d41bc354-129a-5804-8e4c-c37616107c6c" +version = "7.10.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.Nullables]] +git-tree-sha1 = "8f87854cc8f3685a60689d8edecaa29d2251979b" +uuid = "4d1e1d77-625e-5b40-9113-a560ec7a8ecd" +version = "1.0.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.Ogg_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "b6aa4566bb7ae78498a5e68943863fa8b5231b59" +uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051" +version = "1.3.6+0" + +[[deps.OpenBLAS32_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl"] +git-tree-sha1 = "ece4587683695fe4c5f20e990da0ed7e83c351e7" +uuid = "656ef2d0-ae68-5445-9ca0-591084a874a2" +version = "0.3.29+0" + +[[deps.OpenBLAS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] +uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" +version = "0.3.27+1" + +[[deps.OpenLibm_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "05823500-19ac-5b8b-9628-191a04bc5112" +version = "0.8.5+0" + +[[deps.OpenSSH_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "OpenSSL_jll", "Zlib_jll"] +git-tree-sha1 = "301412a644646fdc0ad67d0a87487466b491e53d" +uuid = "9bd350c2-7e96-507f-8002-3f2e150b4e1b" +version = "10.2.1+0" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "f19301ae653233bc88b1810ae908194f07f8db9d" +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.5.4+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 = ["Compat", "EnumX", "FillArrays", "ForwardDiff", "LineSearches", "LinearAlgebra", "NLSolversBase", "NaNMath", "PositiveFactorizations", "Printf", "SparseArrays", "StatsBase"] +git-tree-sha1 = "61942645c38dd2b5b78e2082c9b51ab315315d10" +uuid = "429524aa-4258-5aef-a3af-852621145aeb" +version = "1.13.2" +weakdeps = ["MathOptInterface"] + + [deps.Optim.extensions] + OptimMOIExt = "MathOptInterface" + +[[deps.Opus_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "c392fc5dd032381919e3b22dd32d6443760ce7ea" +uuid = "91d4177d-7536-5919-b921-800302f37372" +version = "1.5.2+0" + +[[deps.OrderedCollections]] +git-tree-sha1 = "05868e21324cede2207c6f0f466b4bfef6d5e7ee" +uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" +version = "1.8.1" + +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.42.0+1" + +[[deps.PDMats]] +deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] +git-tree-sha1 = "f07c06228a1c670ae4c87d1276b92c7c597fdda0" +uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" +version = "0.11.35" + +[[deps.Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.3" + +[[deps.Parsers]] +deps = ["Dates", "PrecompileTools", "UUIDs"] +git-tree-sha1 = "7d2f8f21da5db6a806faf7b9b292296da42b2810" +uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" +version = "2.8.3" + +[[deps.Pixman_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "db76b1ecd5e9715f3d043cec13b2ec93ce015d53" +uuid = "30392449-352a-5448-841d-b1acce4e97dc" +version = "0.44.2+0" + +[[deps.Pkg]] +deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "Random", "SHA", "TOML", "Tar", "UUIDs", "p7zip_jll"] +uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" +version = "1.11.0" +weakdeps = ["REPL"] + + [deps.Pkg.extensions] + REPLExt = "REPL" + +[[deps.PolyesterWeave]] +deps = ["BitTwiddlingConvenienceFunctions", "CPUSummary", "IfElse", "Static", "ThreadingUtilities"] +git-tree-sha1 = "645bed98cd47f72f67316fd42fc47dee771aefcd" +uuid = "1d0040c9-8b98-4ee7-8388-3f51789ca0ad" +version = "0.2.2" + +[[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.PrecompileTools]] +deps = ["Preferences"] +git-tree-sha1 = "5aa36f7049a63a1528fe8f7c3f2113413ffd4e1f" +uuid = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +version = "1.2.1" + +[[deps.Preferences]] +deps = ["TOML"] +git-tree-sha1 = "0f27480397253da18fe2c12a4ba4eb9eb208bf3d" +uuid = "21216c6a-2e73-6563-6e65-726566657250" +version = "1.5.0" + +[[deps.PrettyTables]] +deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "Reexport", "StringManipulation", "Tables"] +git-tree-sha1 = "1101cd475833706e4d0e7b122218257178f48f34" +uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +version = "2.4.0" + +[[deps.Printf]] +deps = ["Unicode"] +uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" +version = "1.11.0" + +[[deps.Profile]] +uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" +version = "1.11.0" + +[[deps.ProgressBars]] +deps = ["Printf"] +git-tree-sha1 = "b437cdb0385ed38312d91d9c00c20f3798b30256" +uuid = "49802e3a-d2f1-5c88-81d8-b72133a6f568" +version = "1.5.1" + +[[deps.ProgressLogging]] +deps = ["Logging", "SHA", "UUIDs"] +git-tree-sha1 = "d95ed0324b0799843ac6f7a6a85e65fe4e5173f0" +uuid = "33c8b6b6-d38a-422a-b730-caa89a2f386c" +version = "0.1.5" + +[[deps.ProgressMeter]] +deps = ["Distributed", "Printf"] +git-tree-sha1 = "fbb92c6c56b34e1a2c4c36058f68f332bec840e7" +uuid = "92933f4c-e287-5a05-a399-4b506db050ca" +version = "1.11.0" + +[[deps.PtrArrays]] +git-tree-sha1 = "1d36ef11a9aaf1e8b74dacc6a731dd1de8fd493d" +uuid = "43287f4e-b6f4-7ad1-bb20-aadabca52c3d" +version = "1.3.0" + +[[deps.PyCall]] +deps = ["Conda", "Dates", "Libdl", "LinearAlgebra", "MacroTools", "Serialization", "VersionParsing"] +git-tree-sha1 = "9816a3826b0ebf49ab4926e2b18842ad8b5c8f04" +uuid = "438e738f-606a-5dbb-bf0a-cddfbfd45ab0" +version = "1.96.4" + +[[deps.QuadGK]] +deps = ["DataStructures", "LinearAlgebra"] +git-tree-sha1 = "9da16da70037ba9d701192e27befedefb91ec284" +uuid = "1fd47b50-473d-5c70-9696-f719f8f3bcdc" +version = "2.11.2" + + [deps.QuadGK.extensions] + QuadGKEnzymeExt = "Enzyme" + + [deps.QuadGK.weakdeps] + Enzyme = "7da242da-08ed-463a-9acd-ee780be4f1d9" + +[[deps.REPL]] +deps = ["InteractiveUtils", "Markdown", "Sockets", "StyledStrings", "Unicode"] +uuid = "3fa0cd96-eef1-5676-8a61-b3b8758bbffb" +version = "1.11.0" + +[[deps.Random]] +deps = ["SHA"] +uuid = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c" +version = "1.11.0" + +[[deps.RandomFeatures]] +deps = ["Distributions", "DocStringExtensions", "EnsembleKalmanProcesses", "FFMPEG", "LinearAlgebra", "LoopVectorization", "Random", "SpecialFunctions", "Statistics", "StatsBase", "Tullio"] +git-tree-sha1 = "8e63cac591d3ffe80ecfa7ba189951009fb642fc" +uuid = "36c3bae2-c0c3-419d-b3b4-eebadd35c5e5" +version = "0.3.4" + +[[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.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + +[[deps.Reexport]] +git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" +uuid = "189a3867-3050-52da-a836-e630ba90ab69" +version = "1.2.2" + +[[deps.RegistryInstances]] +deps = ["LazilyInitializedFields", "Pkg", "TOML", "Tar"] +git-tree-sha1 = "ffd19052caf598b8653b99404058fce14828be51" +uuid = "2792f1a3-b283-48e8-9a74-f99dce5104f3" +version = "0.1.0" + +[[deps.Requires]] +deps = ["UUIDs"] +git-tree-sha1 = "62389eeff14780bfe55195b7204c0d8738436d64" +uuid = "ae029012-a4dd-5104-9daa-d747884805df" +version = "1.3.1" + +[[deps.ReverseDiff]] +deps = ["ChainRulesCore", "DiffResults", "DiffRules", "ForwardDiff", "FunctionWrappers", "LinearAlgebra", "LogExpFunctions", "MacroTools", "NaNMath", "Random", "SpecialFunctions", "StaticArrays", "Statistics"] +git-tree-sha1 = "3ab8eee3620451b09f0272c271875b4bc02146d9" +uuid = "37e2e3b7-166d-5795-8a7a-e32c996b4267" +version = "1.16.1" + +[[deps.Rmath]] +deps = ["Random", "Rmath_jll"] +git-tree-sha1 = "f65dcb5fa46aee0cf9ed6274ccbd597adc49aa7b" +uuid = "79098fc4-a85e-5d69-aa6a-4863f24498fa" +version = "0.7.1" + +[[deps.Rmath_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e60724fd3beea548353984dc61c943ecddb0e29a" +uuid = "f50d1b31-88e8-58de-be2c-1cc44531875f" +version = "0.4.3+0" + +[[deps.SCS]] +deps = ["LinearAlgebra", "MathOptInterface", "OpenBLAS32_jll", "PrecompileTools", "SCS_jll", "SparseArrays"] +git-tree-sha1 = "48ec3c39787bc7b278789b9af17c157ea8774dae" +uuid = "c946c3f1-0d1f-5ce8-9dea-7daa1f7e2d13" +version = "2.4.0" + + [deps.SCS.extensions] + SCSSCS_GPU_jllExt = ["SCS_GPU_jll"] + SCSSCS_MKL_jllExt = ["SCS_MKL_jll"] + + [deps.SCS.weakdeps] + SCS_GPU_jll = "af6e375f-46ec-5fa0-b791-491b0dfa44a4" + SCS_MKL_jll = "3f2553a9-4106-52be-b7dd-865123654657" + +[[deps.SCS_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl", "libblastrampoline_jll"] +git-tree-sha1 = "05d6e31efa3debae6618dabee35dbd53cf4539d8" +uuid = "f4f2fc5b-1d94-523c-97ea-2ab488bedf4b" +version = "300.200.900+0" + +[[deps.SHA]] +uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" +version = "0.7.0" + +[[deps.SIMDTypes]] +git-tree-sha1 = "330289636fb8107c5f32088d2741e9fd7a061a5c" +uuid = "94e857df-77ce-4151-89e5-788b33177be4" +version = "0.1.0" + +[[deps.SLEEFPirates]] +deps = ["IfElse", "Static", "VectorizationBase"] +git-tree-sha1 = "456f610ca2fbd1c14f5fcf31c6bfadc55e7d66e0" +uuid = "476501e8-09a2-5ece-8869-fb82de89a1fa" +version = "0.6.43" + +[[deps.SciMLPublic]] +git-tree-sha1 = "ed647f161e8b3f2973f24979ec074e8d084f1bee" +uuid = "431bcebd-1456-4ced-9d72-93c2757fff0b" +version = "1.0.0" + +[[deps.ScientificTypesBase]] +git-tree-sha1 = "a8e18eb383b5ecf1b5e6fc237eb39255044fd92b" +uuid = "30f210dd-8aff-4c5f-94ba-8e64358c1161" +version = "3.0.0" + +[[deps.ScikitLearn]] +deps = ["Compat", "Conda", "DataFrames", "Distributed", "IterTools", "LinearAlgebra", "MacroTools", "Parameters", "Printf", "PyCall", "Random", "ScikitLearnBase", "SparseArrays", "StatsBase", "VersionParsing"] +git-tree-sha1 = "3df098033358431591827bb86cada0bed744105a" +uuid = "3646fa90-6ef7-5e7e-9f22-8aca16db6324" +version = "0.7.0" + +[[deps.ScikitLearnBase]] +deps = ["LinearAlgebra", "Random", "Statistics"] +git-tree-sha1 = "7877e55c1523a4b336b433da39c8e8c08d2f221f" +uuid = "6e75b9c4-186b-50bd-896f-2d2496a4843e" +version = "0.5.0" + +[[deps.SentinelArrays]] +deps = ["Dates", "Random"] +git-tree-sha1 = "712fb0231ee6f9120e005ccd56297abbc053e7e0" +uuid = "91c51154-3ec4-41a3-a24f-3f23e20d615c" +version = "1.4.8" + +[[deps.Serialization]] +uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" +version = "1.11.0" + +[[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" +version = "1.11.0" + +[[deps.Sockets]] +uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +version = "1.11.0" + +[[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.11.0" + +[[deps.SpecialFunctions]] +deps = ["IrrationalConstants", "LogExpFunctions", "OpenLibm_jll", "OpenSpecFun_jll"] +git-tree-sha1 = "f2685b435df2613e25fc10ad8c26dddb8640f547" +uuid = "276daf66-3868-5448-9aa4-cd146d93841b" +version = "2.6.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.StableRNGs]] +deps = ["Random"] +git-tree-sha1 = "4f96c596b8c8258cc7d3b19797854d368f243ddc" +uuid = "860ef19b-820b-49d6-a774-d7a799459cd3" +version = "1.0.4" + +[[deps.Static]] +deps = ["CommonWorldInvalidations", "IfElse", "PrecompileTools", "SciMLPublic"] +git-tree-sha1 = "49440414711eddc7227724ae6e570c7d5559a086" +uuid = "aedffcd0-7271-4cad-89d0-dc628f76c6d3" +version = "1.3.1" + +[[deps.StaticArrayInterface]] +deps = ["ArrayInterface", "Compat", "IfElse", "LinearAlgebra", "PrecompileTools", "Static"] +git-tree-sha1 = "96381d50f1ce85f2663584c8e886a6ca97e60554" +uuid = "0d7ed370-da01-4f52-bd93-41d350b8b718" +version = "1.8.0" +weakdeps = ["OffsetArrays", "StaticArrays"] + + [deps.StaticArrayInterface.extensions] + StaticArrayInterfaceOffsetArraysExt = "OffsetArrays" + StaticArrayInterfaceStaticArraysExt = "StaticArrays" + +[[deps.StaticArrays]] +deps = ["LinearAlgebra", "PrecompileTools", "Random", "StaticArraysCore"] +git-tree-sha1 = "b8693004b385c842357406e3af647701fe783f98" +uuid = "90137ffa-7385-5640-81b9-e52037218182" +version = "1.9.15" +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"] +git-tree-sha1 = "ae3bb1eb3bba077cd276bc5cfc337cc65c3075c0" +uuid = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" +version = "1.11.1" +weakdeps = ["SparseArrays"] + + [deps.Statistics.extensions] + SparseArraysExt = ["SparseArrays"] + +[[deps.StatsAPI]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "9d72a13a3f4dd3795a195ac5a44d7d6ff5f552ff" +uuid = "82ae8749-77ed-4fe6-ae5f-f523153014b0" +version = "1.7.1" + +[[deps.StatsBase]] +deps = ["DataAPI", "DataStructures", "LinearAlgebra", "LogExpFunctions", "Missings", "Printf", "Random", "SortingAlgorithms", "SparseArrays", "Statistics", "StatsAPI"] +git-tree-sha1 = "d1bf48bfcc554a3761a133fe3a9bb01488e06916" +uuid = "2913bbd2-ae8a-5f71-8c99-4fb6c76f3a91" +version = "0.33.21" + +[[deps.StatsFuns]] +deps = ["ChainRulesCore", "InverseFunctions", "IrrationalConstants", "LogExpFunctions", "Reexport", "Rmath", "SpecialFunctions"] +git-tree-sha1 = "5950925ff997ed6fb3e985dcce8eb1ba42a0bbe7" +uuid = "4c63d2b9-4356-54db-8cca-17b64c39e42c" +version = "0.9.18" + +[[deps.StringManipulation]] +deps = ["PrecompileTools"] +git-tree-sha1 = "725421ae8e530ec29bcbdddbe91ff8053421d023" +uuid = "892a3eda-7b42-436c-8928-eab12a02cf0e" +version = "0.4.1" + +[[deps.StructTypes]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "159331b30e94d7b11379037feeb9b690950cace8" +uuid = "856f2bd8-1eba-4b0a-8007-ebc267875bd4" +version = "1.11.0" + +[[deps.StructUtils]] +deps = ["Dates", "UUIDs"] +git-tree-sha1 = "79529b493a44927dd5b13dde1c7ce957c2d049e4" +uuid = "ec057cc2-7a8d-4b58-b3b3-92acb9f63b42" +version = "2.6.0" + + [deps.StructUtils.extensions] + StructUtilsMeasurementsExt = ["Measurements"] + StructUtilsTablesExt = ["Tables"] + + [deps.StructUtils.weakdeps] + Measurements = "eff96d63-e80a-5855-80a2-b1b0885c5ab7" + Tables = "bd369af6-aec1-5ad0-b16a-f7cc5008161c" + +[[deps.StyledStrings]] +uuid = "f489334b-da3d-4c2e-b8f0-e476e12c162b" +version = "1.11.0" + +[[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.7.0+0" + +[[deps.TOML]] +deps = ["Dates"] +uuid = "fa267f1f-6049-4f14-aa54-33bafae1ed76" +version = "1.0.3" + +[[deps.TSVD]] +deps = ["Adapt", "LinearAlgebra"] +git-tree-sha1 = "c39caef6bae501e5607a6caf68dd9ac6e8addbcb" +uuid = "9449cd9e-2762-5aa3-a617-5413e99d722e" +version = "0.4.4" + +[[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.TensorCore]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6" +uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50" +version = "0.1.1" + +[[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" +version = "1.11.0" + +[[deps.ThreadingUtilities]] +deps = ["ManualMemory"] +git-tree-sha1 = "d969183d3d244b6c33796b5ed01ab97328f2db85" +uuid = "8290d209-cae3-49c0-8002-c8c24d57dab5" +version = "0.5.5" + +[[deps.TranscodingStreams]] +git-tree-sha1 = "0c45878dcfdcfa8480052b6ab162cdd138781742" +uuid = "3bb67fe8-82b1-5028-8e26-92a6c54297fa" +version = "0.11.3" + +[[deps.Transducers]] +deps = ["Adapt", "ArgCheck", "BangBang", "Baselet", "CompositionsBase", "ConstructionBase", "DefineSingletons", "Distributed", "InitialValues", "Logging", "Markdown", "MicroCollections", "Requires", "Setfield", "SplittablesBase", "Tables"] +git-tree-sha1 = "3064e780dbb8a9296ebb3af8f440f787bb5332af" +uuid = "28d57a85-8fef-5791-bfe6-a80928e7c999" +version = "0.4.80" + + [deps.Transducers.extensions] + TransducersBlockArraysExt = "BlockArrays" + TransducersDataFramesExt = "DataFrames" + TransducersLazyArraysExt = "LazyArrays" + TransducersOnlineStatsBaseExt = "OnlineStatsBase" + TransducersReferenceablesExt = "Referenceables" + + [deps.Transducers.weakdeps] + 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.Tullio]] +deps = ["DiffRules", "LinearAlgebra", "Requires"] +git-tree-sha1 = "972698b132b9df8791ae74aa547268e977b55f68" +uuid = "bc48ee85-29a4-5162-ae0b-a64e1601d4bc" +version = "0.3.8" + + [deps.Tullio.extensions] + TullioCUDAExt = "CUDA" + TullioChainRulesCoreExt = "ChainRulesCore" + TullioFillArraysExt = "FillArrays" + TullioTrackerExt = "Tracker" + + [deps.Tullio.weakdeps] + CUDA = "052768ef-5323-5732-b1bb-66c8b64840ba" + ChainRulesCore = "d360d2e6-b24c-11e9-a2a3-2a2ae2dbcce4" + FillArrays = "1a297f60-69ca-5386-bcde-b61e274b549b" + Tracker = "9f7883ad-71c0-57eb-9f7f-b5c9e6d3789c" + +[[deps.UUIDs]] +deps = ["Random", "SHA"] +uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +version = "1.11.0" + +[[deps.UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + +[[deps.Unicode]] +uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +version = "1.11.0" + +[[deps.VectorizationBase]] +deps = ["ArrayInterface", "CPUSummary", "HostCPUFeatures", "IfElse", "LayoutPointers", "Libdl", "LinearAlgebra", "SIMDTypes", "Static", "StaticArrayInterface"] +git-tree-sha1 = "d1d9a935a26c475ebffd54e9c7ad11627c43ea85" +uuid = "3d5dd08c-fd9d-11e8-17fa-ed2836048c2f" +version = "0.21.72" + +[[deps.VersionParsing]] +git-tree-sha1 = "58d6e80b4ee071f5efd07fda82cb9fbe17200868" +uuid = "81def892-9a0e-5fdd-b105-ffc91e053289" +version = "1.3.0" + +[[deps.WoodburyMatrices]] +deps = ["LinearAlgebra", "SparseArrays"] +git-tree-sha1 = "c1a7aa6219628fcd757dede0ca95e245c5cd9511" +uuid = "efce3f68-66dc-5838-9240-27a6d6f5f9b6" +version = "1.0.0" + +[[deps.Xorg_libX11_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xtrans_jll"] +git-tree-sha1 = "b5899b25d17bf1889d25906fb9deed5da0c15b3b" +uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc" +version = "1.8.12+0" + +[[deps.Xorg_libXau_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "aa1261ebbac3ccc8d16558ae6799524c450ed16b" +uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec" +version = "1.0.13+0" + +[[deps.Xorg_libXdmcp_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "52858d64353db33a56e13c341d7bf44cd0d7b309" +uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05" +version = "1.1.6+0" + +[[deps.Xorg_libXext_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "a4c0ee07ad36bf8bbce1c3bb52d21fb1e0b987fb" +uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3" +version = "1.3.7+0" + +[[deps.Xorg_libXrender_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "7ed9347888fac59a618302ee38216dd0379c480d" +uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa" +version = "0.9.12+0" + +[[deps.Xorg_libxcb_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libXau_jll", "Xorg_libXdmcp_jll"] +git-tree-sha1 = "bfcaf7ec088eaba362093393fe11aa141fa15422" +uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b" +version = "1.17.1+0" + +[[deps.Xorg_xtrans_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a63799ff68005991f9d9491b6e95bd3478d783cb" +uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10" +version = "1.6.0+0" + +[[deps.Zlib_jll]] +deps = ["Libdl"] +uuid = "83775a58-1f1d-513f-b197-d71354ab007a" +version = "1.2.13+1" + +[[deps.ZygoteRules]] +deps = ["ChainRulesCore", "MacroTools"] +git-tree-sha1 = "434b3de333c75fc446aa0d19fc394edafd07ab08" +uuid = "700de1a5-db45-46bc-99cf-38207098b444" +version = "0.2.7" + +[[deps.libaom_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "371cc681c00a3ccc3fbc5c0fb91f58ba9bec1ecf" +uuid = "a4ae2306-e953-59d6-aa16-d00cac43593b" +version = "3.13.1+0" + +[[deps.libass_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "125eedcb0a4a0bba65b657251ce1d27c8714e9d6" +uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" +version = "0.17.4+0" + +[[deps.libblastrampoline_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" +version = "5.11.0+0" + +[[deps.libfdk_aac_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "646634dd19587a56ee2f1199563ec056c5f228df" +uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" +version = "2.0.4+0" + +[[deps.libpng_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "07b6a107d926093898e82b3b1db657ebe33134ec" +uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f" +version = "1.6.50+0" + +[[deps.libvorbis_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll"] +git-tree-sha1 = "11e1772e7f3cc987e9d3de991dd4f6b2602663a5" +uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a" +version = "1.3.8+0" + +[[deps.nghttp2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" +version = "1.59.0+0" + +[[deps.oneTBB_jll]] +deps = ["Artifacts", "JLLWrappers", "LazyArtifacts", "Libdl"] +git-tree-sha1 = "1350188a69a6e46f799d3945beef36435ed7262f" +uuid = "1317d2d5-d96f-522e-a858-c73665f53c3e" +version = "2022.0.0+1" + +[[deps.p7zip_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" +version = "17.4.0+2" + +[[deps.x264_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "14cc7083fc6dff3cc44f2bc435ee96d06ed79aa7" +uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a" +version = "10164.0.1+0" + +[[deps.x265_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e7b67590c14d487e734dcb925924c5dc43ec85f3" +uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76" +version = "4.1.0+0" From c3db2d53862857659bf06d00c29ecdad3249720d Mon Sep 17 00:00:00 2001 From: odunbar Date: Tue, 18 Nov 2025 16:56:26 -0800 Subject: [PATCH 21/32] added codecov by testing different obs-noise-cov type conversion to linear maps --- src/Utilities.jl | 91 +++++++++++--------------------------- test/Utilities/runtests.jl | 60 +++++++++++++++++++++++++ 2 files changed, 86 insertions(+), 65 deletions(-) diff --git a/src/Utilities.jl b/src/Utilities.jl index 0fbaf2587..258c322a1 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -121,11 +121,22 @@ This compact map constructs the following form of the Linear map f: kwargs: ------ When computing the svd internally from an abstract matrix -- `svd_dim_max=4000`: this switches to an approximate tsvd approach when applying to covariance matrices above dimension 4000 -- `tsvd_rank=50`: when using tsvd, what rank to truncate at. - +- `svd_dim_max=3000`: this switches to an approximate svd approach when applying to covariance matrices above dimension 3000 +- `psvd_or_tsvd="psvd"`: use psvd or tsvd for approximating svd for large matrices +- `tsvd_max_rank=50`: when using tsvd, what max rank to use. high rank = higher accuracy +- `psvd_kwargs=(; rtol=1e-2)`: when using psvd, what kwargs to pass. lower rtol = higher accuracy + +Recommended: quick & inaccurate -> slow and more accurate +- very large matrices - start with tsvd with very low rank, and increase +- mid-size matrices - psvd with very high rtol, and decrease """ -function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank = 50) +function create_compact_linear_map( + A; + svd_dim_max = 3000, + psvd_or_tsvd = "psvd", + tsvd_max_rank = 50, + psvd_kwargs = (; rtol = 1e-1), +) Avec = isa(A, AbstractVector) ? A : [A] # explicitly write the loop here: @@ -153,10 +164,17 @@ function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank = 50) push!(ds, zeros(size(a, 1))) bsize[1] = size(a, 1) else - svda = EKP.tsvd_mat(a, min(tsvd_rank, size(a, 1) - 1)) # swap to tsvd for performance - push!(Us, svda.U) - push!(Ss, svda.S) - push!(VTs, svda.Vt) + if psvd_or_tsvd == "psvd" + svda = psvd(a; psvd_kwargs...) + push!(Us, svda[1]) + push!(Ss, svda[2]) + push!(VTs, svda[3]') + else + svda = tsvd_mat(a, min(tsvd_max_rank, size(a, 1) - 1)) + push!(Us, svda.U) + push!(Ss, svda.S) + push!(VTs, svda.Vt) + end push!(ds, zeros(size(a, 1))) bsize[1] = size(a, 1) end @@ -203,63 +221,6 @@ function create_compact_linear_map(A; svd_dim_max = 4000, tsvd_rank = 50) end -#= -""" -$(TYPEDSIGNATURES) - -svd of a sum of two matrices `A` and `B` in svd form without building A+B directly. - -This is useful when A and B are low rank, but high dimensional and provided as SVD types. (e.g. from `EKP.tsvd_cov_from_samples`) -""" -function svd_of_sum(svdA::SS1,svdB::SS2) where { SS1 <: SVD, SS2 <: SVD} - - # treat A + B as just "low rank" - # can write A+B = L * R = [Ua Ub] * [ Sa * Va'; Sb * Vb'] - L = [svdA.U svdB.U] # N x (r1+r2) - R = [Diagonal(svdA.S) * svdA.Vt ; Diagonal(svdB.S) * svdB.Vt] # (r1+r2) x N - qrl = qr(L) # Q1 R1 - qrr = qr(R') # Q2 R2 - # A+B = Q_1 * R_1 * R_2' * Q_2' = Q1 * (ss.U * ss.S * ss.V' * Q2' = (Q1 ss.U) * ss.S * (Q2 ss.V)' - ss = svd(qrl.R*qrr.R') - - return SVD(qrl.Q*ss.U, ss.S, ss.Vt*qrr.Q') # build the new svd - -end - -function inv_sqrt_of_svdplusd(a) - D = a.diag_cov - D += sqrt(eps())*I # minimum tolerance for some operations below - iD = inv(D) # - irD = sqrt.(iD) - ss = a.svd_cov - U = ss.U - S = Diagonal(ss.S) - - # begin computing the whitening transform - M = inv(S) + U'*iD*U - riM = sqrt(inv(M)) - B = irD*U - C = riM*B'*B*riM - ev = eigen(C) - V = ev.vectors - # if A = B*riM => - # (I-AA')^{1/2} = I - A * Chat * A' - # = I - A * V * Diag(chat) * V' * A' - # LHS evals sqrt(1-σ_i^2), rhs evals 1 - chat * σ_i^2 - # => chat = (1 - sqrt(1-σ_i^2))/(σ_i^2) # where σ_i is eval of A = sqrt(ev.values) - ev_correction = Diagonal((1.0 .-sqrt.(1.0 .- ev.values)) ./ ev.values) - - # Then, (I - BM^{-1}B')^{1/2} = I - B M^{-1/2} V sv V' M^{-1/2} B' - rt_ImBiMB = I - B * riM * V * ev_correction * V' * riM * B' - # Idea is that woodbury: Σ^{-1} = D^{-1/2} * ImBiMB * D^{-1/2} - # Then W = rt_ImBiMB * D^{-1/2} satisfies W Σ W' = I - W = rt_ImBiMB * irD # perhaps keep this in a compact form until use: - return W -end -=# - - - # Data processing tooling: abstract type DataProcessor end diff --git a/test/Utilities/runtests.jl b/test/Utilities/runtests.jl index 7784a969b..1c1477d2b 100644 --- a/test/Utilities/runtests.jl +++ b/test/Utilities/runtests.jl @@ -72,6 +72,64 @@ end diff = encoder_kwargs.observation - [get_obs(obs), get_obs(obs2)] @test all([all(isapprox.(dd, 0.0, atol = 1e-12)) for dd in diff]) + # Building a blocked noise covariance with different types to test creating linear maps + # Abstract mats (small and large (> svd_dim_max)), SVD, SVDplusD + d = 1000 + A = [] + svd_dim_max = 999 # defaul 4000, reduce here for speed/memory + X = randn(100, d) + X = X' * X # make posdef + push!(A, X[1:50, 1:50]) + push!(A, X) + + μ = zeros(d) + sam = rand(d, 30) + Σ = tsvd_cov_from_samples(sam) + push!(A, Σ) + + D = Diagonal(0.001 * sqrt.(collect(1:d))) + ΣpD = SVDplusD(Σ, D) + push!(A, ΣpD) + + + as = [50, d, d, d] + cas = cumsum(as) + block_id = [1:cas[1], (cas[1] + 1):cas[2], (cas[2] + 1):cas[3], (cas[3] + 1):cas[4]] + Afull = zeros(sum(as), sum(as)) + + Afull[1:cas[1], 1:cas[1]] = A[1] + Afull[(cas[1] + 1):cas[2], (cas[1] + 1):cas[2]] = A[2] + Afull[(cas[2] + 1):cas[3], (cas[2] + 1):cas[3]] = A[3].U * Diagonal(A[3].S) * A[3].Vt + Afull[(cas[3] + 1):cas[4], (cas[3] + 1):cas[4]] = + A[4].svd_cov.U * Diagonal(A[4].svd_cov.S) * A[4].svd_cov.Vt + A[4].diag_cov + + + for svd_type in ["psvd", "tsvd"] + psvd_kwargs = (; rtol = 1e-3) # make very small for testing + tsvd_max_rank = 30 # often only stable small ranks + Amap = create_compact_linear_map( + A; + svd_dim_max = svd_dim_max, + psvd_or_tsvd = svd_type, + psvd_kwargs = psvd_kwargs, + tsvd_max_rank = tsvd_max_rank, + ) + Amat_from_map = Matrix(Amap) + + for (i, ids) in enumerate(block_id) + if i == 2 # the case where we do psvd on a full matrix - can be very high error expected (particularly tsvd + if svd_type == "psvd" + @test norm(Afull[ids, ids] - Amat_from_map[ids, ids]) < 1e-14 * length(ids)^2 + else + @test norm(Afull[ids, ids] - Amat_from_map[ids, ids]) < 1e-2 * length(ids)^2 # bad! + end + + else + @test norm(Afull[ids, ids] - Amat_from_map[ids, ids]) < 1e-14 * length(ids)^2 + end + end + end + # Tests for get_structure_vec and get_structure_mat structure_vecs = Dict("a" => [1, 2, 3], "b" => [4, 5, 6]) @@ -437,7 +495,9 @@ end μ = zeros(d) sam = rand(d, 30) Σ = tsvd_cov_from_samples(sam) + D = Diagonal(0.001 * sqrt.(collect(1:d))) noise_samples = Σ.U * (sqrt.(Σ.S) .* Σ.Vt) * rand(MvNormal(μ, I), m) + y += noise_samples io_pairs = PairedDataContainer(x, y, data_are_columns = true) From ccb1517c5c97585840835881856cfd5b58001bd0 Mon Sep 17 00:00:00 2001 From: odunbar Date: Wed, 19 Nov 2025 10:40:30 -0800 Subject: [PATCH 22/32] remove redundant islinear function, add == tests --- src/Utilities.jl | 9 +-------- test/Utilities/runtests.jl | 7 +++++++ 2 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/Utilities.jl b/src/Utilities.jl index 258c322a1..36bd3cefa 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -28,6 +28,7 @@ export create_encoder_schedule, decode_data, decode_structure_matrix, norm, + isequal_linear, encoder_kwargs_from @@ -276,14 +277,6 @@ function isequal_linear( return true end -function isequal_linear(A::AMorV1, B::AMorV2; kwargs...) where {AMorV1 <: AbstractVecOrMat, AMorV2 <: AbstractVecOrMat} - if !(size(A) == size(B)) - return false - end - - return all(isequal_linear(a, b; kwargs...) for (a, b) in zip(A[:], B[:])) -end - function Base.:(==)(a::LM1, b::LM2) where {LM1 <: LinearMap, LM2 <: LinearMap} n = size(a, 2) if n < 1e4 # gets expensive diff --git a/test/Utilities/runtests.jl b/test/Utilities/runtests.jl index 1c1477d2b..f9140fca0 100644 --- a/test/Utilities/runtests.jl +++ b/test/Utilities/runtests.jl @@ -104,6 +104,8 @@ end A[4].svd_cov.U * Diagonal(A[4].svd_cov.S) * A[4].svd_cov.Vt + A[4].diag_cov + @test_throws ArgumentError create_compact_linear_map(3 * I) # needs dims + for svd_type in ["psvd", "tsvd"] psvd_kwargs = (; rtol = 1e-3) # make very small for testing tsvd_max_rank = 30 # often only stable small ranks @@ -116,6 +118,11 @@ end ) Amat_from_map = Matrix(Amap) + # some extra tests for the ==/is_equal overrides + @test Amap == Amap + Amap2 = create_compact_linear_map([A[1]]) + @test !(Amap == Amap2) + for (i, ids) in enumerate(block_id) if i == 2 # the case where we do psvd on a full matrix - can be very high error expected (particularly tsvd if svd_type == "psvd" From f06b46704997553751b681aa0cc13197413a87af Mon Sep 17 00:00:00 2001 From: odunbar Date: Wed, 26 Nov 2025 14:57:38 -0800 Subject: [PATCH 23/32] consistent with rebase --- Project.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Project.toml b/Project.toml index dcb82c9b7..8a72abcef 100644 --- a/Project.toml +++ b/Project.toml @@ -46,7 +46,7 @@ GaussianProcesses = "0.12" KernelFunctions = "0.10.64" LinearMaps = "3.11.4" LowRankApprox = "0.5.5" -MCMCChains = "4.14, 5, 6, 7" +MCMCChains = "7" Plots = "1.41.1" Printf = "1" ProgressBars = "1" From 0e7fc1a988e5893abe1d4ae01f8e7b70b9619689 Mon Sep 17 00:00:00 2001 From: odunbar Date: Tue, 2 Dec 2025 13:47:19 -0800 Subject: [PATCH 24/32] reviewer comments --- src/MarkovChainMonteCarlo.jl | 1 - src/Utilities.jl | 6 ++++-- src/Utilities/decorrelator.jl | 2 +- src/Utilities/elementwise_scaler.jl | 2 -- 4 files changed, 5 insertions(+), 6 deletions(-) diff --git a/src/MarkovChainMonteCarlo.jl b/src/MarkovChainMonteCarlo.jl index e8688b266..06319d33a 100644 --- a/src/MarkovChainMonteCarlo.jl +++ b/src/MarkovChainMonteCarlo.jl @@ -34,7 +34,6 @@ export EmulatorPosteriorModel, optimize_stepsize, get_posterior, get_sample_kwargs, - get_init_params, sample, esjd diff --git a/src/Utilities.jl b/src/Utilities.jl index 36bd3cefa..cd35a69ab 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -252,9 +252,11 @@ function isequal_linear( ) where {LM1 <: LinearMap, LM2 <: LinearMap} m, n = size(A) if !(n == size(B, 2)) + @warn "Comparing equality of linear maps with size ($(m), $(n)) and ($(size(B,1)), $(size(B,2))). Was this intended?" return false end if !(m == size(B, 1)) + @warn "Comparing equality of linear maps with size ($(m), $(n)) and ($(size(B,1)),$(size(B,2))). Was this intended?" return false end @@ -269,7 +271,7 @@ function isequal_linear( else AmB = A * e - B * e end - if !(norm(AmB) <= n * tol) + if !(norm(AmB) <= sqrt(n) * tol) return false end e[j] -= 1 @@ -481,7 +483,7 @@ function initialize_and_encode_with_schedule!( ) where {VV <: AbstractVector, PDC <: PairedDataContainer} processed_io_pairs = deepcopy(io_pairs) - # We additionally convert to `mats` into a linear-maps for flexible handling of massive covariances. In a matrix-free manner + # We additionally convert the `mats` into a linear-maps for flexible handling of massive covariances. In a matrix-free manner input_structure_mats = deepcopy(input_structure_mats) if !isnothing(prior_cov) (input_structure_mats[:prior_cov] = prior_cov) diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index 24f1b99b3..b3218f5c8 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -258,7 +258,7 @@ function initialize_processor!( # psvd: approximates SVD to a given error tolerance (can truncate too) [good for full svd approx] # tsvd: truncates to dimension where resulting SVD has the same s.vals as the true [good of low rank approx] max_svd_size = 3000 - if max(size(decorrelation_map)...) < max_svd_size + if maximum(size(decorrelation_map)) < max_svd_size # svd options svdA = svd(Matrix(decorrelation_map)) rk = rank(Matrix(decorrelation_map)) diff --git a/src/Utilities/elementwise_scaler.jl b/src/Utilities/elementwise_scaler.jl index 52f163081..1065c4396 100644 --- a/src/Utilities/elementwise_scaler.jl +++ b/src/Utilities/elementwise_scaler.jl @@ -247,7 +247,6 @@ Apply the `ElementwiseScaler` encoder to a provided structure matrix. If the str function encode_structure_matrix(es::ElementwiseScaler, structure_matrix::SM) where {SM <: StructureMatrix} encoder_mat = get_struct_encoder_mat(es)[1] return encoder_mat * structure_matrix * encoder_mat' - #return Diagonal(1 ./ get_scale(es)) * structure_matrix * Diagonal(1 ./ get_scale(es)) end """ @@ -258,5 +257,4 @@ Apply the `ElementwiseScaler` decoder to a provided structure matrix. If the str function decode_structure_matrix(es::ElementwiseScaler, enc_structure_matrix::SM) where {SM <: StructureMatrix} decoder_mat = get_struct_decoder_mat(es)[1] return decoder_mat * enc_structure_matrix * decoder_mat' - # return Diagonal(get_scale(es)) * enc_structure_matrix * Diagonal(get_scale(es)) end From 4c3b231ef317477c63573b311916b2f3a62f349d Mon Sep 17 00:00:00 2001 From: odunbar Date: Tue, 2 Dec 2025 13:56:39 -0800 Subject: [PATCH 25/32] init_params -> initial_params --- test/MarkovChainMonteCarlo/runtests.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/MarkovChainMonteCarlo/runtests.jl b/test/MarkovChainMonteCarlo/runtests.jl index dd7844136..336d98a40 100644 --- a/test/MarkovChainMonteCarlo/runtests.jl +++ b/test/MarkovChainMonteCarlo/runtests.jl @@ -261,7 +261,7 @@ function mcmc_test_template( if extra_tests mcmc = MCMCWrapper(mcmc_alg, obs_sample, prior, em) # without ICs - @test all(isapprox.(getfield(get_sample_kwargs(mcmc), :init_params), mean(prior))) + @test all(isapprox.(getfield(get_sample_kwargs(mcmc), :initial_params), mean(prior))) end mcmc = MCMCWrapper(mcmc_alg, obs_sample, prior, em; init_params = init_params) From 8291d424fd906f59ade6b14bbf9d726a38728096 Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 5 Dec 2025 14:02:56 -0800 Subject: [PATCH 26/32] no more UniformScaling types --- src/GaussianProcess.jl | 9 +-------- src/ScalarRandomFeature.jl | 7 +------ 2 files changed, 2 insertions(+), 14 deletions(-) diff --git a/src/GaussianProcess.jl b/src/GaussianProcess.jl index 0f2148885..4f8a089b7 100644 --- a/src/GaussianProcess.jl +++ b/src/GaussianProcess.jl @@ -194,14 +194,7 @@ function build_models!( regularization = if isempty(output_structure_mats) 1.0 * ones(N_models) else - output_structure_mat = Matrix(get_structure_mat(output_structure_mats)) - # in small space one can convert to a matrix - if isa(output_structure_mat, UniformScaling) - output_structure_mat.λ * ones(N_models) - else - diag(output_structure_mat) - end - + output_structure_mat = diag(Matrix(get_structure_mat(output_structure_mats))) end regularization_noise = regularization .* gp.alg_reg_noise logstd_regularization_noise = log.(sqrt.(regularization_noise)) diff --git a/src/ScalarRandomFeature.jl b/src/ScalarRandomFeature.jl index 2e2b3bfd7..a6264a83f 100644 --- a/src/ScalarRandomFeature.jl +++ b/src/ScalarRandomFeature.jl @@ -404,12 +404,7 @@ function build_models!( regularization = if isempty(output_structure_mats) 1.0 * I(n_rfms) else - output_structure_mat = Matrix(get_structure_mat(output_structure_mats)) - if isa(output_structure_mat, UniformScaling) - output_structure_mat - else - Diagonal(output_structure_mat) - end + output_structure_mat = Diagonal(Matrix(get_structure_mat(output_structure_mats))) end @info ( From 82e7e84c51d2d261ea2b453075e386bb7a19745b Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 5 Dec 2025 16:44:58 -0800 Subject: [PATCH 27/32] canges to utils from review --- src/Utilities.jl | 39 ++++++++------------------ src/Utilities/canonical_correlation.jl | 4 +-- src/Utilities/decorrelator.jl | 20 ++++++------- src/Utilities/elementwise_scaler.jl | 6 ++-- 4 files changed, 25 insertions(+), 44 deletions(-) diff --git a/src/Utilities.jl b/src/Utilities.jl index cd35a69ab..4dd11ffb8 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -14,8 +14,6 @@ using ..DataContainers using LowRankApprox using TSVD -import LinearAlgebra: norm - export get_training_points export create_compact_linear_map export PairedDataContainerProcessor, DataContainerProcessor @@ -27,7 +25,6 @@ export create_encoder_schedule, encode_structure_matrix, decode_data, decode_structure_matrix, - norm, isequal_linear, encoder_kwargs_from @@ -95,6 +92,12 @@ function encoder_kwargs_from(os::OS) where {OS <: ObservationSeries} observations = get_observations(os) obs_vec = [get_obs(obs) for obs in observations] obs_noise_cov = get_obs_noise_cov(observations[1], build = false) + if !all([get_obs_noise_cov(observations[i], build = false) == obs_noise_vec for i in length(observations)]) + @warn(""" + Detected that observation covariances vary for different observations. + Encoder kwarg `:obs_noise_cov` will be set to the FIRST of these covariances for the purpose of data processing. + """) + end return (; obs_noise_cov = obs_noise_cov, observation = obs_vec) end @@ -148,7 +151,7 @@ function create_compact_linear_map( batches = [] shift = 0 for a in Avec - bsize = [0] + bsize = 0 if isa(a, UniformScaling) throw( ArgumentError( @@ -163,7 +166,7 @@ function create_compact_linear_map( push!(Ss, svda.S) push!(VTs, svda.Vt) push!(ds, zeros(size(a, 1))) - bsize[1] = size(a, 1) + bsize = size(a, 1) else if psvd_or_tsvd == "psvd" svda = psvd(a; psvd_kwargs...) @@ -177,7 +180,7 @@ function create_compact_linear_map( push!(VTs, svda.Vt) end push!(ds, zeros(size(a, 1))) - bsize[1] = size(a, 1) + bsize = size(a, 1) end elseif isa(a, SVD) svda = a @@ -185,7 +188,7 @@ function create_compact_linear_map( push!(Ss, svda.S) push!(VTs, svda.Vt) push!(ds, zeros(size(a.U, 1))) - bsize[1] = size(a.U, 1) + bsize = size(a.U, 1) elseif isa(a, SVDplusD) svda = a.svd_cov diaga = (a.diag_cov).diag @@ -193,10 +196,10 @@ function create_compact_linear_map( push!(Ss, svda.S) push!(VTs, svda.Vt) push!(ds, diaga) - bsize[1] = length(diaga) + bsize = length(diaga) end - batch = (shift + 1):(shift + bsize[1]) + batch = (shift + 1):(shift + bsize) push!(batches, batch) shift = batch[end] end @@ -293,24 +296,6 @@ Base.:(==)(a::DCP1, b::DCP2) where {DCP1 <: DataContainerProcessor, DCP2 <: Data Base.:(==)(a::PDCP1, b::PDCP2) where {PDCP1 <: PairedDataContainerProcessor, PDCP2 <: PairedDataContainerProcessor} = all(getfield(a, f) == getfield(b, f) for f in fieldnames(PDCP1)) - -function norm_linear_map(A::LM, p::Real = 2; n_eval = nothing) where {LM <: LinearMap} - m, n = size(A) - # test on standard basis (up to n_eval tests) - basis_id = isa(n_eval, Nothing) ? collect(1:n) : randperm(rng, n)[1:n_eval] - - e = vec(zeros(eltype(A), n)) - norm_val = [0.0] - for j in basis_id - e[j] += 1 - norm_val[1] += 1.0 / n * norm(A * e, p) - e[j] -= 1 - end - return norm_val[1] -end - -LinearAlgebra.norm(A::LM, p::Real = 2; lm_kwargs...) where {LM <: LinearMap} = norm_linear_map(A, p; lm_kwargs...) - #### function get_structure_vec(structure_vecs, name = nothing) diff --git a/src/Utilities/canonical_correlation.jl b/src/Utilities/canonical_correlation.jl index 8ffe78c11..9e52cc1fd 100644 --- a/src/Utilities/canonical_correlation.jl +++ b/src/Utilities/canonical_correlation.jl @@ -187,7 +187,7 @@ function encode_data(cc::CanonicalCorrelation, data::MM) where {MM <: AbstractMa data_mean = get_data_mean(cc)[1] encoder_mat = get_encoder_mat(cc)[1] out = zeros(size(encoder_mat, 1), size(data, 2)) - mul!(out, encoder_mat, deepcopy(data) .- data_mean) + mul!(out, encoder_mat, data .- data_mean) return out end @@ -200,7 +200,7 @@ function decode_data(cc::CanonicalCorrelation, data::MM) where {MM <: AbstractMa data_mean = get_data_mean(cc)[1] decoder_mat = get_decoder_mat(cc)[1] out = zeros(size(decoder_mat, 1), size(data, 2)) - mul!(out, decoder_mat, deepcopy(data)) + mul!(out, decoder_mat, data) return out .+ data_mean end diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index b3218f5c8..1ad4d52e6 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -250,6 +250,8 @@ function initialize_processor!( psvd_kwargs = get_psvd_kwargs(dd) ret_var = get_retain_var(dd) + max_svd_size = 3000 # max size to perform true SVD + n_norm_compute = 10 # number of repeated norm computations to estimate total variance (if ret_var < 1) S = [] Vt = [] @@ -257,7 +259,7 @@ function initialize_processor!( # svd: convert to matrix and perform actual SVD. [good for small matrix (d < ~3000)] # psvd: approximates SVD to a given error tolerance (can truncate too) [good for full svd approx] # tsvd: truncates to dimension where resulting SVD has the same s.vals as the true [good of low rank approx] - max_svd_size = 3000 + if maximum(size(decorrelation_map)) < max_svd_size # svd options svdA = svd(Matrix(decorrelation_map)) @@ -282,8 +284,9 @@ function initialize_processor!( if ret_var < 1.0 # tsvd option # approximate Frobenius norm of the map - norm_approx = zeros(10) - for i in 1:10 + + norm_approx = zeros(n_norm_compute) + for i in 1:n_norm_compute samples = randn(size(decorrelation_map, 1), n_totvar_samples) norm_approx[i] = 1 / n_totvar_samples * sum([sum(abs2, (decorrelation_map * x)) for x in eachcol(samples)]) @@ -306,14 +309,11 @@ function initialize_processor!( @warn "Maximum tolerance of SVD truncation hit ($(rank_max)), consider increasing `rank_max` in decorrelator, this may also result from `retain_var` being close to 1, while `n_totvar_samples` is low. Proceeding with final iterant." push!(S, Stmp) push!(Vt, Vtmp') - end - end else # psvd option - # check V or Vt - _, Stmp, Vtmp = psvd(decorrelation_map; psvd_kwargs...) # randomized algorithm to avoid building the matrix, but this will be big. + _, Stmp, Vtmp = psvd(decorrelation_map; psvd_kwargs...) # randomized algorithm to avoid building the matrix. if length(Stmp) < size(data, 1) @info " truncating at $(length(Stmp))/$(size(data,1)), as low-rank data detected" @@ -324,8 +324,6 @@ function initialize_processor!( end end - - # Enforce a sign convention for the singular vectors (rows Vt have positive first entry) for (j, row) in enumerate(eachrow(Vt[1])) if row[1] < 0 @@ -363,7 +361,7 @@ function encode_data(dd::Decorrelator, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(dd)[1] encoder_mat = get_encoder_mat(dd)[1] out = zeros(size(encoder_mat, 1), size(data, 2)) - mul!(out, encoder_mat, deepcopy(data) .- data_mean) + mul!(out, encoder_mat, data .- data_mean) return out end @@ -376,7 +374,7 @@ function decode_data(dd::Decorrelator, data::MM) where {MM <: AbstractMatrix} data_mean = get_data_mean(dd)[1] decoder_mat = get_decoder_mat(dd)[1] out = zeros(size(decoder_mat, 1), size(data, 2)) - mul!(out, decoder_mat, deepcopy(data)) + mul!(out, decoder_mat, data) return out .+ data_mean end diff --git a/src/Utilities/elementwise_scaler.jl b/src/Utilities/elementwise_scaler.jl index 1065c4396..f3f3f5973 100644 --- a/src/Utilities/elementwise_scaler.jl +++ b/src/Utilities/elementwise_scaler.jl @@ -208,9 +208,8 @@ $(TYPEDSIGNATURES) Apply the `ElementwiseScaler` encoder, on a columns-are-data matrix """ function encode_data(es::ElementwiseScaler, data::MM) where {MM <: AbstractMatrix} - out = deepcopy(data) enc = get_data_encoder_mat(es)[1] - mul!(out, enc, out) # must use this form to get matrix output of enc*out + mul!(out, enc, data) # must use this form to get matrix output of enc*out return out end @@ -220,9 +219,8 @@ $(TYPEDSIGNATURES) Apply the `ElementwiseScaler` decoder, on a columns-are-data matrix """ function decode_data(es::ElementwiseScaler, data::MM) where {MM <: AbstractMatrix} - out = deepcopy(data) dec = get_data_decoder_mat(es)[1] - mul!(out, dec, out) # must use this form to get matrix output of dec*out + mul!(out, dec, data) # must use this form to get matrix output of dec*out return out end From 9b5641a96c42c575493a83f30ecdb099442e5fbe Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 5 Dec 2025 16:46:07 -0800 Subject: [PATCH 28/32] repeat test for all times --- test/MarkovChainMonteCarlo/runtests.jl | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/test/MarkovChainMonteCarlo/runtests.jl b/test/MarkovChainMonteCarlo/runtests.jl index 336d98a40..11c40d397 100644 --- a/test/MarkovChainMonteCarlo/runtests.jl +++ b/test/MarkovChainMonteCarlo/runtests.jl @@ -243,7 +243,6 @@ function mcmc_test_template( prior::ParameterDistribution, σ2_y, em::Emulator; - extra_tests = false, exp_name = "test", mcmc_alg = RWMHSampling(), obs_sample = [1.0], @@ -258,12 +257,10 @@ function mcmc_test_template( end init_params = vec(collect(init_params)) # scalar or Vector -> Vector - if extra_tests - mcmc = MCMCWrapper(mcmc_alg, obs_sample, prior, em) # without ICs - - @test all(isapprox.(getfield(get_sample_kwargs(mcmc), :initial_params), mean(prior))) - end + mcmc = MCMCWrapper(mcmc_alg, obs_sample, prior, em) # without ICs + @test all(isapprox.(getfield(get_sample_kwargs(mcmc), :initial_params), mean(prior))) + mcmc = MCMCWrapper(mcmc_alg, obs_sample, prior, em; init_params = init_params) # First let's run a short chain to determine a good step size new_step = optimize_stepsize(mcmc; init_stepsize = step, N = 5000, target_acc = target_acc) @@ -381,7 +378,7 @@ end # test various MCMC methods new_step_1, posterior_mean_1, chain_1 = - mcmc_test_template(prior, σ2_y, em_1; extra_tests = true, exp_name = "gpjl_1d", mcmc_params...) + mcmc_test_template(prior, σ2_y, em_1; exp_name = "gpjl_1d", mcmc_params...) esjd1 = esjd(chain_1) @info "ESJD [GPJL,RW] = $esjd1" @test isapprox(new_step_1, 0.125; atol = 0.125) From f83d30bac025e4fb27a73a50c269f690df70e65f Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 5 Dec 2025 16:49:34 -0800 Subject: [PATCH 29/32] format --- test/MarkovChainMonteCarlo/runtests.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/MarkovChainMonteCarlo/runtests.jl b/test/MarkovChainMonteCarlo/runtests.jl index 11c40d397..3775939eb 100644 --- a/test/MarkovChainMonteCarlo/runtests.jl +++ b/test/MarkovChainMonteCarlo/runtests.jl @@ -260,7 +260,7 @@ function mcmc_test_template( mcmc = MCMCWrapper(mcmc_alg, obs_sample, prior, em) # without ICs @test all(isapprox.(getfield(get_sample_kwargs(mcmc), :initial_params), mean(prior))) - + mcmc = MCMCWrapper(mcmc_alg, obs_sample, prior, em; init_params = init_params) # First let's run a short chain to determine a good step size new_step = optimize_stepsize(mcmc; init_stepsize = step, N = 5000, target_acc = target_acc) From cb2ceaa406e672f7016fc6035d19f500bd0a7e43 Mon Sep 17 00:00:00 2001 From: odunbar Date: Fri, 5 Dec 2025 17:20:28 -0800 Subject: [PATCH 30/32] bugfix --- src/Utilities.jl | 2 +- src/Utilities/elementwise_scaler.jl | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Utilities.jl b/src/Utilities.jl index 4dd11ffb8..13bf0ad8b 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -92,7 +92,7 @@ function encoder_kwargs_from(os::OS) where {OS <: ObservationSeries} observations = get_observations(os) obs_vec = [get_obs(obs) for obs in observations] obs_noise_cov = get_obs_noise_cov(observations[1], build = false) - if !all([get_obs_noise_cov(observations[i], build = false) == obs_noise_vec for i in length(observations)]) + if !all([get_obs_noise_cov(observations[i], build = false) == obs_noise_cov for i in length(observations)]) @warn(""" Detected that observation covariances vary for different observations. Encoder kwarg `:obs_noise_cov` will be set to the FIRST of these covariances for the purpose of data processing. diff --git a/src/Utilities/elementwise_scaler.jl b/src/Utilities/elementwise_scaler.jl index f3f3f5973..a6521cd8d 100644 --- a/src/Utilities/elementwise_scaler.jl +++ b/src/Utilities/elementwise_scaler.jl @@ -208,6 +208,7 @@ $(TYPEDSIGNATURES) Apply the `ElementwiseScaler` encoder, on a columns-are-data matrix """ function encode_data(es::ElementwiseScaler, data::MM) where {MM <: AbstractMatrix} + out = zeros(size(data)) enc = get_data_encoder_mat(es)[1] mul!(out, enc, data) # must use this form to get matrix output of enc*out return out @@ -219,6 +220,7 @@ $(TYPEDSIGNATURES) Apply the `ElementwiseScaler` decoder, on a columns-are-data matrix """ function decode_data(es::ElementwiseScaler, data::MM) where {MM <: AbstractMatrix} + out = zeros(size(data)) dec = get_data_decoder_mat(es)[1] mul!(out, dec, data) # must use this form to get matrix output of dec*out return out From 1874bf6ab726855fc59fa72b5594a35fd960a5db Mon Sep 17 00:00:00 2001 From: odunbar Date: Sat, 6 Dec 2025 19:06:01 -0800 Subject: [PATCH 31/32] improved norms --- src/Utilities.jl | 21 +++++++++++++++++++++ src/Utilities/decorrelator.jl | 16 +++++++--------- 2 files changed, 28 insertions(+), 9 deletions(-) diff --git a/src/Utilities.jl b/src/Utilities.jl index 13bf0ad8b..c8c29c4b9 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -14,6 +14,8 @@ using ..DataContainers using LowRankApprox using TSVD +import LinearAlgebra: norm + export get_training_points export create_compact_linear_map export PairedDataContainerProcessor, DataContainerProcessor @@ -25,6 +27,8 @@ export create_encoder_schedule, encode_structure_matrix, decode_data, decode_structure_matrix, + norm, + norm_linear_map, isequal_linear, encoder_kwargs_from @@ -224,6 +228,23 @@ function create_compact_linear_map( end +function norm_linear_map(A::LM, p::Real = 2; n_eval = nothing, rng = Random.default_rng()) where {LM <: LinearMap} + m, n = size(A) + + # use unit-normalized gaussian vectors + n_basis = isa(n_eval, Nothing) ? n : n_eval + samples = randn(n, n_basis) + for i in 1:size(samples,2) + samples[:,i] /= norm(samples[:,i]) + end + out = zeros(m,n_basis) + mul!(out,A,samples)# must use mul! for multiply with lin map to return a matrix) + norm_val = (n/n_basis)^(1/p) * norm(out,p) + + return norm_val +end + +LinearAlgebra.norm(A::LM, p::Real = 2; lm_kwargs...) where {LM <: LinearMap} = norm_linear_map(A, p; lm_kwargs...) # Data processing tooling: diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index 1ad4d52e6..9b233d649 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -283,26 +283,24 @@ function initialize_processor!( else if ret_var < 1.0 # tsvd option - # approximate Frobenius norm of the map - norm_approx = zeros(n_norm_compute) + norm_sq_approx = zeros(n_norm_compute) for i in 1:n_norm_compute - samples = randn(size(decorrelation_map, 1), n_totvar_samples) - norm_approx[i] = - 1 / n_totvar_samples * sum([sum(abs2, (decorrelation_map * x)) for x in eachcol(samples)]) + # approximate frobenius norm^2 (= sum of s.v.^2 = total variance) + norm_sq_approx[i] = norm_linear_map(decorrelation_map, n_eval=n_totvar_samples)^2 end - @info "relative error of total variance $(std(norm_approx)/mean(norm_approx))" - retain_var_max = 1 - std(norm_approx) / mean(norm_approx) + @info "relative error of total variance $(std(norm_sq_approx)/mean(norm_sq_approx))" + retain_var_max = 1 - std(norm_sq_approx) / mean(norm_sq_approx) ret_var_tmp = min(ret_var, retain_var_max) for rk in 1:max_rank _, Stmp, Vtmp = tsvd(decorrelation_map, rk) - retain_var_current = sum(Stmp .^ 2) / (retain_var_max * mean(norm_approx)) + retain_var_current = sum(Stmp .^ 2) / (retain_var_max * mean(norm_sq_approx)) if retain_var_current > ret_var_tmp push!(S, Stmp) push!(Vt, Vtmp') - @info " truncating at $(rk)/$(size(data,1)) retaining $(retain_var_current*100)% (+/-$(100*std(norm_approx)/mean(norm_approx)))% of the variance of the structure matrix" + @info " truncating at $(rk)/$(size(data,1)) retaining $(retain_var_current*100)% (+/-$(100*std(norm_sq_approx)/mean(norm_sq_approx)))% of the variance of the structure matrix" break end if rk == max_rank From ac0fc62f38f43b55ea6a700719adeee3f3ff35c5 Mon Sep 17 00:00:00 2001 From: odunbar Date: Sat, 6 Dec 2025 19:24:05 -0800 Subject: [PATCH 32/32] format and docstring --- src/Utilities.jl | 23 +++++++++++++++++------ src/Utilities/decorrelator.jl | 2 +- 2 files changed, 18 insertions(+), 7 deletions(-) diff --git a/src/Utilities.jl b/src/Utilities.jl index c8c29c4b9..95a4b3824 100644 --- a/src/Utilities.jl +++ b/src/Utilities.jl @@ -228,19 +228,30 @@ function create_compact_linear_map( end +""" +$(TYPEDSIGNATURES) + +Approximately computes the norm of a `LinearMap` object. For `Amap` associated with matrix `A`, `norm_linear_map(Amap,p)≈norm(A,p)`. Can be aliased as `norm()` + +kwargs +------ +- n_eval(=nothing): number of mat-vec products to apply in the approximation (larger is more accurate). default performs `size(map,2)` products +- rng(=Random.default_rng()): random number generator + +""" function norm_linear_map(A::LM, p::Real = 2; n_eval = nothing, rng = Random.default_rng()) where {LM <: LinearMap} m, n = size(A) # use unit-normalized gaussian vectors n_basis = isa(n_eval, Nothing) ? n : n_eval samples = randn(n, n_basis) - for i in 1:size(samples,2) - samples[:,i] /= norm(samples[:,i]) + for i in 1:size(samples, 2) + samples[:, i] /= norm(samples[:, i]) end - out = zeros(m,n_basis) - mul!(out,A,samples)# must use mul! for multiply with lin map to return a matrix) - norm_val = (n/n_basis)^(1/p) * norm(out,p) - + out = zeros(m, n_basis) + mul!(out, A, samples)# must use mul! for multiply with lin map to return a matrix) + norm_val = (n / n_basis)^(1 / p) * norm(out, p) + return norm_val end diff --git a/src/Utilities/decorrelator.jl b/src/Utilities/decorrelator.jl index 9b233d649..aa94266f2 100644 --- a/src/Utilities/decorrelator.jl +++ b/src/Utilities/decorrelator.jl @@ -287,7 +287,7 @@ function initialize_processor!( norm_sq_approx = zeros(n_norm_compute) for i in 1:n_norm_compute # approximate frobenius norm^2 (= sum of s.v.^2 = total variance) - norm_sq_approx[i] = norm_linear_map(decorrelation_map, n_eval=n_totvar_samples)^2 + norm_sq_approx[i] = norm_linear_map(decorrelation_map, n_eval = n_totvar_samples)^2 end @info "relative error of total variance $(std(norm_sq_approx)/mean(norm_sq_approx))" retain_var_max = 1 - std(norm_sq_approx) / mean(norm_sq_approx)