Compare `70a35e0 ... +1 ... 240d8f7`

convert_result(::typeof(waic), result) = todataframes(result)
convert_result(::typeof(r2_score), result) = todataframes(result)
function convert_result(::typeof(compare), result)
    return todataframes(result; index_name = :name)
    return todataframes(result; index_name=:name)
end

@doc doc"""

@@ -126,15 +126,15 @@

summarystats(idata; var_names = ["mu", "tau"], stat_funcs = func_dict, extend = false)
```
"""
function StatsBase.summarystats(data::InferenceData; group = :posterior, kwargs...)
function StatsBase.summarystats(data::InferenceData; group=:posterior, kwargs...)
    dataset = getproperty(data, Symbol(group))
    return summarystats(dataset; kwargs...)
end
function StatsBase.summarystats(data::Dataset; index_origin = 1, fmt = :wide, kwargs...)
    s = arviz.summary(data; index_origin = index_origin, fmt = fmt, kwargs...)
function StatsBase.summarystats(data::Dataset; index_origin=1, fmt=:wide, kwargs...)
    s = arviz.summary(data; index_origin=index_origin, fmt=fmt, kwargs...)
    s isa Dataset && return s
    index_name = Symbol(fmt) == :long ? :statistic : :variable
    return todataframes(s; index_name = index_name)
    return todataframes(s; index_name=index_name)
end

"""

@@ -150,12 +150,12 @@


# Keywords

- `coords::Dict{String,Vector}=nothing`: Map from named dimension to named indices.
- `dims::Dict{String,Vector{String}}=nothing`: Map from variable name to names of its
  - `coords::Dict{String,Vector}=nothing`: Map from named dimension to named indices.
  - `dims::Dict{String,Vector{String}}=nothing`: Map from variable name to names of its
    dimensions.
- `kwargs`: Keyword arguments passed to [`summarystats`](@ref).
  - `kwargs`: Keyword arguments passed to [`summarystats`](@ref).
"""
function summary(data; group = :posterior, coords = nothing, dims = nothing, kwargs...)
    dataset = convert_to_dataset(data; group = group, coords = coords, dims = dims)
function summary(data; group=:posterior, coords=nothing, dims=nothing, kwargs...)
    dataset = convert_to_dataset(data; group=group, coords=coords, dims=dims)
    return summarystats(dataset; kwargs...)
end

@@ -63,19 +63,20 @@

    ndraws, _, nchains = size(chns)
    loc_names_old = getfield(chns.name_map, section) # old may be Symbol or String
    loc_names = string.(loc_names_old)
    loc_str_to_old =
        Dict(name_str => name_old for (name_str, name_old) in zip(loc_names, loc_names_old))
    loc_str_to_old = Dict(
        name_str => name_old for (name_str, name_old) in zip(loc_names, loc_names_old)
    )
    vars_to_locs = varnames_locs_dict(loc_names, loc_str_to_old)
    vars_to_arrays = Dict{String,Array}()
    for (var_name, names_locs) in vars_to_locs
        loc_names, locs = names_locs
        max_loc = maximum(hcat([[loc...] for loc in locs]...); dims = 2)
        max_loc = maximum(hcat([[loc...] for loc in locs]...); dims=2)
        ndim = length(max_loc)
        sizes = tuple(max_loc...)

        oldarr = reshape_values(replacemissing(Array(chns.value[:, loc_names, :])))
        if ndim == 0
            arr = dropdims(oldarr; dims = 3)
            arr = dropdims(oldarr; dims=3)
        else
            arr = Array{Union{typeof(NaN),eltype(oldarr)}}(undef, nchains, ndraws, sizes...)
            fill!(arr, NaN)

@@ -89,10 +90,7 @@

end

function chains_to_dict(
    chns::Chains;
    ignore = String[],
    section = :parameters,
    rekey_fun = identity,
    chns::Chains; ignore=String[], section=:parameters, rekey_fun=identity
)
    section in sections(chns) || return Dict()
    chns_dict = section_dict(chns, section)

@@ -108,7 +106,7 @@


