Internal Documentation

Documentation for ComposedDistributions's internal interface.

Internal Documentation

Index

ComposedDistributions.AbstractEventSpec
ComposedDistributions.ParamsTable
Base.rand
Base.show
ComposedDistributions._composed_params
ComposedDistributions._composer_rand
ComposedDistributions._edit_at
ComposedDistributions._flat_event_names
ComposedDistributions._hazard_panelled_integrate
ComposedDistributions.threshold
ConvolvedDistributions.convolve_series
ConvolvedDistributions.difference
Distributions.ccdf
Distributions.cdf
Distributions.logpdf
Distributions.pdf
Distributions.pdf
Distributions.pdf
Distributions.pdf
Distributions.probs
Distributions.probs
Statistics.mean
Statistics.mean
Statistics.std
Statistics.var
StatsAPI.params
StatsAPI.params

Internal API

ComposedDistributions.AbstractEventSpec Type

julia

abstract type AbstractEventSpec

The supertype of the event-skeleton spec nodes.

An EventSkeleton is a tree of these structural nodes: a named Hole leaf, a →-chain, a |-one_of group, or a &-parallel group. The nodes carry names and composition structure only, no distributions.

See also

EventSkeleton: the skeleton wrapper the nodes sit under.
@events: the macro that lowers an operator diagram to them.

Fields

source

ComposedDistributions.ParamsTable Type

julia

struct ParamsTable{C<:NamedTuple}

A Tables.jl column table of a composed distribution's free parameters.

The value params_table returns: a Tables.jl source (a column table) that prints as a padded edge | param | value | support | prior table. It is a thin wrapper over a NamedTuple of equal-length column vectors, forwarding the whole Tables.jl column interface and column access (tbl.edge, tbl.param, ...), so Tables.istable, Tables.columns, Tables.getcolumn, DataFrame(tbl) and build_priors all consume it unchanged; only its display is customised.

See also: params_table, build_priors.

Fields

columns::NamedTuple

source

ComposedDistributions._composed_params Function

julia

_composed_params(
    d::Union{Parallel, Sequential}
) -> NamedTuple

Nested, name-keyed parameters of a composed distribution.

Returns a NamedTuple keyed by the node names, each value the params of that child (recursing into nested composers; a leaf delegates to its standard/ extended Distributions.params). A Resolve node contributes a name-keyed NamedTuple of its outcomes plus a branch_probs entry. This nested form is for prior introspection via params_table; a composed distribution reconstructs through compose, not through Distribution(params...).

source

ComposedDistributions._composer_rand Function

julia

_composer_rand(
    rng::Random.AbstractRNG,
    d::Union{Parallel, Sequential}
) -> Any

julia

_composer_rand(rng, d)

The vector-valued realisation of a composer: the generic per-leaf-value draw (one value per leaf, a nested composer contributing its own sub-vector). A Resolve child collapses to its marginal time-to-resolution (its univariate rand), a Choose child to its first alternative. Composed distributions score this flat, vector-valued representation (consumed by logpdf/AD); the labelled outputs below (_named_composer_rand, mean/var/std of a Parallel) wrap it by name for users.

source

ComposedDistributions._edit_at Function

julia

_edit_at(node, path::Tuple, op) -> Any

julia

_edit_at(node, path, op)

The path-walk core shared by update, prune and splice: walks path from node, applying op(target) at the addressed node and rebuilding the spine on the way back up. path is a tuple of edge names, in the same forms event accepts. An empty path applies op to node itself; otherwise _edit_step dispatches on the composer type to find the named child, recurse, and rebuild with the edited child swapped in.

source

ComposedDistributions._flat_event_names Function

julia

_flat_event_names(
    d::Union{Parallel, Sequential}
) -> Tuple{Vararg{Symbol}}

julia

_flat_event_names(d)

The internal worker behind the public event_names (flat) accessor: the tuple of event names matching the scored event vector [E_0, E_1, ..., E_k], the root origin event followed by one target event per edge in depth-first order. Built by appending into a Symbol[] and freezing to a tuple, mirroring the params_table pre-order walk; edge names are read from the parent composer's names field (a leaf edge does not store its own name), so each child is visited paired with its edge name.

