Struct CtnTransformTable 

pub struct CtnTransformTable { /* private fields */ }

A per-row tabulation of the fitted CTN transform h(·|x_i) and its derivative on a shared response grid.

Invariants, all checked by CtnTransformTable::new:

• grid_y has g ≥ 2 finite, strictly increasing entries;
• h is n × g and strictly increasing along every row;
• h_prime is n × g, finite and strictly positive everywhere.

Together these make CtnTransformTable::invert a total, strictly increasing function of the latent argument on the whole real line: the tabulated part is a monotone bracket-and-solve, and the two tails are exact affine inverses at the end slopes.

Implementations

impl CtnTransformTable

pub fn new( grid_y: Array1<f64>, h: Array2<f64>, h_prime: Array2<f64>, ) -> Result<Self, String>

Assemble a table, validating every invariant invert relies on.

The validation is not defensive decoration: a non-monotone row makes the bracketing search meaningless, and a zero or negative slope makes the affine tail inverse point the wrong way (or to infinity). Both are structurally impossible for a feasible CTN fit — h' = ε + Σ_k M_k α_k with α ≥ 0 on the monotonicity cone — so either one signals a corrupt coefficient block, and the caller should hear about it here rather than receive a silently wrong quantile.

pub fn nrows(&self) -> usize

Number of covariate rows the table carries.

pub fn grid_y(&self) -> ArrayView1<'_, f64>

The shared, strictly increasing response grid the transform is tabulated on. Its first and last entries are the fitted support [y_lo, y_hi], the two points the affine tails are anchored at.

pub fn latent(&self) -> ArrayView2<'_, f64>

h[[i, k]] = h(grid_y[k] | x_i) — the model’s own latent, on the scale the standard normal is compared against.

pub fn tail_slopes(&self, row: usize) -> (f64, f64)

(h'(y_lo | x_i), h'(y_hi | x_i)) — the slopes of row i’s two affine tails, which are just the end columns of the derivative table.

pub fn evaluate(&self, row: usize, y: f64) -> f64

h(y | x_row) — the tabulated transform itself, by the same rule CtnTransformTable::invert inverts.

The forward map is part of the contract, not a convenience: without it “the inverse is the inverse of the interpolant” is not a statement anyone can check, and the only available check would be against the exact chart, which conflates a solver bug with an interpolation error.

pub fn invert(&self, row: usize, target: f64) -> f64

h⁻¹(target | x_row) — the response value whose latent is target.

Outside the tabulated range the transform is affine, so the inverse is the exact affine inverse rather than the support endpoint. Inside, the bracketing cell is inverted by safeguarded Newton on its Hermite interpolant. The branches agree at the endpoints by construction (target == h[0] returns grid_y[0] from either side), so the returned quantile function is continuous and strictly increasing in target on the whole real line.

Trait Implementations

impl Clone for CtnTransformTable

fn clone(&self) -> CtnTransformTable

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CtnTransformTable

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

Formats the value using the given formatter.