Remaining `kwargs` are forwarded to [`from_mcmcchains`](@ref).
"""
function convert_to_inference_data(chns::Chains; group = :posterior, kwargs...)
function convert_to_inference_data(chns::Chains; group=:posterior, kwargs...)
    group = Symbol(group)
    group == :posterior && return from_mcmcchains(chns; kwargs...)
    return from_mcmcchains(; group => chns)

@@ -169,16 +167,16 @@

    posterior_predictive,
    predictions,
    log_likelihood;
    library = MCMCChains,
    library=MCMCChains,
    kwargs...,
)
    kwargs = convert(Dict, merge((; dims = nothing), kwargs))
    kwargs = convert(Dict, merge((; dims=nothing), kwargs))
    library = string(library)
    rekey_fun = d -> rekey(d, stats_key_map)

    # Convert chains to dicts
    post_dict = chains_to_dict(posterior)
    stats_dict = chains_to_dict(posterior; section = :internals, rekey_fun = rekey_fun)
    stats_dict = chains_to_dict(posterior; section=:internals, rekey_fun=rekey_fun)
    stats_dict = enforce_stat_types(stats_dict)

    all_idata = InferenceData()

@@ -197,48 +195,45 @@

        if group_data isa Union{AbstractVector{String},NTuple{N,String} where {N}}
            group_data = popsubdict!(post_dict, group_data)
        end
        group_dataset = convert_to_dataset(group_data; library = library, kwargs...)
        group_dataset = convert_to_dataset(group_data; library=library, kwargs...)
        setattribute!(group_dataset, "inference_library", library)
        concat!(all_idata, InferenceData(; group => group_dataset))
    end

    attrs = attributes_dict(posterior)
    attrs = merge(attrs, Dict("inference_library" => library))
    kwargs = convert(Dict, merge((; attrs = attrs, dims = nothing), kwargs))
    post_idata = _from_dict(post_dict; sample_stats = stats_dict, kwargs...)
    kwargs = convert(Dict, merge((; attrs=attrs, dims=nothing), kwargs))
    post_idata = _from_dict(post_dict; sample_stats=stats_dict, kwargs...)
    concat!(all_idata, post_idata)
    return all_idata
end
function from_mcmcchains(
    posterior = nothing;
    posterior_predictive = nothing,
    predictions = nothing,
    prior = nothing,
    prior_predictive = nothing,
    observed_data = nothing,
    constant_data = nothing,
    predictions_constant_data = nothing,
    log_likelihood = nothing,
    library = MCMCChains,
    posterior=nothing;
    posterior_predictive=nothing,
    predictions=nothing,
    prior=nothing,
    prior_predictive=nothing,
    observed_data=nothing,
    constant_data=nothing,
    predictions_constant_data=nothing,
    log_likelihood=nothing,
    library=MCMCChains,
    kwargs...,
)
    kwargs = convert(Dict, merge((; dims = nothing, coords = nothing), kwargs))
    kwargs = convert(Dict, merge((; dims=nothing, coords=nothing), kwargs))

    all_idata = from_mcmcchains(
        posterior,
        posterior_predictive,
        predictions,
        log_likelihood;
        library = library,
        library=library,
        kwargs...,
    )

    if prior !== nothing
        pre_prior_idata = convert_to_inference_data(
            prior;
            posterior_predictive = prior_predictive,
            library = library,
            kwargs...,
            prior; posterior_predictive=prior_predictive, library=library, kwargs...
        )
        prior_idata = rekey(
            pre_prior_idata,

@@ -257,8 +252,7 @@

        :predictions_constant_data => predictions_constant_data,
    ]
        group_data === nothing && continue
        group_dataset =
            convert_to_constant_dataset(group_data; library = library, kwargs...)
        group_dataset = convert_to_constant_dataset(group_data; library=library, kwargs...)
        concat!(all_idata, InferenceData(; group => group_dataset))
    end


@@ -271,5 +265,5 @@

Call [`from_mcmcchains`](@ref) on output of `CmdStan`.
"""
function from_cmdstan(posterior::Chains; kwargs...)
    return from_mcmcchains(posterior; library = "CmdStan", kwargs...)
    return from_mcmcchains(posterior; library="CmdStan", kwargs...)
end

@@ -18,9 +18,10 @@

Convert `MonteCarloMeasurements.AbstractParticles` to an [`InferenceData`](@ref).

`obj` may have the following types:
- `::AbstractParticles`: Univariate draws from a single chain.
- `::AbstractVector{<:AbstractParticles}`: Univariate draws from a vector of chains.
- `::AbstractVector{<:AbstractArray{<:AbstractParticles}}`: Multivariate draws from a vector

  - `::AbstractParticles`: Univariate draws from a single chain.
  - `::AbstractVector{<:AbstractParticles}`: Univariate draws from a vector of chains.
  - `::AbstractVector{<:AbstractArray{<:AbstractParticles}}`: Multivariate draws from a vector
    of chains.
