Struct TransformationNormalFamily 

pub struct TransformationNormalFamily { /* private fields */ }

Conditional transformation model mapping Y|x to N(0,1).

Single-block CustomFamily. The block design is x_val (tensor product of response value basis × covariate design). The family internally holds x_deriv (tensor product of response derivative basis × covariate design) for the Jacobian term in the likelihood.

Implementations

impl TransformationNormalFamily

pub fn new( response: &Array1<f64>, weights: &Array1<f64>, offset: &Array1<f64>, covariate_design: DesignMatrix, covariate_penalties: Vec<PenaltyMatrix>, config: &TransformationNormalConfig, warm_start: Option<&TransformationWarmStart>, ) -> Result<Self, String>

Build a transformation model from response values and a pre-built covariate design operator with associated penalties.

Arguments

• response - The response variable y (n observations).
• covariate_design - Pre-built covariate-side design operator (n × p_cov).
• covariate_penalties - Penalty matrices for the covariate basis.
• config - Response-direction basis configuration.
• warm_start - Optional location/scale from a prior normalizer.

pub fn from_prebuilt_response_basis( response: &Array1<f64>, response_val_basis: Array2<f64>, response_deriv_basis: Array2<f64>, response_penalties: Vec<Array2<f64>>, response_knots: Array1<f64>, response_degree: usize, response_transform: Array2<f64>, weights: &Array1<f64>, offset: &Array1<f64>, covariate_design: DesignMatrix, covariate_penalties: Vec<PenaltyMatrix>, config: &TransformationNormalConfig, warm_start: Option<&TransformationWarmStart>, ) -> Result<Self, String>

Build from a prebuilt response basis, skipping response basis construction.

For the outer loop where the response basis is precomputed once and reused across κ iterations.

pub fn response_knots(&self) -> &Array1<f64>

Response basis metadata for serialization/prediction.

pub fn response_transform(&self) -> &Array2<f64>

pub fn response_degree(&self) -> usize

pub fn response_median(&self) -> f64

pub fn block_spec(&self) -> ParameterBlockSpec

Return the ParameterBlockSpec for this family (single block).

pub fn p_total(&self) -> usize

Total number of coefficients.

pub fn n_obs(&self) -> usize

Number of observations.

Trait Implementations

impl Clone for TransformationNormalFamily

fn clone(&self) -> TransformationNormalFamily

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl CustomFamily for TransformationNormalFamily

fn exact_newton_joint_gradient_evaluation( &self, block_states: &[ParameterBlockState], _: &[ParameterBlockSpec], ) -> Result<Option<ExactNewtonJointGradientEvaluation>, String>

Log-likelihood + flat joint gradient without building the dense Hessian.

The default trait implementation returns None, so the joint-Newton inner solver falls back to evaluate() to obtain the gradient — and that side-effects a full Θ(n p²) weighted_gram Hessian build at every inner iteration. CTN’s gradient is structurally

