Struct LatentZRankIntCalibration 

pub struct LatentZRankIntCalibration {
    pub sorted_z: Vec<f64>,
    pub weighted_cdf: Vec<f64>,
    pub post_mean: f64,
    pub post_sd: f64,
}

Blom-rankit weighted rank inverse-normal transform for the latent score.

When the latent z fails the standard-normal auto-detection ([latent_z_is_standard_normal_enough]), the BMS family applied to pretend the score is N(0,1) anyway would distort the closed-form probit log-CDF kernel. The historical fallback (local- or global-empirical latent measure) is mathematically correct but triggers the per-row intercept Newton solve in the empirical-grid closed-form kernels (empirical_rigid_primary_grad_hess_closed_form and its higher-order siblings); at large scale that is the dominant cost.

Rank-INT is exact under monotone re-parameterisation. The Blom rankit assigns each sorted training z the rank-probability (W_i − 0.375) / (W_total + 0.25), then maps that probability through Φ⁻¹. The transform is strictly monotone on the observed support, so the BMS likelihood is invariant up to a re-parameterisation (the model is a transformation-equivariant family on the latent axis). The transformed sample is exactly N(0,1) by construction, so the standard-normal closed-form kernel is exact on the calibrated scale. The kept work is the same closed-form signed_probit_logcdf_and_mills_ratio evaluation as the no-calibration path; the dropped work is the empirical-grid jet machinery. Persisted to disk so prediction applies the same monotone map to incoming z and re-routes through the closed-form kernel.

Fields

sorted_z: Vec<f64>

Sorted unique z values seen during training, ascending. Knot table for apply_to_training / apply_at_predict.

weighted_cdf: Vec<f64>

Weighted cumulative-distribution-function values at each sorted_z knot, in [eps, 1 - eps] with eps = 0.5 / W_total. Strictly increasing.

post_mean: f64

Weighted mean of the calibrated training sample. Used as a sanity-check value on fit; should be very close to zero.

post_sd: f64

Weighted SD of the calibrated training sample. Used as a sanity-check value on fit; should be very close to one.

Implementations

impl LatentZRankIntCalibration

pub fn fit(z: &Array1<f64>, weights: &Array1<f64>) -> Result<Self, String>

Fit the weighted rank-INT calibration from training z and weights.

Algorithm:

1. Sort rows by ascending z.
2. Compute cumulative weight W_i at each sorted row.
3. Blom-rankit cumulative probability: p_i = (W_i − 0.375) / (W_total + 0.25).
4. Clip to [eps, 1 − eps] with eps = 0.5 / W_total.
5. Store (sorted_z, weighted_cdf = p_i).

Returns the calibration plus the post-transform sample’s weighted mean / SD for sanity-check logging.

pub fn apply_to_training(&self, z: &Array1<f64>) -> Result<Array1<f64>, String>

Apply the calibration to the full training z vector, returning the calibrated sample. Equivalent to mapping each row’s z through Self::apply_at_predict, but vectorised.

pub fn apply_at_predict(&self, z: f64) -> f64

Apply the calibration to a single z at predict time.

Linear interpolation on (sorted_z, weighted_cdf) to obtain p ∈ [eps, 1 − eps], then Φ⁻¹(p) via standard_normal_quantile. Out-of-range z’s clip to the boundary CDF before the quantile, so the calibration extrapolates monotonically beyond the training support.

Trait Implementations

impl Clone for LatentZRankIntCalibration

fn clone(&self) -> LatentZRankIntCalibration

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LatentZRankIntCalibration

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for LatentZRankIntCalibration

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for LatentZRankIntCalibration

fn eq(&self, other: &LatentZRankIntCalibration) -> 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 LatentZRankIntCalibration

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 LatentZRankIntCalibration