"""
function convert_to_inference_data(obj::AbstractParticles; kwargs...)

@@ -30,8 +31,7 @@

    return convert_to_inference_data(stack(stack.(obj)); kwargs...)
end
function convert_to_inference_data(
    obj::AbstractVector{<:AbstractArray{<:AbstractParticles}};
    kwargs...,
    obj::AbstractVector{<:AbstractArray{<:AbstractParticles}}; kwargs...
)
    return convert_to_inference_data(stack(stack.(obj)); kwargs...)
end

@@ -87,7 +87,7 @@


convert_to_inference_data(::Nothing; kwargs...) = InferenceData()

function convert_to_dataset(data::InferenceData; group = :posterior, kwargs...)
function convert_to_dataset(data::InferenceData; group=:posterior, kwargs...)
    group = Symbol(group)
    dataset = getproperty(data, group)
    return dataset

@@ -109,19 +109,13 @@


# A more flexible form of `from_dict`
# Internally calls `dict_to_dataset`
function _from_dict(
    posterior = nothing;
    attrs = Dict(),
    coords = nothing,
    dims = nothing,
    dicts...,
)
    dicts = (posterior = posterior, dicts...)
function _from_dict(posterior=nothing; attrs=Dict(), coords=nothing, dims=nothing, dicts...)
    dicts = (posterior=posterior, dicts...)

    datasets = []
    for (name, dict) in pairs(dicts)
        (dict === nothing || isempty(dict)) && continue
        dataset = dict_to_dataset(dict; attrs = attrs, coords = coords, dims = dims)
        dataset = dict_to_dataset(dict; attrs=attrs, coords=coords, dims=dims)
        push!(datasets, name => dataset)
    end


@@ -132,7 +126,7 @@

@doc forwarddoc(:concat) concat

function concat(data::InferenceData...; kwargs...)
    return arviz.concat(data...; inplace = false, kwargs...)
    return arviz.concat(data...; inplace=false, kwargs...)
end

Docs.getdoc(::typeof(concat)) = forwardgetdoc(:concat)

@@ -146,7 +140,7 @@

concat!

function concat!(data::InferenceData, other_data::InferenceData...; kwargs...)
    arviz.concat(data, other_data...; inplace = true, kwargs...)
    arviz.concat(data, other_data...; inplace=true, kwargs...)
    return data
end
concat!(; kwargs...) = InferenceData()

@@ -162,7 +156,7 @@

    return concat(data_new...)
end

function reorder_groups!(data::InferenceData; group_order = SUPPORTED_GROUPS)
function reorder_groups!(data::InferenceData; group_order=SUPPORTED_GROUPS)
    group_order = map(Symbol, group_order)
    names = groupnames(data)
    sorted_names = filter(n -> n ∈ names, group_order)

@@ -96,7 +96,7 @@


# Load ArviZ once at precompilation time for docstringS
copy!(arviz, import_arviz())
check_needs_update(update = false)
check_needs_update(; update=false)
const _precompile_arviz_version = arviz_version()

function __init__()

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Click to load this diff.

Loading diff...

Learn more Showing 1 files with coverage changes found.

Changes in src/rcparams.jl

-2

→

Loading file...

88.50% 93.85% +0.37%

Auto format code and documentation with JuliaFormatter BlueStyle (#105)

sethaxen

240d8f7

CI Passed

Hiding 1 contexual commits

-2

88.13% ø ø

Several updates to CI workflows (#103)

sethaxen

70a35e0

CI Passed

Files		•	•	•	Coverage
src	ø	+2	ø	-2	^0.37% 88.50%
Project Totals (13 files)	539	477	0	62	88.50%

150	150
151	151		# Keywords
152	152
153		-	- `coords::Dict{String,Vector}=nothing`: Map from named dimension to named indices.
154		-	- `dims::Dict{String,Vector{String}}=nothing`: Map from variable name to names of its
	153	+	- `coords::Dict{String,Vector}=nothing`: Map from named dimension to named indices.
	154	+	- `dims::Dict{String,Vector{String}}=nothing`: Map from variable name to names of its
155	155		dimensions.
156		-	- `kwargs`: Keyword arguments passed to [`summarystats`](@ref).
	156	+	- `kwargs`: Keyword arguments passed to [`summarystats`](@ref).
157	157		"""
158		-	function summary(data; group = :posterior, coords = nothing, dims = nothing, kwargs...)
159		-	dataset = convert_to_dataset(data; group = group, coords = coords, dims = dims)
	158	+	function summary(data; group=:posterior, coords=nothing, dims=nothing, kwargs...)
	159	+	dataset = convert_to_dataset(data; group=group, coords=coords, dims=dims)