Event names are derived from the composer's edge names (an edge :onset_admit gives origin :onset and target :admit); an edge with a positional default name (:step_i / :branch_i) contributes the positional event name :event_i instead. These event names key a data row (a linelist column is an event time), distinct from the edge names (component_names / the parameter inventory).

source

ComposedDistributions._hazard_panelled_integrate Function

julia

_hazard_panelled_integrate(f, lo, hi, c::Compete) -> Any

Integrate f over [lo, hi], splitting at each of c's causes' own quantile (or moment) markers so a wide shared window doesn't starve the region where the mass actually sits. Falls back to the single-window _PRIMARY rule when there are no interior breaks (a window that's already narrow, or every cause lacking a usable quantile/moment marker).

See also: Compete

source

Distributions.cdf Method

julia

cdf(c::Resolve, x::Real) -> Any

Cumulative distribution function of the one_of-outcome marginal at x.

The branch-prob-weighted mixture cdf Σ_i p_i F_i(x), summed directly so the probabilities keep their (possibly AD Dual) element type rather than being stripped by as_mixture's float.(branch_probs). This keeps the cdf AD-safe on a differentiated path (e.g. a censored-survival term), matching logpdf.

For a defective node (a no-event branch present) a no-event branch never contributes to "occurred by x" at any x, so it is skipped rather than scored; the sum rises only to occurrence_probability(c) as x → ∞, a proper sub-stochastic law rather than one coerced back to mass one. ccdf is 1 - cdf, the generic Distributions fallback, so it comes along for free: the defective survival that flattens at the no-event probability instead of decaying to zero.

source

ConvolvedDistributions.convolve_series Function

julia

convolve_series(
    d::Sequential,
    series::AbstractVector{<:Real};
    events
) -> Any

Convolve a timeseries through a composed chain's observed delay.

convolve_series(chain, series), where series is a numeric timeseries vector, collapses the Sequential chain to its observed total delay (observed_distribution, the convolution of the chain steps) and hands it straight to ConvolvedDistributions.convolve_series. With series the expected events at unit-spaced times 0, 1, ..., t (e.g. infections), a discrete observed delay gives the expected downstream event counts at the same times — the EpiNow2-style latent / renewal observation layer, driven by a composed delay rather than a bare distribution.

A chain's observed total is usually continuous (e.g. a Convolved sum of Gamma/LogNormal steps), and ConvolvedDistributions is discrete-convolution -only: it throws, naming CensoredDistributions.jl (which owns primary and interval censoring, including double-interval-censored masses for a day-binned primary) as the way to build a PMF first, then convolve_series(pmf, series). This method does not choose a scheme on the caller's behalf — it collapses the tree and delegates, nothing more.

Pass events to convolve the series to a chosen interim event of the chain rather than its endpoint. A single event name returns the count series at that event; a tuple or vector of names returns a NamedTuple of series keyed by the names. The cumulative delay to an interim event is the observed collapse of the chain prefix up to that event (the convolution of the steps leading to it), so selecting the terminal event reproduces the plain whole-chain result. Only a plain continuous chain (every step a delay leaf, no branching) has such per-event cumulative delays; a chain with a branching step is rejected.

Arguments

chain: a Sequential chain, collapsed to its observed total delay.
series: the input timeseries (expected events at unit-spaced times from 0).

Keyword Arguments

events: a chain event name, or a tuple/vector of names, to convolve the series to (the cumulative delay of the chain prefix up to that event). The valid names are the chain's event_names after the origin. nothing (the default) convolves to the endpoint (the whole-chain observed total).

Examples

julia

using ComposedDistributions, ConvolvedDistributions, Distributions

chain = Sequential(Gamma(2.0, 1.0), LogNormal(0.5, 0.4))
infections = [0.0, 1.0, 3.0, 6.0, 8.0, 5.0, 2.0]
maxlag = length(infections) - 1
# Standing in for what CensoredDistributions.jl would build for the chain's
# own (continuous) observed total: a caller-owned PMF, here from a discrete
# distribution's own masses.
masses = pdf.(NegativeBinomial(5, 0.5), 0:maxlag)
expected_counts = convolve_series(masses, infections)

# The count series at named interim events (here the prefix to each event).
onset_to = sequential(:onset_admit => Gamma(2.0, 1.0),
    :admit_death => LogNormal(0.5, 0.4))
