Struct LikelihoodSpec 

pub struct LikelihoodSpec {
    pub response: ResponseFamily,
    pub link: InverseLink,
}

Unified likelihood specification: response distribution + parameterized link.

ResponseFamily carries the per-family scalars (Tweedie p, NegBin theta, Beta phi); InverseLink carries the parameterized link state. Together they replace the former flat likelihood enum.

Only the legal (response, link) cells enumerated by LikelihoodSpec::kind are representable through the public surface: LikelihoodSpec::try_new validates the legal matrix on construction, and deserialization routes through LikelihoodSpecWire (#[serde(try_from / into)]) so saved bytes cannot resurrect an illegal cell. The on-wire shape is byte-identical to the historical { response, link } struct, so legal saved models load unchanged.

Fields

response: ResponseFamily

link: InverseLink

Implementations

impl LikelihoodSpec

pub const fn new(response: ResponseFamily, link: InverseLink) -> Self

Unchecked constructor: assembles a (response, link) cell without validating the legal matrix. Reserved for the in-crate named const constructors below (gaussian_identity, poisson_log, beta_logit, the binomial_* family, …), every one of which builds a cell that is legal by construction. The public, fallible entry point for an arbitrary (response, link) pair is LikelihoodSpec::try_new; the serde path also validates via LikelihoodSpecWire. Do not expose illegal cells through this method.

pub fn is_legal_cell(response: &ResponseFamily, link: &InverseLink) -> bool

Returns true when the (response, link) pair is one of the legal cells the family math honours — exactly the cells enumerated by LikelihoodSpec::kind before any masking. Each non-binomial response is pinned to a single inverse link; the binomial family admits its full set of probability links but never the identity/log standard links.

pub fn try_new( response: ResponseFamily, link: InverseLink, ) -> Result<Self, IllegalLikelihoodCell>

Fallible constructor over an arbitrary (response, link) pair. Validates the legal matrix (LikelihoodSpec::is_legal_cell) so that an illegal cell — one whose stored link would drive a wrong response transformation — is rejected instead of silently masked by LikelihoodSpec::kind.

pub const fn gaussian_identity() -> Self

pub const fn binomial_logit() -> Self

pub const fn binomial_probit() -> Self

pub const fn binomial_cloglog() -> Self

pub const fn binomial_latent_cloglog(state: LatentCLogLogState) -> Self

pub const fn binomial_sas(state: SasLinkState) -> Self

pub const fn binomial_beta_logistic(state: SasLinkState) -> Self

pub fn binomial_mixture(state: MixtureLinkState) -> Self

pub const fn poisson_log() -> Self

pub const fn tweedie_log(p: f64) -> Self

pub const fn negative_binomial_log(theta: f64) -> Self

Estimated-theta NB spec: theta is the seed, refined by the inner solver (#802 default).

pub const fn negative_binomial_log_fixed(theta: f64) -> Self

Fixed-theta NB spec: the fit holds theta at exactly this value (--negative-binomial-theta, issue #983).

pub const fn beta_logit(phi: f64) -> Self

pub const fn gamma_log() -> Self

pub const fn royston_parmar() -> Self

pub const fn link_function(&self) -> LinkFunction

pub fn kind(&self) -> FamilySpecKind

Once-and-for-all classification into the legal-only FamilySpecKind.

(ResponseFamily, InverseLink) is a 40-cell product (8 response × 5 inverse-link); only the cells listed here are legal. Construction (LikelihoodSpec::try_new) and deserialization (the LikelihoodSpecWire try_from) both enforce LikelihoodSpec::is_legal_cell, so an illegal cell can never reach this method. Each link-pinned family therefore matches its one legal link explicitly; the remaining (now-unreachable) illegal combinations are unreachable!() so the historical silent masking — collapsing e.g. Poisson + Identity to PoissonLog while the transform predicted μ = η — can never silently happen again.

pub fn is_binomial(&self) -> bool

pub fn is_gaussian_identity(&self) -> bool

pub fn is_royston_parmar(&self) -> bool

pub fn is_latent_cloglog(&self) -> bool

pub fn is_binomial_mixture(&self) -> bool

pub fn is_binomial_sas(&self) -> bool

pub fn is_binomial_beta_logistic(&self) -> bool

pub fn default_scale_metadata(&self) -> LikelihoodScaleMetadata

Default scale metadata for this (response, link).

pub fn pretty_name(&self) -> &'static str

Human-readable label, routed through FamilySpecKind.

pub fn name(&self) -> &'static str

Short identifier, routed through FamilySpecKind.

pub fn supports_firth(&self) -> bool

pub const fn fixed_dispersion(&self) -> Option<f64>

Family-level fixed-dispersion contract. Returns the dispersion parameter phi that the GLM log-likelihood / weight expressions treat as fixed for the given ResponseFamily, or None when the family carries no fixed scale (profiled or jointly estimated).

• Gaussian and Gamma profile/estimate the scale jointly with the mean, so no fixed phi is exposed here.
• Binomial and Poisson are unit-scale exponential-family fits, so the contract is Some(1.0). NegativeBinomial’s overdispersion lives in theta (a separate parameter / flag), not in a free phi, so it also returns Some(1.0).
• Tweedie { p } carries its variance power on the family variant. Its free dispersion phi lives in LikelihoodScaleMetadata and is estimated by default (EstimatedTweediePhi, issue #771), so this family-level contract only exposes the unit seed used when callers ask the response family without scale metadata.
• Beta { phi } carries its precision parameter directly on the family variant; the contract returns that exact value rather than the placeholder used elsewhere for unit-scale GLMs.
• RoystonParmar has no GLM-style dispersion slot.

Trait Implementations

impl Clone for LikelihoodSpec

fn clone(&self) -> LikelihoodSpec

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LikelihoodSpec

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LikelihoodSpec

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<LikelihoodSpec> for LikelihoodSpecWire

fn from(spec: LikelihoodSpec) -> Self

Converts to this type from the input type.

impl PartialEq for LikelihoodSpec

fn eq(&self, other: &LikelihoodSpec) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for LikelihoodSpec

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for LikelihoodSpec

impl TryFrom<LikelihoodSpecWire> for LikelihoodSpec

type Error = IllegalLikelihoodCell

The type returned in the event of a conversion error.

fn try_from(wire: LikelihoodSpecWire) -> Result<Self, Self::Error>

Performs the conversion.