160	160		return summarystats(dataset; kwargs...)
161	161		end

169	167		posterior_predictive,
170	168		predictions,
171	169		log_likelihood;
172		-	library = MCMCChains,
	170	+	library=MCMCChains,
173	171		kwargs...,
174	172		)
175		-	kwargs = convert(Dict, merge((; dims = nothing), kwargs))
	173	+	kwargs = convert(Dict, merge((; dims=nothing), kwargs))
176	174		library = string(library)
177	175		rekey_fun = d -> rekey(d, stats_key_map)
178	176
179	177		# Convert chains to dicts
180	178		post_dict = chains_to_dict(posterior)
181		-	stats_dict = chains_to_dict(posterior; section = :internals, rekey_fun = rekey_fun)
	179	+	stats_dict = chains_to_dict(posterior; section=:internals, rekey_fun=rekey_fun)
182	180		stats_dict = enforce_stat_types(stats_dict)
183	181
184	182		all_idata = InferenceData()

197	195		if group_data isa Union{AbstractVector{String},NTuple{N,String} where {N}}
198	196		group_data = popsubdict!(post_dict, group_data)
199	197		end
200		-	group_dataset = convert_to_dataset(group_data; library = library, kwargs...)
	198	+	group_dataset = convert_to_dataset(group_data; library=library, kwargs...)
201	199		setattribute!(group_dataset, "inference_library", library)
202	200		concat!(all_idata, InferenceData(; group => group_dataset))
203	201		end
204	202
205	203		attrs = attributes_dict(posterior)
206	204		attrs = merge(attrs, Dict("inference_library" => library))
207		-	kwargs = convert(Dict, merge((; attrs = attrs, dims = nothing), kwargs))
208		-	post_idata = _from_dict(post_dict; sample_stats = stats_dict, kwargs...)
	205	+	kwargs = convert(Dict, merge((; attrs=attrs, dims=nothing), kwargs))
	206	+	post_idata = _from_dict(post_dict; sample_stats=stats_dict, kwargs...)
209	207		concat!(all_idata, post_idata)
210	208		return all_idata
211	209		end
212	210		function from_mcmcchains(
213		-	posterior = nothing;
214		-	posterior_predictive = nothing,
215		-	predictions = nothing,
216		-	prior = nothing,
217		-	prior_predictive = nothing,
218		-	observed_data = nothing,
219		-	constant_data = nothing,
220		-	predictions_constant_data = nothing,
221		-	log_likelihood = nothing,
222		-	library = MCMCChains,
	211	+	posterior=nothing;
	212	+	posterior_predictive=nothing,
	213	+	predictions=nothing,
	214	+	prior=nothing,
	215	+	prior_predictive=nothing,
	216	+	observed_data=nothing,
	217	+	constant_data=nothing,
	218	+	predictions_constant_data=nothing,
	219	+	log_likelihood=nothing,
	220	+	library=MCMCChains,
223	221		kwargs...,
224	222		)
225		-	kwargs = convert(Dict, merge((; dims = nothing, coords = nothing), kwargs))
	223	+	kwargs = convert(Dict, merge((; dims=nothing, coords=nothing), kwargs))
226	224
227	225		all_idata = from_mcmcchains(
228	226		posterior,
229	227		posterior_predictive,
230	228		predictions,
231	229		log_likelihood;
232		-	library = library,
	230	+	library=library,
233	231		kwargs...,
234	232		)
235	233
236	234		if prior !== nothing
237	235		pre_prior_idata = convert_to_inference_data(
238		-	prior;
239		-	posterior_predictive = prior_predictive,
240		-	library = library,
241		-	kwargs...,
	236	+	prior; posterior_predictive=prior_predictive, library=library, kwargs...
242	237		)
243	238		prior_idata = rekey(
244	239		pre_prior_idata,

257	252		:predictions_constant_data => predictions_constant_data,
258	253		]
259	254		group_data === nothing && continue
260		-	group_dataset =
261		-	convert_to_constant_dataset(group_data; library = library, kwargs...)
	255	+	group_dataset = convert_to_constant_dataset(group_data; library=library, kwargs...)
262	256		concat!(all_idata, InferenceData(; group => group_dataset))
263	257		end
264	258