by_event = convolve_series(onset_to, infections; events = (:admit, :death))

See also

observed_distribution: the chain-to-total-delay collapse.
event_names: the chain's event names, the valid events selectors.
difference: the difference of two observed totals.

source

julia

convolve_series(
    delay::Distributions.Distribution{Distributions.Univariate, Distributions.Discrete},
    series::AbstractVector{<:Real};
    mask
) -> Any

Convolve a timeseries with the PMF of a discrete delay distribution.

convolve_series(delay, series) for a DiscreteUnivariateDistribution delay reads the delay PMF directly off the integer lag grid — the lag-k mass IS pdf(delay, k) — and returns the causal discrete convolution of series with that PMF, truncated to the series window. With series the expected events at times 0, 1, ..., t (e.g. infections), the result is the expected downstream event counts at the same times (the EpiNow2-style latent / renewal observation layer).

The masses are [pdf(delay, k) for k in 0:(length(series) - 1)], used as given: no renormalisation, so any delay mass beyond the series window is truncated. pdf(delay, k) is differentiable in the delay parameters for the standard discrete families, so gradients flow under the supported AD backends.

Direct PMF evaluation, NOT a CDF difference: for an integer-support delay, , an off-by-one, so the discrete method reads pdf(delay, k) rather than a CDF-difference mass.

Only the integer lags 0, 1, 2, ... are read. A delay with atoms off the integer grid is out of scope (a lag grid means masses at the integers), and mass at negative lags cannot enter a causal convolution, so lags below 0 are not read (consistent with the causal kernel).