∇ℓ = -X_val^T (w·h) + X_deriv^T (w/h'),

which is two transpose_muls through the existing Khatri-Rao operators and one Θ(n) row reduction — Θ(n p) total. At large scale that is ~10⁷ FLOPs per call versus ~3·10¹⁰ for the full evaluate, so wiring this override is the gating condition for routing CTN’s inner solve through the matrix-free joint-Newton path without paying the dense H tax on every gradient refresh.

fn evaluate( &self, block_states: &[ParameterBlockState], ) -> Result<FamilyEvaluation, String>

Evaluate log-likelihood and per-block working quantities at current block predictors.

fn log_likelihood_only( &self, block_states: &[ParameterBlockState], ) -> Result<f64, String>

Compute only the log-likelihood without building working sets.

fn log_likelihood_only_with_options( &self, block_states: &[ParameterBlockState], options: &BlockwiseFitOptions, ) -> Result<f64, String>

Options-aware log-likelihood evaluation for line search.

fn exact_newton_joint_hessian_beta_dependent(&self) -> bool

Whether the joint likelihood Hessian H_L depends on β.

fn joint_jeffreys_term_required(&self) -> bool

Whether the family’s inner/outer solves need the full-span Jeffreys curvature H_Φ and score ∇Φ.

fn coefficient_hessian_cost(&self, specs: &[ParameterBlockSpec]) -> u64

Per-evaluation arithmetic cost of forming or applying the inner coefficient-space Hessian once, in flop-equivalent units. This is used for diagnostics, seed-budget policy, and first-order iteration caps when a family genuinely lacks analytic second-order support. It is not allowed to hide an analytic Hessian from the outer optimizer.

fn coefficient_gradient_cost(&self, specs: &[ParameterBlockSpec]) -> u64

Per-evaluation arithmetic cost of one analytic-gradient outer evaluation, in flop-equivalent units. Used only when the family genuinely has no analytic outer Hessian and the planner must use a first-order optimizer.

fn outer_derivative_policy( &self, specs: &[ParameterBlockSpec], psi_dim: usize, options: &BlockwiseFitOptions, ) -> OuterDerivativePolicy

Realized outer-derivative policy at the current problem size.

fn outer_seed_config(&self, n_params: usize) -> SeedConfig

Family-specific outer seeding policy.

fn max_feasible_step_size( &self, block_states: &[ParameterBlockState], block_index: usize, delta: &Array1<f64>, ) -> Result<Option<f64>, String>

Optional barrier-aware maximum feasible step size for a block update.

fn block_linear_constraints( &self, _: &[ParameterBlockState], block_index: usize, block_spec: &ParameterBlockSpec, ) -> Result<Option<LinearInequalityConstraints>, String>

Optional linear inequality constraints for a block update: A * beta_block >= b.

fn exact_newton_hessian_directional_derivative( &self, block_states: &[ParameterBlockState], block_index: usize, d_beta: &Array1<f64>, ) -> Result<Option<Array2<f64>>, String>

Optional exact directional derivative of a block’s ExactNewton Hessian.

fn exact_newton_joint_hessian( &self, block_states: &[ParameterBlockState], ) -> Result<Option<Array2<f64>>, String>

Optional exact joint coefficient-space Hessian across all blocks.

fn exact_newton_joint_hessian_directional_derivative( &self, block_states: &[ParameterBlockState], d_beta_flat: &Array1<f64>, ) -> Result<Option<Array2<f64>>, String>

Optional exact directional derivative of the joint coefficient-space Hessian.

fn exact_newton_joint_hessiansecond_directional_derivative( &self, block_states: &[ParameterBlockState], d_beta_u_flat: &Array1<f64>, d_beta_v_flat: &Array1<f64>, ) -> Result<Option<Array2<f64>>, String>

Optional exact second directional derivative of the joint Hessian.

fn exact_newton_joint_psi_terms( &self, block_states: &[ParameterBlockState], _: &[ParameterBlockSpec], psi_derivs: &[Vec<CustomFamilyBlockPsiDerivative>], psi_index: usize, ) -> Result<Option<ExactNewtonJointPsiTerms>, String>

Optional exact first-order joint psi terms over the flattened coefficient vector.

fn exact_newton_joint_psisecond_order_terms( &self, block_states: &[ParameterBlockState], _: &[ParameterBlockSpec], psi_derivs: &[Vec<CustomFamilyBlockPsiDerivative>], psi_i: usize, psi_j: usize, ) -> Result<Option<ExactNewtonJointPsiSecondOrderTerms>, String>

Optional exact second-order joint psi terms over the flattened coefficient vector.

fn exact_newton_joint_psihessian_directional_derivative( &self, block_states: &[ParameterBlockState], _: &[ParameterBlockSpec], psi_derivs: &[Vec<CustomFamilyBlockPsiDerivative>], psi_index: usize, d_beta_flat: &Array1<f64>, ) -> Result<Option<Array2<f64>>, String>

Optional mixed beta/psi Hessian drift D_beta H_psi[u].

fn exact_newton_joint_hessian_workspace( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], ) -> Result<Option<Arc<dyn ExactNewtonJointHessianWorkspace>>, String>

Optional per-evaluation workspace for exact joint Hessian operators and directional derivatives.

fn exact_newton_joint_psi_workspace( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], derivative_blocks: &[Vec<CustomFamilyBlockPsiDerivative>], ) -> Result<Option<Arc<dyn ExactNewtonJointPsiWorkspace>>, String>

Optional per-evaluation workspace for exact joint ψ derivatives.

fn exact_newton_joint_hessian_workspace_with_options( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], options: &BlockwiseFitOptions, ) -> Result<Option<Arc<dyn ExactNewtonJointHessianWorkspace>>, String>

Outer-aware variant of exact_newton_joint_hessian_workspace.

