Crate gam_models 

Re-exports

pub use vector_response::GaussianVectorLikelihood;

pub use vector_response::MultinomialLogitLikelihood;

pub use vector_response::VectorLikelihood;

pub use vector_response::VectorNoise;

pub use vector_response::VectorResponseTarget;

Modules

binomial_multi

Penalized multi-output binomial-logit fitter at fixed λ.

block_layout

bms

cell_moment_family

Certified 2-D Chebyshev families of denested-cell derivative moments.

cubic_cell_kernel

custom_family

Custom-family namespace shim — reconstructs the pre-carve crate::custom_family (== crate::families::custom_family) flat namespace from the three crates the original families/custom_family/ module was split across by the #1521 carve:

family_runtime

fit_orchestration

gamlss

Multi-parameter GAMLSS family stack, organized into real concern modules.

gpu_kernels

inference

crate::inference::{quadrature, probability} → the carved homes of the two inference submodules that already live in leaf crates. The remaining crate::inference::{model, formula_dsl, smooth_test, predict_io, generative} submodules are still in the uncarved monolith (see blocker report) and are intentionally not shimmed here — there is no leaf crate to re-export them from yet.

inverse_link

joint_penalty

Joint (cross-block) penalty specifications — re-exported from gam-problem.

marginal_slope_orthogonal

Neyman-orthogonal, cross-fitted marginal-slope calibration (closes #461): the Stage-1 score-influence Jacobian and the absorbed influence block.

marginal_slope_shared

Shared kernels and outer-evaluation infrastructure for the marginal-slope family of GAMs (BMS, survival, latent survival).

model_types

crate::model_types → fit-result / penalty-spec carriers now in gam-solve, plus the finite-validation helper from gam-problem that gam-solve only re-exports crate-internally.

monotone_root

multinomial

Penalized multinomial-logit (softmax) GLM driver — fixed-λ inner solve.

outer_subsample

Outer-score row subsampling — re-exported from gam-problem.

parameter_block

penalized_projection

Penalized weighted least-squares projection.

penalized_vector_glm

Generic penalized vector-response GLM Newton solver (fixed λ).

probability

crate::probability → distributional primitives now in gam-math.

protocol

quadrature

crate::quadrature → quadrature rules now in gam-solve.

scale_design

seeding

crate::seeding → seed-config carriers now in gam-problem (the seeding module is private there; its items are surfaced at the crate root).

sigma_link

spatial_psi_bridge

Spatial-ψ derivative bridge.

survival

Survival families and survival-specific support code.

transformation_normal

Conditional transformation model: estimate h(y|x) such that h(Y|x) ~ N(0,1).

util

crate::util → progress/span utilities now in gam-runtime.

vector_response

Vector-valued response support.

wiggle

Macros

bail_dim_custom

bail_dim_sls

bail_invalid_estim

bail_invalid_surv

bail_invalid_tnorm

Structs

CompiledBlock

One compiled block: reparam matrix V (t_lw) and the optional anchor correction matrix M that downstream blocks consume as a first-class anchor.

CompiledBlocks

Output of compile: one CompiledBlock per input block plus the joint pre-fit audit verdict.

Enums

BlockOrder

Semantic block label. The compiler does not need to know what the block is, only its relative order — but downstream consumers (per-family install paths) tag the input operators with these labels so that the compiled output can be routed back to the right runtime slot.

CompilerError

Errors raised by compile.

Traits

RowHessian

Per-row K × K PSD Hessian of −log L_i(u_i) evaluated at a pilot β.

RowJacobianOperator

Maps a coefficient perturbation δβ ∈ R^p for one parameter block into its contribution to the per-row primary state u_i ∈ R^K.

Functions

compile

Compile a sequence of row-Jacobian operators against a shared row Hessian. Walks ordering left-to-right, residualising each block against the cumulative anchor in the H_i-weighted row metric, then performs a joint-design audit and emits one CompiledBlock per input (in the same order as operators).