A Convolved/Difference/Product of integer-lattice discrete components is itself a DiscreteUnivariateDistribution (#85) and flows straight through this method, reading its exact masses. A CONTINUOUS delay has no mass on the integer grid until it is discretised, and discretisation is an explicit modelling choice this package does not make; it matches no method here, so convolve_series(a_continuous_delay, series) is a MethodError naming what is actually missing, rather than a pre-emptive gate (#95) — see convolve_series(pmf, series) below for the caller-owned discretisation path.

Unlike convolved, which combines distributions into a single Convolved distribution, this returns a numeric series; the separate verb keeps convolved strictly for distribution construction.

Arguments

delay: a DiscreteUnivariateDistribution (e.g. Poisson, DiscreteUniform, a shifted count delay).
series: the input timeseries (expected events at unit-spaced times from 0).
mask: optional. A Bool vector the same length as series; when given, only the output positions where mask is true are computed and the rest hold zero(eltype(result)). Masked-out positions are genuinely skipped, not computed and discarded, so a mask selecting a few positions out of a long series is cheap — pdf(delay, k) is only evaluated for the lags a requested position can actually read, so a mask restricted to an early window also skips evaluating the delay's pdf at the later lags. Omitted (the default), every position is computed.

Returns

A numeric vector of expected downstream counts, the same length as series.

Examples

julia

using ConvolvedDistributions, Distributions

delay = Poisson(2.0)
infections = [0.0, 1.0, 3.0, 6.0, 8.0, 5.0, 2.0]
expected_counts = convolve_series(delay, infections)

See also

convolved: the distribution-level convolution
convolve_series(pmf, series): the PMF-vector form for caller-owned discretisation

source

julia

convolve_series(
    pmf::AbstractVector{<:Real},
    series::AbstractVector{<:Real};
    mask
) -> Any

Convolve a timeseries with a caller-supplied discretised delay PMF.

convolve_series(pmf, series) returns the causal discrete convolution of series with the probability masses pmf, truncated to the series window: out[i] = sum(pmf[k + 1] * series[i - k] for k in 0:(min(length(pmf), i) - 1)). pmf[k + 1] is read as the delay mass at integer lag k on the same unit grid as series.

The masses are used exactly as given: no renormalisation, no validation that they sum to one, and no tail correction — mass at lags beyond the series window (including any pmf entries past length(series)) is simply never used, so sub-normalised or window-truncated PMFs stay truncated. This is the decoupled form of convolve_series(delay, series): the caller owns the discretisation (e.g. double-interval-censored masses from CensoredDistributions.jl), and this method only convolves. The convolution is linear, so gradients flow through both pmf and series under the supported AD backends.

Arguments

pmf: the discretised delay probability masses at integer lags 0, 1, 2, ... (used as given).
series: the input timeseries (expected events at unit-spaced times from 0).
mask: optional output-position mask, as in convolve_series(delay, series).

Returns

A numeric vector of expected downstream counts, the same length as series.

Examples

julia

using ConvolvedDistributions

pmf = [0.5, 0.3, 0.2]
infections = [0.0, 1.0, 3.0, 6.0, 8.0, 5.0, 2.0]
expected_counts = convolve_series(pmf, infections)

See also

convolve_series(pmf::DiscreteNonParametric, series): the non-unit-grid form

source

julia

convolve_series(
    pmf::Distributions.DiscreteNonParametric,
    series::AbstractVector{<:Real};
    mask
) -> Any

Convolve a timeseries with a delay's DiscreteNonParametric PMF.

convolve_series(pmf, series) for a DiscreteNonParametric pmf reads its support as the delay's lag grid and its probabilities as the masses at those lags, then convolves as convolve_series(probs(pmf), series). The support must start at 0 and be regularly spaced (a constant gap between consecutive support points); an irregular or offset grid throws an ArgumentError, since convolve_series has no separate argument to carry a grid width or starting lag.

This is the non-unit-grid caller-supplied form: a DiscreteNonParametric built on a coarser grid (e.g. DiscreteNonParametric(0:7:28, weekly_masses) for weekly bins) convolves correctly, whereas a plain AbstractVector PMF only ever reads as the unit grid.

Unlike the AbstractVector form, which uses masses exactly as given (no renormalisation, so a window-truncated tail stays sub-normalised), DiscreteNonParametric enforces a genuine probability vector at construction (sum(probs(pmf)) ≈ 1, or Distributions.jl throws a DomainError). A window-truncated or otherwise sub-normalised PMF therefore needs the plain vector form instead.

Arguments

pmf: a DiscreteNonParametric whose support is the delay's lag grid (regularly spaced, starting at 0) and whose probabilities are the masses at those lags.
series: the input timeseries, sampled at the same grid steps as pmf's support, from time 0.
mask: optional output-position mask, as in convolve_series(delay, series).

Examples

julia

using ConvolvedDistributions, Distributions

pmf = DiscreteNonParametric([0.0, 7.0, 14.0], [0.6, 0.3, 0.1])
infections = [0.0, 1.0, 3.0, 6.0, 8.0, 5.0, 2.0]
expected_counts = convolve_series(pmf, infections)

See also

convolve_series(pmf::AbstractVector, series): the unit-grid vector form

source

julia

convolve_series(
    delays::AbstractVector,
    series::AbstractVector{<:Real};
    indexed_by,
    mask,
    kwargs...
) -> Any

Convolve a timeseries with a time-varying delay: one delay per time point.

convolve_series(delays, series) takes one delay per entry of series and returns the convolution, truncated to the series window. Each delay's lag masses come from its own single-delay convolve_series(delay, series) method, so the elements may be of any, and of mixed, types. A type whose masses are not what that method gives specialises delay_masses instead.

Identical delays share one set of masses, however often they recur, so a delay is only ever built once. With a mask, a delay is also built no larger than the requested output positions can actually read — a delay at a time point a mask excludes entirely is never built beyond a single placeholder lag.

indexed_by names which time the delay belongs to:

:primary (the default): the delay belongs to the events, so the cohort at time s spreads forward through delays[s] — out[i] = Σ_s series[s] * pmf_s[i - s + 1]. Conserves mass up to the truncated tail.
:secondary: the delay belongs to the observation time, so everything landing at time i is read through delays[i] — out[i] = Σ_k pmf_i[k + 1] * series[i - k]. Not mass-conserving.

Any other keyword is forwarded to each distinct delay's delay_masses call, so a vector of continuous delays needing a non-default discretisation (e.g. interval) agrees with the same keywords passed to the single-delay convolve_series(delay, series) form.

Arguments

delays: one delay per time point, in series order.
series: the input timeseries (expected events at unit-spaced times from 0).
indexed_by: :primary (default) or :secondary.
mask: optional output-position mask, as in convolve_series(delay, series).
kwargs...: discretisation keywords, forwarded to delay_masses for each distinct delay.

Returns

A numeric vector of expected downstream counts, the same length as series.

Examples

julia

using ConvolvedDistributions, Distributions

infections = [0.0, 1.0, 3.0, 6.0, 8.0, 5.0, 2.0]
delays = [Poisson(λ) for λ in range(3.0, 1.0; length = length(infections))]
expected_counts = convolve_series(delays, infections)

See also

convolve_series(delay, series): the static single-delay form
convolve_series(pmfs::AbstractMatrix, series): the caller-supplied-PMF form
delay_masses: how one delay's masses are read, and where to specialise it

source

julia

convolve_series(
    runs::AbstractVector{<:Pair},
    series::AbstractVector{<:Real};
    indexed_by,
    mask
) -> Any

Convolve a timeseries with a delay that changes less often than the series.

convolve_series(runs, series) takes delay => length pairs, each holding for that many consecutive time points, and expands them before convolving — so the delays (or mass vectors) are given once per regime rather than once per time point. The lengths must sum to length(series).

indexed_by is as in the one-delay-per-time-point form.

Arguments

runs: delay => length pairs, in series order. Each delay is anything the one-per-time-point form accepts, including a mass vector.
series: the input timeseries (expected events at unit-spaced times from 0).
indexed_by: :primary (default) or :secondary.
mask: optional output-position mask, as in convolve_series(delay, series).

Returns

A numeric vector of expected downstream counts, the same length as series.

Examples

julia

using ConvolvedDistributions, Distributions

infections = [0.0, 1.0, 3.0, 6.0, 8.0, 5.0, 2.0]
expected_counts = convolve_series([Poisson(3.0) => 3, Poisson(1.0) => 4],
    infections)

See also

convolve_series(delays::AbstractVector, series): one delay per time point

source

julia

convolve_series(
    pmfs::AbstractMatrix{<:Real},
    series::AbstractVector{<:Real};
    indexed_by,
    mask
) -> Any

Convolve a timeseries with time-varying caller-supplied delay PMFs held in a matrix.

convolve_series(pmfs, series) reads an AbstractMatrix as one delay PMF per time point, lags down columns: pmfs[k + 1, j] is the mass at lag k for time point j, so size(pmfs, 2) must equal length(series). The lag count size(pmfs, 1) is free. A time-by-lag matrix M is passed as transpose(M).

indexed_by is as in the vector-of-delays form. Masses are used exactly as given: no renormalisation, no sum-to-one check and no tail correction.

Arguments

pmfs: delay masses, lags down columns, one column per time point.
series: the input timeseries (expected events at unit-spaced times from 0).
indexed_by: :primary (default) or :secondary.
mask: optional output-position mask, as in convolve_series(delay, series).

Returns

A numeric vector of expected downstream counts, the same length as series.

Examples

julia

using ConvolvedDistributions

infections = [0.0, 1.0, 3.0, 6.0]
pmfs = [0.5 0.5 0.6 0.7
        0.3 0.3 0.3 0.2
        0.2 0.2 0.1 0.1]
expected_counts = convolve_series(pmfs, infections)

See also

convolve_series(pmf::AbstractVector, series): the static unit-grid vector form
convolve_series(delays::AbstractVector, series): the vector-of-distributions form

source

julia

convolve_series(
    pmfs::AbstractVector{<:AbstractVector{<:Real}},
    series::AbstractVector{<:Real};
    indexed_by,
    mask
) -> Any

Convolve a timeseries with time-varying caller-supplied delay PMFs held in a vector of vectors.

The ragged counterpart of the matrix form: pmfs[j] is the delay PMF for time point j on the unit lag grid, so length(pmfs) must equal length(series) while each PMF may carry its own number of lags. indexed_by and the masses-as-given contract are as in the matrix form.

Arguments

pmfs: one vector of delay masses per time point, each from lag 0.
series: the input timeseries (expected events at unit-spaced times from 0).
indexed_by: :primary (default) or :secondary.
mask: optional output-position mask, as in convolve_series(delay, series).

Returns

A numeric vector of expected downstream counts, the same length as series.

Examples

julia

using ConvolvedDistributions

infections = [0.0, 1.0, 3.0, 6.0]
pmfs = [[0.5, 0.3, 0.2], [0.5, 0.5], [1.0], [0.4, 0.4, 0.1, 0.1]]
expected_counts = convolve_series(pmfs, infections)

See also

convolve_series(pmfs::AbstractMatrix, series): the rectangular matrix form

source

ConvolvedDistributions.difference Method

julia

difference(
    a::Sequential,
    b;
    kwargs...
) -> Union{ConvolvedDistributions.Difference{X, Y, ConvolvedDistributions.AnalyticalSolver{ConvolvedDistributions.GaussLegendre{ConvolvedDistributions._GL{Vector{Float64}, Vector{Float64}}}}, Distributions.Continuous} where {X<:(Distributions.UnivariateDistribution), Y<:(Distributions.UnivariateDistribution)}, ConvolvedDistributions.Difference{X, Y, ConvolvedDistributions.AnalyticalSolver{ConvolvedDistributions.GaussLegendre{ConvolvedDistributions._GL{Vector{Float64}, Vector{Float64}}}}, Distributions.Discrete} where {X<:(Distributions.UnivariateDistribution), Y<:(Distributions.UnivariateDistribution)}}

Difference of two observed total delays, Z = X - Y.

difference(a, b) accepts a Sequential chain for either operand and collapses it to its observed total delay (observed_distribution) before forming the Difference. With both operands chains, Z is the difference of the two convolved totals; a bare distribution operand is used as-is. This extends the univariate ConvolvedDistributions difference to composed stacks.

Examples

julia

using ComposedDistributions, Distributions

onset = Sequential(Gamma(2.0, 1.0), LogNormal(0.5, 0.4))
report = Sequential(Gamma(1.5, 1.0), Gamma(1.0, 2.0))
gap = difference(onset, report)

See also

observed_distribution: the chain-to-total-delay collapse.
Difference: the univariate difference distribution.

source

Distributions.logpdf Function

julia

logpdf(d::Sequential, x::AbstractVector) -> Missing

Log probability density of a chain's step-value vector.

See also: Sequential

source

julia

logpdf(
    d::Sequential,
    x::AbstractVector{>:Missing}
) -> Missing

Log probability density of a chain's step-value vector admitting missing steps: missing in a slot means that step was not observed (the ecosystem- wide convention), scoring the observed steps and integrating out the rest (each unobserved step's own marginal contributes zero log density).