fn exact_newton_joint_psi_workspace_with_options( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], derivative_blocks: &[Vec<CustomFamilyBlockPsiDerivative>], options: &BlockwiseFitOptions, ) -> Result<Option<Arc<dyn ExactNewtonJointPsiWorkspace>>, String>

Outer-aware variant of exact_newton_joint_psi_workspace.

fn exact_newton_joint_psi_workspace_for_first_order_terms(&self) -> bool

Whether the family’s exact joint ψ workspace should also be built for first-order ψ terms during outer gradient evaluation.

fn inner_coefficient_hessian_hvp_available( &self, specs: &[ParameterBlockSpec], ) -> bool

Explicit name for the inner coefficient-space Hessian HVP capability.

fn outer_hyper_hessian_hvp_available( &self, specs: &[ParameterBlockSpec], ) -> bool

True only when the family has a real profiled outer Hessian-vector product over θ = (ρ, ψ), without enumerating all θ_i θ_j pairs.

fn outer_hyper_hessian_dense_available( &self, specs: &[ParameterBlockSpec], ) -> bool

True when the family can expose the dense profiled outer Hessian. Generic custom-family pairwise derivative paths default to dense availability; families with only inner HVP support should override this if dense θθ assembly is not a valid capability for their path.

fn persistent_warm_start_fingerprint( &self, specs: &[ParameterBlockSpec], options: &BlockwiseFitOptions, ) -> Option<String>

Family-owned fingerprint for persistent coefficient warm-starts.

fn supports_log_likelihood_early_exit(&self) -> bool

Whether log_likelihood_only_with_options can use BlockwiseFitOptions::early_exit_threshold to reject line-search trials without computing the full log-likelihood.

fn exact_newton_outerobjective(&self) -> ExactNewtonOuterObjective

Selects the outer objective semantics for exact-Newton families.

fn use_projected_penalty_logdet(&self) -> bool