109	109
110	110		# A more flexible form of `from_dict`
111	111		# Internally calls `dict_to_dataset`
112		-	function _from_dict(
113		-	posterior = nothing;
114		-	attrs = Dict(),
115		-	coords = nothing,
116		-	dims = nothing,
117		-	dicts...,
118		-	)
119		-	dicts = (posterior = posterior, dicts...)
	112	+	function _from_dict(posterior=nothing; attrs=Dict(), coords=nothing, dims=nothing, dicts...)
	113	+	dicts = (posterior=posterior, dicts...)
120	114
121	115		datasets = []
122	116		for (name, dict) in pairs(dicts)
123	117		(dict === nothing \|\| isempty(dict)) && continue
124		-	dataset = dict_to_dataset(dict; attrs = attrs, coords = coords, dims = dims)
	118	+	dataset = dict_to_dataset(dict; attrs=attrs, coords=coords, dims=dims)
125	119		push!(datasets, name => dataset)
126	120		end
127	121

34	34		convert_result(::typeof(waic), result) = todataframes(result)
35	35		convert_result(::typeof(r2_score), result) = todataframes(result)
36	36		function convert_result(::typeof(compare), result)
37		-	return todataframes(result; index_name = :name)
	37	+	return todataframes(result; index_name=:name)
38	38		end
39	39
40	40		@doc doc"""

126	126		summarystats(idata; var_names = ["mu", "tau"], stat_funcs = func_dict, extend = false)
127	127		```
128	128		"""
129		-	function StatsBase.summarystats(data::InferenceData; group = :posterior, kwargs...)
	129	+	function StatsBase.summarystats(data::InferenceData; group=:posterior, kwargs...)
130	130		dataset = getproperty(data, Symbol(group))
131	131		return summarystats(dataset; kwargs...)
132	132		end
133		-	function StatsBase.summarystats(data::Dataset; index_origin = 1, fmt = :wide, kwargs...)
134		-	s = arviz.summary(data; index_origin = index_origin, fmt = fmt, kwargs...)
	133	+	function StatsBase.summarystats(data::Dataset; index_origin=1, fmt=:wide, kwargs...)
	134	+	s = arviz.summary(data; index_origin=index_origin, fmt=fmt, kwargs...)
135	135		s isa Dataset && return s
136	136		index_name = Symbol(fmt) == :long ? :statistic : :variable
137		-	return todataframes(s; index_name = index_name)
	137	+	return todataframes(s; index_name=index_name)
138	138		end
139	139
140	140		"""

63	63		ndraws, _, nchains = size(chns)
64	64		loc_names_old = getfield(chns.name_map, section) # old may be Symbol or String
65	65		loc_names = string.(loc_names_old)
66		-	loc_str_to_old =
67		-	Dict(name_str => name_old for (name_str, name_old) in zip(loc_names, loc_names_old))
	66	+	loc_str_to_old = Dict(
	67	+	name_str => name_old for (name_str, name_old) in zip(loc_names, loc_names_old)
	68	+	)
68	69		vars_to_locs = varnames_locs_dict(loc_names, loc_str_to_old)
69	70		vars_to_arrays = Dict{String,Array}()
70	71		for (var_name, names_locs) in vars_to_locs
71	72		loc_names, locs = names_locs
72		-	max_loc = maximum(hcat([[loc...] for loc in locs]...); dims = 2)
	73	+	max_loc = maximum(hcat([[loc...] for loc in locs]...); dims=2)
73	74		ndim = length(max_loc)
74	75		sizes = tuple(max_loc...)
75	76
76	77		oldarr = reshape_values(replacemissing(Array(chns.value[:, loc_names, :])))
77	78		if ndim == 0
78		-	arr = dropdims(oldarr; dims = 3)
	79	+	arr = dropdims(oldarr; dims=3)
79	80		else
80	81		arr = Array{Union{typeof(NaN),eltype(oldarr)}}(undef, nchains, ndraws, sizes...)
81	82		fill!(arr, NaN)

89	90		end
90	91
91	92		function chains_to_dict(
92		-	chns::Chains;
93		-	ignore = String[],
94		-	section = :parameters,
95		-	rekey_fun = identity,
	93	+	chns::Chains; ignore=String[], section=:parameters, rekey_fun=identity
96	94		)
97	95		section in sections(chns) \|\| return Dict()
98	96		chns_dict = section_dict(chns, section)

108	106
109	107		Remaining `kwargs` are forwarded to [`from_mcmcchains`](@ref).
110	108		"""
111		-	function convert_to_inference_data(chns::Chains; group = :posterior, kwargs...)
	109	+	function convert_to_inference_data(chns::Chains; group=:posterior, kwargs...)