See also: Sequential

source

julia

logpdf(d::Parallel, x::AbstractVector) -> Missing

Log probability density of a branch-value vector, summed over branches.

See also: Parallel

source

julia

logpdf(d::Parallel, x::AbstractVector{>:Missing}) -> Missing

Log probability density of a branch-value vector admitting missing branches: missing in a slot means that branch was not observed (the ecosystem-wide convention), scoring the observed branches and integrating out the rest (each unobserved branch's own marginal contributes zero log density).

See also: Parallel

source

julia

logpdf(c::Resolve, x::Real) -> Any

Log probability density of the one_of-outcome marginal at x.

Routed through the AD-safe _one_of_logmix reduction rather than logpdf(as_mixture(c), x): as_mixture does float.(branch_probs), which strips an AD Dual/tracked type from the branch probabilities, breaking the gradient w.r.t. a covariate case-fatality term (logistic(Xβ)) when a Resolve is scored as a leaf of a plain (non-censored) compose(...) tree. The explicit log-sum-exp keeps the probabilities' element type, so a Dual propagates exactly as on the censored-tree scorer.

See also: pdf, logcdf

source

julia

logpdf(
    d::ConvolvedDistributions.Convolved,
    x::AbstractVector{<:Real}
) -> Any

Compute log densities for a vector of points, analytically where convolved_logpdf has an exact route, otherwise as the log of the batched PDF solve.

Each numeric point is integrated over the same window the scalar path picks (shared composite panels plus per-point end corrections), so batched and scalar numeric log densities agree to well within ~1e-8 even for wide batches (typically near machine precision; extreme 100x-plus point spans stay within ~1e-6).

See also: pdf, logcdf

source

julia

logpdf(d::ConvolvedDistributions.Product, z::Real) -> Any

Compute the log probability density function.

See also: pdf, logcdf

source

julia

logpdf(d::ConvolvedDistributions.Ratio, z::Real) -> Any

Compute the log probability density function.

See also: pdf, logcdf

source

julia

logpdf(d::Distribution{ArrayLikeVariate{N}}, x::AbstractArray{<:Real,N}) where {N}

Evaluate the logarithm of the probability density function of d at x.

This function checks if the size of x is compatible with distribution d. This check can be disabled by using @inbounds.

Implementation

Instead of logpdf one should implement _logpdf(d, x) which does not have to check the size of x.

See also: logpdf

source

Distributions.pdf Method

julia

pdf(d::Parallel, x::AbstractVector) -> Any

Probability density of a branch-value vector.

See also: logpdf

source

Distributions.pdf Method

julia

pdf(c::Resolve, x::Real) -> Any

Probability density of the one_of-outcome marginal at x.

exp of the AD-safe logpdf, so branch-prob gradients survive (see the logpdf note on why as_mixture is avoided on a differentiated path).

See also: logpdf

source

Distributions.pdf Method

julia

pdf(d::Choose, x::Real; kind)

Probability density of the selected alternative at x.

See also: logpdf

source

Distributions.probs Method

julia

probs(c::Resolve) -> NamedTuple

The per-outcome probabilities of a fixed-probability Resolve node: its declared branch probabilities (the no-event branch's mass is the non-occurrence probability), returned as a NamedTuple keyed by the outcome names.

This is the Resolve method of Distributions.probs, the standard mixture-weight reader: a Resolve lowers to a MixtureModel (see as_mixture), so its weights are the declared branch probabilities. The racing-hazard Compete sibling derives the same split from the hazards instead.

Arguments

c: the Resolve node whose declared branch probabilities to read.

Examples

julia

using ComposedDistributions, Distributions

node = resolve(:death => (Gamma(1.5, 1.0), 0.3),
    :disch => (Gamma(2.0, 1.5), 0.7))
probs(node)

See also: Sequential

source

julia

rand(rng::Random.AbstractRNG, d::Parallel) -> NamedTuple

Sample a branch realisation as a NamedTuple keyed by the per-branch value names: one entry per leaf branch, a nested Sequential/Parallel branch contributing its own sub-values under dotted-joined names, and a Resolve branch contributing its own collapsed scalar.

See also: Parallel

source

julia

rand(
    rng::Random.AbstractRNG,
    c::ComposedDistributions.AbstractOneOf;
    outcome
) -> Union{Tuple{Any, Any}, NamedTuple}

Sample a one_of node (Resolve / Compete).

By default (outcome = false) the draw returns the full named event record of the outcome that fired: a NamedTuple keyed by event_names, a positional origin slot then one slot per outcome, with the fired outcome's time present and the others missing. This is the same self-describing record the in-tree path produces (the node nested in a compose(...) tree), so a standalone draw identifies which outcome won and feeds straight back into logpdf.

With outcome = true the draw instead returns the compact (name, time) pair of the outcome that fired, so a standalone draw tells you which outcome/cause won without reading the sparse record. For a Resolve the outcome is drawn from the branch probabilities and the time from that outcome's own delay; for a Compete a latent time is drawn per cause and the argmin cause with its min time is returned (the marginal any-event time min_k D_k alone is the pair's second element). A no-event win yields a missing time.

To recover the marginal time-to-resolution alone (the mixture over outcomes, discarding which fired) sample as_mixture(c) instead.

Examples

julia

using ComposedDistributions, Distributions, Random

node = resolve(:death => (Gamma(1.5, 1.0), 0.3),
    :disch => (Gamma(2.0, 1.5), 0.7))
rand(MersenneTwister(1), node)                      # the named event record
rand(MersenneTwister(1), node; outcome = true)      # the (name, time) pair

See also: Sequential

source

julia

show(io::IO, _::MIME{Symbol("text/plain")}, d::Parallel)

Print a Parallel composer as a recursive indented tree, descending into any nested composer children so the whole structure is shown at once.

See also: Parallel

source

julia

show(io::IO, _::MIME{Symbol("text/plain")}, c::Resolve)

Print a Resolve node as a recursive indented tree, labelling each outcome with its name and branch probability and descending into any nested composer outcome so the whole structure is shown at once.

Internal Documentation ​

Contents ​

Index ​

Internal API ​

Internal Documentation

Contents

Index

Internal API