Whether the outer REML/LAML logdet term ½ log|H + Sλ| and its analytic trace gradient ½ tr((H+Sλ)⁺ ∂Sλ) are evaluated over the FULL identifiable subspace range(H + Sλ) (mgcv’s generalized determinant, gam#752) rather than the penalty-range subspace range(Sλ).

fn exact_outer_derivative_order( &self, specs: &[ParameterBlockSpec], _: &BlockwiseFitOptions, ) -> ExactOuterDerivativeOrder

Declares how much exact outer calculus this family wants to expose for the current realized problem size.

fn outer_derivative_subsample_capable(&self) -> bool

Whether this family’s outer-only paths honour HT-weighted partial sums over options.outer_score_subsample.

fn requires_joint_outer_hyper_path(&self) -> bool

Whether outer hyper-derivative evaluation must use a joint exact path.

fn output_channel_assignment( &self, specs: &[ParameterBlockSpec], ) -> Option<Vec<usize>>

Per-block output-channel assignment for the identifiability audit.

fn block_geometry( &self, _: &[ParameterBlockState], spec: &ParameterBlockSpec, ) -> Result<(DesignMatrix, ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>), String>

Optional dynamic geometry hook for blocks whose design/offset depend on current values of other blocks.

fn block_geometry_is_dynamic(&self) -> bool

Whether block_geometry(...) can change with the current block state.

fn block_geometry_directional_derivative( &self, _: &[ParameterBlockState], _: usize, block_spec: &ParameterBlockSpec, arr: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<BlockGeometryDirectionalDerivative>, String>

Optional directional derivative of the effective block geometry wrt the current block coefficients.

fn post_update_block_beta( &self, _: &[ParameterBlockState], _: usize, block_spec: &ParameterBlockSpec, beta: ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, String>

Optional per-block coefficient projection applied after each block update.

fn joint_trust_metric_block_floor( &self, _: &[ParameterBlockState], _: &[ParameterBlockSpec], ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>>, String>

Optional scale-aware floor for the joint trust-region metric D.

fn exact_newton_hessian_second_directional_derivative( &self, _: &[ParameterBlockState], _: usize, arr: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, arr2: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional exact second directional derivative of a block’s ExactNewton Hessian.

fn exact_newton_joint_loglik_gradient( &self, _: &[ParameterBlockState], ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>>, String>

Optional block-concatenated log-likelihood gradient g = nabla l(theta) assembled from the SAME single source of truth as Self::exact_newton_joint_hessian (e.g. a per-row jet-tower kernel), so the damped Newton H delta = g is solved on a consistent (objective, gradient, Hessian) triple. The default returns None, leaving the caller on its legacy hand-assembled gradient.

fn batched_outer_gradient_terms( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], derivative_blocks: &[Vec<CustomFamilyBlockPsiDerivative>], rho: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, options: &BlockwiseFitOptions, hessian_workspace: Option<Arc<dyn ExactNewtonJointHessianWorkspace>>, ) -> Result<Option<BatchedOuterGradientTerms>, String>

Optional batched analytic-gradient hook.

fn batched_outer_hessian_terms( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], derivative_blocks: &[Vec<CustomFamilyBlockPsiDerivative>], rho: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, hessian_workspace: Option<Arc<dyn ExactNewtonJointHessianWorkspace>>, ) -> Result<Option<BatchedOuterHessianTerms>, String>

Optional batched analytic-Hessian / HVP hook.

fn inner_joint_workspace_gradient_available( &self, specs: &[ParameterBlockSpec], ) -> bool

fn prefers_matrix_free_inner_joint( &self, specs: &[ParameterBlockSpec], _: &[ParameterBlockState], ) -> bool

Opt families in to the matrix-free inner-Newton/PCG path on top of the generic use_joint_matrix_free_path heuristic.

fn inner_joint_workspace_log_likelihood_available( &self, specs: &[ParameterBlockSpec], ) -> bool

fn outer_hyper_hessian_operator( &self, specs: &[ParameterBlockSpec], ) -> Option<Arc<dyn OuterHessianOperator>>

Family-supplied exact outer Hessian operator over θ = (ρ, ψ).

fn exact_newton_joint_hessian_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional spec-aware exact joint Hessian.

fn joint_hessian_is_structurally_coupled( &self, block_states: &[ParameterBlockState], ) -> Result<bool, String>

Structural-coupling probe shared by the _with_specs joint dispatch gates: is the family’s exact_newton_joint_hessian a genuinely coupled matrix (nonzero off-diagonal blocks), as opposed to the trait’s block-diagonal default? This is the marker-free signal that lets the engine trust a coupled multi-block family that overrode the joint Hessian without hand-setting has_explicit_joint_hessian(). Returns false when no joint Hessian is available or it is block-diagonal.

fn likelihood_blocks_uncoupled(&self) -> bool

Whether the family’s log-likelihood Hessian is block-diagonal in the joint coefficient vector — i.e. ∂²L/∂β_a∂β_b = 0 for every pair of distinct blocks a ≠ b. Default false (assume coupling, the safe answer); families whose blocks share no η/W coupling override to true to opt into the default working-set joint-Hessian assembly for multi-block specs.

fn has_explicit_joint_hessian(&self) -> bool

Whether the family has an explicit override of exact_newton_joint_hessian (or its _with_specs variant) that returns the true coupled joint Hessian rather than the trait’s block-diagonal default.

fn joint_penalty_specs(&self) -> Result<Vec<JointPenaltySpec>, String>

Full-span cross-block smoothing penalties, in raw (pre-canonicalisation) coordinates over the entire stacked parameter vector Σ_b p_b_raw.

fn joint_jeffreys_information_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional Tier-B Jeffreys information matrix.

fn joint_jeffreys_information_directional_derivative_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], d_beta_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

First beta-directional derivative of Self::joint_jeffreys_information_with_specs.

fn joint_jeffreys_information_directional_derivative_all_axes_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], ) -> Result<Option<Vec<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>>, String>

where Self: Sync,

BATCHED all-axes FIRST beta-directional derivative of Self::joint_jeffreys_information_with_specs: with the direction sweeping every canonical axis e_a, return the p dense matrices {Hdot[e_a]}_{a=0..p}.

fn joint_jeffreys_information_second_directional_derivative_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], d_beta_u_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, d_betav_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Second beta-directional derivative of Self::joint_jeffreys_information_with_specs.

fn joint_jeffreys_information_second_directional_all_axes_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], d_beta_u_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<Vec<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>>, String>

BATCHED all-axes second beta-directional derivative of Self::joint_jeffreys_information_with_specs: with d_beta_u fixed and the second direction sweeping every canonical axis e_a, return the p dense matrices {H²dot[d_beta_u, e_a]}_{a=0..p}.

fn exact_newton_joint_contracted_trace_hessian( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], weight: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional contracted second beta-derivative of the observed joint Newton information:

fn joint_jeffreys_information_contracted_trace_hessian_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], weight: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Contracted second beta-derivative matching Self::joint_jeffreys_information_with_specs:

fn joint_jeffreys_information_contracted_trace_hessian_available(&self) -> bool

Whether Self::joint_jeffreys_information_contracted_trace_hessian_with_specs can supply the wide-p Jeffreys completion without the pairwise H'' fallback. Default false preserves the historical width cap exactly.

fn joint_jeffreys_information_matches_observed_hessian(&self) -> bool

Whether Self::joint_jeffreys_information_with_specs is the SAME object as the observed joint Newton Hessian (exact_newton_joint_hessian_with_specs).

fn levenberg_on_ill_conditioning(&self) -> bool

Whether the coupled-joint inner Newton should engage its self-vanishing Levenberg–Marquardt damping μ on a FULL-RANK-but-ILL-CONDITIONED penalized Hessian (cond > COND_NEWTON_SAFETY), not only on a rank-deficient one (nullity > 0). Default false (binary / AFT / others byte-identical). Survival marginal-slope overrides to true (#808: full-rank but cond ≈ 5.8e6; the self-vanishing μ shapes only the trajectory, so the converged β is unbiased and the log-slope target is preserved). Survival-local by trait override so the shared spectral-range solver stays byte-identical for every other family — in particular AFT (survival_location_scale), whose intercept-only-scale fits can be high-cond and which a shared (unconditional) gate would regress (#735/#736).

fn outer_default_trustworthy_for_joint_hessian( &self, specs: &[ParameterBlockSpec], ) -> bool

Internal helper: do the outer-REML _with_specs defaults trust the inner-fit’s block-diagonal-from-blocks output for this family?

fn exact_newton_outer_curvature( &self, _: &[ParameterBlockState], ) -> Result<Option<ExactNewtonOuterCurvature>, String>

Optional scale-aware exact joint curvature for the outer REML calculus.

fn exact_newton_outer_curvature_directional_derivative( &self, block_states: &[ParameterBlockState], d_beta_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional first directional derivative matching exact_newton_outer_curvature.

fn exact_newton_outer_curvature_directional_derivative_with_specs( &self, block_states: &[ParameterBlockState], _: &[ParameterBlockSpec], d_beta_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Spec-aware variant of exact_newton_outer_curvature_directional_derivative.

fn exact_newton_outer_curvature_second_directional_derivative( &self, block_states: &[ParameterBlockState], d_beta_u_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, d_beta_v_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional second directional derivative matching exact_newton_outer_curvature.

fn exact_newton_outer_curvature_second_directional_derivative_with_specs( &self, block_states: &[ParameterBlockState], _: &[ParameterBlockSpec], d_beta_u_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, d_beta_v_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Spec-aware variant of exact_newton_outer_curvature_second_directional_derivative.

fn exact_newton_joint_hessian_directional_derivative_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], d_beta_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional spec-aware exact first directional derivative of the joint Hessian.

fn exact_newton_joint_hessian_second_directional_derivative_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], d_beta_u_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, d_betav_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional spec-aware exact second directional derivative of the joint Hessian.

fn joint_outer_hyper_surrogate_hessian_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional joint multi-block outer-hyper surrogate Hessian over the flattened coefficient vector.

fn joint_outer_hyper_surrogate_hessian_directional_derivative_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], d_beta_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional first beta-directional derivative of the joint surrogate outer-hyper Hessian.

fn joint_outer_hyper_surrogate_hessian_second_directional_derivative_with_specs( &self, block_states: &[ParameterBlockState], specs: &[ParameterBlockSpec], d_beta_u_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, d_betav_flat: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 2]>>>, String>

Optional second beta-directional derivative of the joint surrogate outer-hyper Hessian.

fn diagonalworking_weights_directional_derivative( &self, _: &[ParameterBlockState], _: usize, arr: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>>, String>

Optional exact directional derivative of diagonal working weights along a predictor-space direction d_eta for BlockWorkingSet::Diagonal.

fn diagonalworking_weights_second_directional_derivative( &self, _: &[ParameterBlockState], _: usize, arr: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, arr2: &ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>, ) -> Result<Option<ArrayBase<OwnedRepr<f64>, Dim<[usize; 1]>>>, String>

Optional exact second directional derivative of diagonal working weights.

fn pseudo_logdet_mode(&self) -> PseudoLogdetMode

How the penalized Hessian’s log-determinant and its derivatives should handle eigenvalues below the numerical-stability floor.