112	110		group = Symbol(group)
113	111		group == :posterior && return from_mcmcchains(chns; kwargs...)
114	112		return from_mcmcchains(; group => chns)

271	265		Call [`from_mcmcchains`](@ref) on output of `CmdStan`.
272	266		"""
273	267		function from_cmdstan(posterior::Chains; kwargs...)
274		-	return from_mcmcchains(posterior; library = "CmdStan", kwargs...)
	268	+	return from_mcmcchains(posterior; library="CmdStan", kwargs...)
275	269		end

18	18		Convert `MonteCarloMeasurements.AbstractParticles` to an [`InferenceData`](@ref).
19	19
20	20		`obj` may have the following types:
21		-	- `::AbstractParticles`: Univariate draws from a single chain.
22		-	- `::AbstractVector{<:AbstractParticles}`: Univariate draws from a vector of chains.
23		-	- `::AbstractVector{<:AbstractArray{<:AbstractParticles}}`: Multivariate draws from a vector
	21	+
	22	+	- `::AbstractParticles`: Univariate draws from a single chain.
	23	+	- `::AbstractVector{<:AbstractParticles}`: Univariate draws from a vector of chains.
	24	+	- `::AbstractVector{<:AbstractArray{<:AbstractParticles}}`: Multivariate draws from a vector
24	25		of chains.
25	26		"""
26	27		function convert_to_inference_data(obj::AbstractParticles; kwargs...)

30	31		return convert_to_inference_data(stack(stack.(obj)); kwargs...)
31	32		end
32	33		function convert_to_inference_data(
33		-	obj::AbstractVector{<:AbstractArray{<:AbstractParticles}};
34		-	kwargs...,
	34	+	obj::AbstractVector{<:AbstractArray{<:AbstractParticles}}; kwargs...
35	35		)
36	36		return convert_to_inference_data(stack(stack.(obj)); kwargs...)
37	37		end

87	87
88	88		convert_to_inference_data(::Nothing; kwargs...) = InferenceData()
89	89
90		-	function convert_to_dataset(data::InferenceData; group = :posterior, kwargs...)
	90	+	function convert_to_dataset(data::InferenceData; group=:posterior, kwargs...)
91	91		group = Symbol(group)
92	92		dataset = getproperty(data, group)
93	93		return dataset

132	126		@doc forwarddoc(:concat) concat
133	127
134	128		function concat(data::InferenceData...; kwargs...)
135		-	return arviz.concat(data...; inplace = false, kwargs...)
	129	+	return arviz.concat(data...; inplace=false, kwargs...)
136	130		end
137	131
138	132		Docs.getdoc(::typeof(concat)) = forwardgetdoc(:concat)

Navigation	Overlay
`t` Navigate files	`h` Toggle hits
`y` Change url to tip of branch	`m` Toggle misses
`b / v` Jump to prev/next hit line	`p` Toggle partial
`z / x` Jump to prev/next missed or partial line	`1..9` Toggle flags
`shift + o` Open current page in GitHub	`a` Toggle all on
`/ or ?` Show keyboard shortcuts dialog	`c` Toggle context lines or commits

146	140		concat!
147	141
148	142		function concat!(data::InferenceData, other_data::InferenceData...; kwargs...)
149		-	arviz.concat(data, other_data...; inplace = true, kwargs...)
	143	+	arviz.concat(data, other_data...; inplace=true, kwargs...)
150	144		return data
151	145		end
152	146		concat!(; kwargs...) = InferenceData()

162	156		return concat(data_new...)
163	157		end
164	158
165		-	function reorder_groups!(data::InferenceData; group_order = SUPPORTED_GROUPS)
	159	+	function reorder_groups!(data::InferenceData; group_order=SUPPORTED_GROUPS)
166	160		group_order = map(Symbol, group_order)
167	161		names = groupnames(data)
168	162		sorted_names = filter(n -> n ∈ names, group_order)

96	96
97	97		# Load ArviZ once at precompilation time for docstringS
98	98		copy!(arviz, import_arviz())
99		-	check_needs_update(update = false)
	99	+	check_needs_update(; update=false)
100	100		const _precompile_arviz_version = arviz_version()
101	101
102	102		function __init__()

Compare 70a35e0 ... +1 ... 240d8f7

No flags found

Show failed CI and contexual commits c 3 Commits

Compare `70a35e0 ... +1 ... 240d8f7`

Show failed CI and contexual commits `c`

3 Commits