Struct WorkingModelSurvival 

pub struct WorkingModelSurvival { /* private fields */ }

Implementations

impl WorkingModelSurvival

pub fn monotonicity_linear_constraints( &self, ) -> Option<LinearInequalityConstraints>

pub fn from_engine_inputs( inputs: SurvivalEngineInputs<'_>, penalties: PenaltyBlocks, monotonicity: SurvivalMonotonicityPenalty, spec: SurvivalSpec, ) -> Result<Self, SurvivalError>

pub fn from_engine_inputswith_offsets( inputs: SurvivalEngineInputs<'_>, offsets: Option<SurvivalBaselineOffsets<'_>>, penalties: PenaltyBlocks, monotonicity: SurvivalMonotonicityPenalty, spec: SurvivalSpec, ) -> Result<Self, SurvivalError>

pub fn from_time_covariate_inputswith_offsets( inputs: SurvivalTimeCovarInputs<'_>, offsets: Option<SurvivalBaselineOffsets<'_>>, penalties: PenaltyBlocks, monotonicity: SurvivalMonotonicityPenalty, spec: SurvivalSpec, ) -> Result<Self, SurvivalError>

pub fn set_penalty_lambdas( &mut self, lambdas: &[f64], ) -> Result<(), EstimationError>

Enable/disable monotonic time-block enforcement metadata.

Monotonicity is enforced through linear inequality constraints on the derivative design; enabling this records how many leading time columns belong to that constrained block. Overwrite the per-block smoothing parameters λ_k in place.

Used by the REML smoothing-parameter selection for transformation survival fits (issue #563): the outer optimizer proposes a ρ = log λ vector, sets the smoothing blocks’ λ_k here, and re-runs the inner constrained PIRLS, so the monotone I-spline baseline can adapt its wiggliness instead of being pinned at a fixed seed. lambdas must have one entry per penalty block. The fixed stabilization ridge keeps its caller-set value (the optimizer never proposes a new one for it).

pub fn set_structural_monotonicity( &mut self, enabled: bool, time_columns: usize, ) -> Result<(), EstimationError>

pub fn update_state( &self, beta: &Array1<f64>, ) -> Result<WorkingState, EstimationError>

pub fn offset_channel_residuals( &self, beta: &Array1<f64>, ) -> Result<OffsetChannelResiduals, EstimationError>

Per-observation gradients of the unpenalized survival NLL with respect to each additive offset channel, at the given β.

Contract (Royston-Parmar, eta = log H(t)):

NLL_i(β; o_E, o_X, o_D) = w_i · [ exp(η1_i) − 1{has_entry}·exp(η0_i) − δ_i · (η1_i + log s_i) ]

with η1_i = a1_iᵀβ + o_X[i], η0_i = a0_iᵀβ + o_E[i], s_i = d_iᵀβ + o_D[i].

The additive offsets enter each of the three η channels linearly, so ∂NLL_i/∂o_X[i] = w_i · (exp(η1_i) − δ_i) ∂NLL_i/∂o_E[i] = −w_i · exp(η0_i) · 1{has_entry_interval} ∂NLL_i/∂o_D[i] = −w_i · δ_i / s_i (event-row only)

These three arrays are the sampleweight-scaled residuals used to chain ∂NLL/∂offset into ∂NLL/∂θ via any closed-form ∂offset/∂θ map (see baseline_offset_theta_partials for parametric baselines). At converged β*, the envelope theorem on the penalized objective gives

d[0.5·(deviance + βᵀS_λβ)] / dθ = Σᵢ r_X_i·∂o_X_i/∂θ + r_E_i·∂o_E_i/∂θ + r_D_i·∂o_D_i/∂θ

exactly (no IFT back-solve required), because β* is a stationary point of the penalized objective wrt β and the penalty has no θ dependence.

Rows with sampleweight[i] ≤ 0 and non-event rows for r_D are returned as exact 0.0 so the output can be dot-producted against a per-obs baseline-partials array without a mask.

Structural-monotonicity stabilization on s_i (see stabilized_structural_derivative) is applied identically to the existing update_state path so the residual agrees with the NLL that update_state evaluates.

pub fn unified_lamlobjective_and_rhogradient( &self, beta: &Array1<f64>, state: &WorkingState, rho: &Array1<f64>, ) -> Result<(f64, Array1<f64>), EstimationError>

Build an InnerSolution from the survival working state, suitable for the unified REML/LAML evaluator.

Evaluate the survival outer objective and gradient via the unified REML/LAML evaluator, using the canonical assembly module.

pub fn evaluate_survival_lamlcost_and_gradient( &self, rho: &[f64], beta0: &Array1<f64>, ) -> Result<(f64, Array1<f64>), EstimationError>

Self-contained ρ → (LAML value, analytic ρ-gradient) surface for the survival LAML objective.

Unlike unified_lamlobjective_and_rhogradient, which takes a pre-converged WorkingState and β̂ at the evaluated ρ, this shim re-converges the inner survival mode internally: it sets the active-block smoothing parameters to λ = exp(ρ), runs the same constrained inner PIRLS that the survival outer loop uses (runworking_model_pirls), then evaluates the unified survival LAML value and analytic ρ-gradient at the re-fitted β̂(ρ). The returned pair is therefore a single-source value+ gradient surface that a caller can finite-difference by varying ρ alone — the survival counterpart of the GLM path’s evaluate_externalgradient / evaluate_externalcost_andridge.

rho enumerates the active penalty blocks (those with λ > 0) in block order, matching the convention of the unified evaluator. beta0 is the inner warm-start. The behaviour is identical to the existing survival LAML path (set-λ → inner PIRLS → update_state → unified LAML); this is a reachability shim, not a new objective.

Trait Implementations

impl Clone for WorkingModelSurvival

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for WorkingModelSurvival

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

Formats the value using the given formatter.

impl WorkingModel for WorkingModelSurvival

fn update( &mut self, beta: &Coefficients, ) -> Result<WorkingState, EstimationError>

fn update_with_curvature( &mut self, beta: &Coefficients, _: HessianCurvatureKind, ) -> Result<WorkingState, EstimationError>

fn update_candidate( &mut self, beta: &Coefficients, curvature: HessianCurvatureKind, ) -> Result<WorkingState, EstimationError>

fn screen_candidate( &mut self, beta: &Coefficients, arr: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, _: &LinearPredictor, curvature: HessianCurvatureKind, ) -> Result<CandidateEvaluation, EstimationError>

fn supports_observed_information_curvature(&self) -> bool