moon-bayes-kit

    MoonBit Composable Bayesian Online Update Library

    Download zip
    Author
    Version
    0.1.9
    License
    Apache-2.0
    Last updated
    2 months ago
    Downloads
    80

    No dependencies

    #moon-bayes-kit

    MoonBit Composable Bayesian Online Update Library.

    #Features

    • Beta-Binomial Conjugate Model: Prior update and posterior predictions for binomial data.
    • Gamma-Poisson Conjugate Model: Inference on count data.
    • Normal-Normal Conjugate Model: Continuous data with known variance.
    • Dirichlet-Multinomial Conjugate Model: Categorical data with any number of categories.
    • Serialization: ToJson support for model persistence.

    #Extensible online updates

    Every model is immutable: update returns a new posterior, so updates can be composed, replayed, or persisted without hidden state. The categorical model accepts an arbitrary number of categories and supports both batch counts and one-observation-at-a-time updates.

    ///|
    test {
    let model = DirichletMultinomial::new([1.0, 1.0, 1.0])
    let posterior = model.update([3, 1, 0])
    debug_inspect(
    posterior.posterior_mean(),
    content=(
    #|[0.5714285714285714, 0.2857142857142857, 0.14285714285714285]
    ),
    )
    }

    #Example

    ///|
    test {
    // Create a Beta-Binomial model with prior alpha=1.0, beta=1.0 (Uniform prior)
    let prior = BetaBinomial::new(1.0, 1.0)

    // Update with 7 successes out of 10 trials
    let posterior = prior.update(7, 10)

    // Posterior mean is now (1+7) / (1+10+1) = 8 / 12 = 0.666...
    inspect(posterior.posterior_mean(), content="0.6666666666666666")
    }

    ///|
    test {
    // Gamma-Poisson model example
    let prior = GammaPoisson::new(2.0, 1.0)
    let posterior = prior.update(3, 2)
    inspect(posterior.posterior_mean(), content="1.6666666666666667")
    }

    ///|
    test {
    // Normal-Normal model example
    let prior = NormalNormal::new(0.0, 1.0, 1.0)
    let posterior = prior.update(1.0, 1)
    inspect(posterior.posterior_mean(), content="0.5")
    }

    Action

    pub enum Action {
    Reject
    Review
    Accept
    Escalate
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ActionRule

    pub struct ActionRule {
    lower : Double
    upper : Double
    action : Action
    priority : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ActionRule::matches

    fn ActionRule::matches(self : ActionRule, score : Double) -> Bool

    AdamConfig

    pub struct AdamConfig {
    learning_rate : Double
    beta1 : Double
    beta2 : Double
    epsilon : Double
    max_iterations : Int
    tolerance : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AdamConfig::new

    fn AdamConfig::new() -> AdamConfig

    AdamConfig::with_iterations

    fn AdamConfig::with_iterations(self : AdamConfig, value : Int) -> AdamConfig

    AdamConfig::with_learning_rate

    fn AdamConfig::with_learning_rate(self : AdamConfig, value : Double) -> AdamConfig

    AdamState

    pub struct AdamState {
    first_moment : Array[Double]
    second_moment : Array[Double]
    step : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AdamState::new

    fn AdamState::new(size : Int) -> AdamState

    AdamState::update

    fn AdamState::update(self : AdamState, gradient : Array[Double], config : AdamConfig) -> (AdamState, Array[Double])

    AlertEvaluator

    pub struct AlertEvaluator {
    rule : AlertRule
    streak : Int
    events : Array[AlertEvent]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AlertEvaluator::evaluate

    fn AlertEvaluator::evaluate(self : AlertEvaluator, timestamp : Int, value : Double) -> AlertEvaluator

    AlertEvaluator::events

    AlertEvaluator::is_active

    fn AlertEvaluator::is_active(self : AlertEvaluator) -> Bool

    AlertEvaluator::new

    AlertEvaluator::reset

    AlertEvaluator::streak

    fn AlertEvaluator::streak(self : AlertEvaluator) -> Int

    AlertEvent

    pub struct AlertEvent {
    rule : String
    timestamp : Int
    value : Double
    active : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AlertEvent::active

    fn AlertEvent::active(self : AlertEvent) -> Bool

    AlertEvent::rule

    fn AlertEvent::rule(self : AlertEvent) -> String

    AlertEvent::timestamp

    fn AlertEvent::timestamp(self : AlertEvent) -> Int

    AlertEvent::value

    fn AlertEvent::value(self : AlertEvent) -> Double

    AlertRule

    pub struct AlertRule {
    name : String
    comparator : Comparator
    threshold : Double
    tolerance : Double
    consecutive : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AlertRule::matches

    fn AlertRule::matches(self : AlertRule, value : Double) -> Bool

    AlertRule::name

    fn AlertRule::name(self : AlertRule) -> String

    AlertRule::new

    fn AlertRule::new(name : String, comparator : Comparator, threshold : Double) -> AlertRule

    AlertRule::required_consecutive

    fn AlertRule::required_consecutive(self : AlertRule) -> Int

    AlertRule::with_consecutive

    fn AlertRule::with_consecutive(self : AlertRule, count : Int) -> AlertRule

    AlertRule::with_tolerance

    fn AlertRule::with_tolerance(self : AlertRule, tolerance : Double) -> AlertRule

    AllocationCheck

    pub struct AllocationCheck {
    expected_control : Double
    observed_control : Double
    ratio_error : Double
    sample_ratio_mismatch : Bool
    control_count : Int
    treatment_count : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AnalysisArm

    pub struct AnalysisArm {
    name : String
    values : Array[Double]
    covariate : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Operational experiment analysis: variance reduction, allocation checks, sequential guardrails, power planning, and metric attribution. The module complements the lower-level experiment design APIs with reports suitable for release reviews and automated decision gates.

    AnalysisArm::count

    fn AnalysisArm::count(self : AnalysisArm) -> Int

    AnalysisArm::mean

    fn AnalysisArm::mean(self : AnalysisArm) -> Double

    AnalysisArm::new

    fn AnalysisArm::new(name : String) -> AnalysisArm

    AnalysisArm::record

    fn AnalysisArm::record(self : AnalysisArm, value : Double) -> AnalysisArm

    AnalysisArm::standard_error

    fn AnalysisArm::standard_error(self : AnalysisArm) -> Double

    AnalysisArm::variance

    fn AnalysisArm::variance(self : AnalysisArm) -> Double

    AnalysisArm::with_covariate

    fn AnalysisArm::with_covariate(self : AnalysisArm, covariate : Array[Double]) -> AnalysisArm

    AnalysisContrast

    pub struct AnalysisContrast {
    control : String
    treatment : String
    estimate : Double
    standard_error : Double
    lower_95 : Double
    upper_95 : Double
    relative_uplift : Double
    observations : Int
    significant : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Approval

    pub struct Approval {
    reviewer : String
    status : ApprovalStatus
    comment : String
    timestamp : Int
    expires_at : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Approval::approve

    fn Approval::approve(reviewer : String, comment : String, timestamp : Int, expires_at : Int) -> Approval

    Approval::is_active

    fn Approval::is_active(self : Approval, now : Int) -> Bool

    ApprovalStatus

    pub enum ApprovalStatus {
    Pending
    Approved
    Blocked
    Expired
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AssignmentMethod

    pub enum AssignmentMethod {
    FixedRatio
    EpsilonGreedy
    Stratified
    Blocked
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Sequential experimentation and uplift analysis utilities.

    AttributionEntry

    pub struct AttributionEntry {
    source : String
    contribution : Double
    share : Double
    cumulative : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AttributionLedger

    pub struct AttributionLedger {
    entries : Array[AttributionEntry]
    total : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AttributionLedger::new

    AttributionLedger::normalize

    AttributionLedger::record

    fn AttributionLedger::record(self : AttributionLedger, source : String, contribution : Double) -> AttributionLedger

    AttributionLedger::top_source

    AuditAction

    pub enum AuditAction {
    Registered
    MetricUpdated
    GateEvaluated
    Approved
    Deployed
    Promoted
    RolledBack
    Archived
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AuditEvent

    pub struct AuditEvent {
    model_name : String
    version : String
    action : AuditAction
    actor : String
    timestamp : Int
    details : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    AuditEvent::new

    fn AuditEvent::new(model_name : String, version : String, action : AuditAction, actor : String, timestamp : Int, details : String) -> AuditEvent

    BackpressurePolicy

    pub struct BackpressurePolicy {
    capacity : Int
    drop_oldest : Bool
    block_on_full : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    BackpressurePolicy::bounded

    fn BackpressurePolicy::bounded(capacity : Int) -> BackpressurePolicy

    BackpressurePolicy::lossy

    BalanceReport

    pub struct BalanceReport {
    standardized_difference : Double
    treated_mean : Double
    control_mean : Double
    treated_variance : Double
    control_variance : Double
    balanced : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    BanditArm

    pub struct BanditArm {
    name : String
    pulls : Int
    reward_sum : Double
    reward_square_sum : Double
    prior_mean : Double
    prior_strength : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Contextual bandit policies, regret accounting, and offline evaluation.

    BanditArm::mean

    fn BanditArm::mean(self : BanditArm) -> Double

    BanditArm::new

    fn BanditArm::new(name : String, prior_mean : Double, prior_strength : Double) -> BanditArm

    BanditArm::observe

    fn BanditArm::observe(self : BanditArm, reward : Double) -> BanditArm

    BanditArm::uncertainty

    fn BanditArm::uncertainty(self : BanditArm) -> Double

    BanditArm::variance

    fn BanditArm::variance(self : BanditArm) -> Double

    BanditContext

    pub struct BanditContext {
    features : Array[Double]
    arms : Array[BanditArm]
    time : Int
    total_reward : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    BanditContext::new

    BanditContext::observe

    fn BanditContext::observe(self : BanditContext, arm : Int, reward : Double) -> BanditContext

    BanditContext::set_features

    fn BanditContext::set_features(self : BanditContext, features : Array[Double]) -> BanditContext

    BanditEvaluation

    pub struct BanditEvaluation {
    value : Double
    standard_error : Double
    lower_95 : Double
    upper_95 : Double
    effective_sample_size : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    BanditPolicy

    pub struct BanditPolicy {
    arms : Array[BetaArm]
    rounds : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    BanditPolicy::arms

    fn BanditPolicy::arms(self : BanditPolicy) -> Array[BetaArm]

    BanditPolicy::best_arm

    fn BanditPolicy::best_arm(self : BanditPolicy) -> Int

    BanditPolicy::new

    BanditPolicy::observe

    fn BanditPolicy::observe(self : BanditPolicy, arm : Int, reward : Bool) -> BanditPolicy

    BanditPolicy::recommendation

    fn BanditPolicy::recommendation(self : BanditPolicy) -> String

    BanditPolicy::rounds

    fn BanditPolicy::rounds(self : BanditPolicy) -> Int

    BanditPolicy::select_upper_confidence

    fn BanditPolicy::select_upper_confidence(self : BanditPolicy, exploration : Double) -> Int

    BayesianExperimentDecision

    pub struct BayesianExperimentDecision {
    control_mean : Double
    treatment_mean : Double
    probability_treatment_better : Double
    expected_lift : Double
    recommendation : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    BayesianLinearRegression

    pub struct BayesianLinearRegression {
    prior_mean : Array[Double]
    prior_precision : DenseMatrix
    precision : DenseMatrix
    information : Array[Double]
    noise_variance : Double
    observations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Bayesian linear regression with a diagonal Gaussian prior.

    The implementation keeps the sufficient statistics X'X and X'y, so repeated micro-batches do not retain the original data. A ridge term makes the small-model API useful for sensor calibration and online forecasting.

    BayesianLinearRegression::add_observation

    fn BayesianLinearRegression::add_observation(self : BayesianLinearRegression, features : Array[Double], target : Double) -> BayesianLinearRegression

    BayesianLinearRegression::feature_count

    fn BayesianLinearRegression::feature_count(self : BayesianLinearRegression) -> Int

    BayesianLinearRegression::fit

    fn BayesianLinearRegression::fit(self : BayesianLinearRegression, features : Array[Array[Double]], targets : Array[Double]) -> BayesianLinearRegression

    BayesianLinearRegression::new

    fn BayesianLinearRegression::new(prior_mean : Array[Double], prior_variance : Double, noise_variance : Double) -> BayesianLinearRegression

    BayesianLinearRegression::observations

    fn BayesianLinearRegression::observations(self : BayesianLinearRegression) -> Int

    BayesianLinearRegression::posterior_covariance

    BayesianLinearRegression::posterior_mean

    fn BayesianLinearRegression::posterior_mean(self : BayesianLinearRegression) -> Array[Double]

    BayesianLinearRegression::posterior_precision

    BayesianLinearRegression::predict

    fn BayesianLinearRegression::predict(self : BayesianLinearRegression, features : Array[Double]) -> Double

    BayesianLinearRegression::predict_summary

    fn BayesianLinearRegression::predict_summary(self : BayesianLinearRegression, features : Array[Double]) -> PredictiveSummary

    BayesianLinearRegression::predict_variance

    fn BayesianLinearRegression::predict_variance(self : BayesianLinearRegression, features : Array[Double]) -> Double

    BayesianLinearRegression::r_squared

    fn BayesianLinearRegression::r_squared(self : BayesianLinearRegression, features : Array[Array[Double]], targets : Array[Double]) -> Double

    BayesianLinearRegression::residuals

    fn BayesianLinearRegression::residuals(self : BayesianLinearRegression, features : Array[Array[Double]], targets : Array[Double]) -> Array[Double]

    BayesianNetwork

    BayesianNetwork::add_factor

    fn BayesianNetwork::add_factor(self : BayesianNetwork, factor : Factor) -> BayesianNetwork

    BayesianNetwork::add_variable

    fn BayesianNetwork::add_variable(self : BayesianNetwork, variable : DiscreteVariable) -> BayesianNetwork

    BayesianNetwork::evidence_probability

    fn BayesianNetwork::evidence_probability(self : BayesianNetwork, evidence : Array[(String, Int)]) -> Double

    BayesianNetwork::joint

    BayesianNetwork::log_evidence

    fn BayesianNetwork::log_evidence(self : BayesianNetwork, evidence : Array[(String, Int)]) -> Double

    BayesianNetwork::new

    BayesianNetwork::query

    fn BayesianNetwork::query(self : BayesianNetwork, target : String, evidence : Array[(String, Int)]) -> Factor

    BayesianNetwork::variable

    fn BayesianNetwork::variable(self : BayesianNetwork, name : String) -> DiscreteVariable

    BernoulliDistribution

    pub struct BernoulliDistribution {
    probability : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    BernoulliDistribution::log_odds

    fn BernoulliDistribution::log_odds(self : BernoulliDistribution) -> Double

    BernoulliDistribution::mean

    fn BernoulliDistribution::mean(self : BernoulliDistribution) -> Double

    BernoulliDistribution::new

    fn BernoulliDistribution::new(probability : Double) -> BernoulliDistribution

    BernoulliDistribution::pmf

    fn BernoulliDistribution::pmf(self : BernoulliDistribution, success : Bool) -> Double

    BernoulliDistribution::predictive

    fn BernoulliDistribution::predictive(self : BernoulliDistribution, trials : Int) -> Array[Double]

    BernoulliDistribution::probability

    fn BernoulliDistribution::probability(self : BernoulliDistribution) -> Double

    BernoulliDistribution::variance

    fn BernoulliDistribution::variance(self : BernoulliDistribution) -> Double

    BetaArm

    pub struct BetaArm {
    name : String
    posterior : BetaBinomial
    pulls : Int
    reward_sum : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    A reproducible multi-armed Bernoulli bandit built from Beta posteriors.

    BetaArm::empirical_rate

    fn BetaArm::empirical_rate(self : BetaArm) -> Double

    BetaArm::name

    fn BetaArm::name(self : BetaArm) -> String

    BetaArm::new

    fn BetaArm::new(name : String, alpha : Double, beta : Double) -> BetaArm

    BetaArm::observe

    fn BetaArm::observe(self : BetaArm, reward : Bool) -> BetaArm

    BetaArm::optimistic_score

    fn BetaArm::optimistic_score(self : BetaArm, z : Double) -> Double

    BetaArm::posterior

    fn BetaArm::posterior(self : BetaArm) -> BetaBinomial

    BetaArm::pulls

    fn BetaArm::pulls(self : BetaArm) -> Int

    BetaArm::reward_sum

    fn BetaArm::reward_sum(self : BetaArm) -> Int

    BetaBinomial

    pub(all) struct BetaBinomial {
    alpha : Double
    beta : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Beta-Binomial conjugate model.

    BetaBinomial::credible_interval_95

    fn BetaBinomial::credible_interval_95(self : BetaBinomial) -> (Double, Double)

    Returns a Normal-approximation 95% credible interval (lower, upper).

    BetaBinomial::effective_sample_size

    fn BetaBinomial::effective_sample_size(self : BetaBinomial) -> Double

    BetaBinomial::new

    fn BetaBinomial::new(alpha : Double, beta : Double) -> BetaBinomial

    Creates a new BetaBinomial model with given prior parameters.

    BetaBinomial::posterior_mean

    fn BetaBinomial::posterior_mean(self : BetaBinomial) -> Double

    The mean of the posterior distribution.

    BetaBinomial::posterior_mode

    fn BetaBinomial::posterior_mode(self : BetaBinomial) -> Double

    BetaBinomial::posterior_predictive_mean

    fn BetaBinomial::posterior_predictive_mean(self : BetaBinomial, new_trials : Int) -> Double

    Returns the posterior predictive mean for a given number of new trials.

    BetaBinomial::posterior_predictive_summary

    fn BetaBinomial::posterior_predictive_summary(self : BetaBinomial, trials : Int) -> PredictiveSummary

    BetaBinomial::posterior_predictive_variance

    fn BetaBinomial::posterior_predictive_variance(self : BetaBinomial, new_trials : Int) -> Double

    Returns the posterior predictive variance for a given number of new trials.

    BetaBinomial::posterior_variance

    fn BetaBinomial::posterior_variance(self : BetaBinomial) -> Double

    The variance of the posterior distribution.

    BetaBinomial::predictive_distribution

    fn BetaBinomial::predictive_distribution(self : BetaBinomial, trials : Int) -> Array[Double]

    BetaBinomial::predictive_probability

    fn BetaBinomial::predictive_probability(self : BetaBinomial, successes : Int, trials : Int) -> Double

    Returns the Beta-Binomial predictive probability mass function for k successes. The recurrence avoids factorial overflow and is suitable for small decision windows such as A/B tests and capacity planning.

    BetaBinomial::predictive_quantile

    fn BetaBinomial::predictive_quantile(self : BetaBinomial, trials : Int, probability : Double) -> Int

    BetaBinomial::prior_strength

    fn BetaBinomial::prior_strength(self : BetaBinomial) -> Double

    BetaBinomial::summary

    BetaBinomial::update

    fn BetaBinomial::update(self : BetaBinomial, successes : Int, trials : Int) -> BetaBinomial

    Update the prior with data to compute the posterior. successes is the number of successful trials. trials is the total number of trials.

    BetaNegativeBinomial

    pub struct BetaNegativeBinomial {
    alpha : Double
    beta : Double
    failures : Int
    successes : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Beta-Negative-Binomial conjugate model for repeated-trial event counts. The model estimates the probability of success before a fixed number of failures. It is useful for reliability, conversion funnels, and retry data.

    BetaNegativeBinomial::credible_interval_95

    fn BetaNegativeBinomial::credible_interval_95(self : BetaNegativeBinomial) -> (Double, Double)

    BetaNegativeBinomial::expected_failures_before_success

    fn BetaNegativeBinomial::expected_failures_before_success(self : BetaNegativeBinomial) -> Double

    BetaNegativeBinomial::failure_distribution

    fn BetaNegativeBinomial::failure_distribution(self : BetaNegativeBinomial, maximum : Int) -> Array[Double]

    BetaNegativeBinomial::failures

    fn BetaNegativeBinomial::failures(self : BetaNegativeBinomial) -> Int

    BetaNegativeBinomial::new

    fn BetaNegativeBinomial::new(alpha : Double, beta : Double) -> BetaNegativeBinomial

    BetaNegativeBinomial::observe_failure

    BetaNegativeBinomial::observe_success

    BetaNegativeBinomial::posterior_mean

    fn BetaNegativeBinomial::posterior_mean(self : BetaNegativeBinomial) -> Double

    BetaNegativeBinomial::posterior_mode

    fn BetaNegativeBinomial::posterior_mode(self : BetaNegativeBinomial) -> Double

    BetaNegativeBinomial::posterior_variance

    fn BetaNegativeBinomial::posterior_variance(self : BetaNegativeBinomial) -> Double

    BetaNegativeBinomial::predictive_failure_probability

    fn BetaNegativeBinomial::predictive_failure_probability(self : BetaNegativeBinomial) -> Double

    BetaNegativeBinomial::predictive_success_probability

    fn BetaNegativeBinomial::predictive_success_probability(self : BetaNegativeBinomial) -> Double

    BetaNegativeBinomial::probability_of_failures

    fn BetaNegativeBinomial::probability_of_failures(self : BetaNegativeBinomial, failures : Int) -> Double

    BetaNegativeBinomial::successes

    fn BetaNegativeBinomial::successes(self : BetaNegativeBinomial) -> Int

    BetaNegativeBinomial::summary

    BetaNegativeBinomial::total_observations

    fn BetaNegativeBinomial::total_observations(self : BetaNegativeBinomial) -> Int

    BetaNegativeBinomial::update

    fn BetaNegativeBinomial::update(self : BetaNegativeBinomial, successes : Int, failures : Int) -> BetaNegativeBinomial

    BinaryBatch

    pub struct BinaryBatch {
    successes : Int
    trials : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    BinaryBatch::combine

    fn BinaryBatch::combine(self : BinaryBatch, other : BinaryBatch) -> BinaryBatch

    BinaryBatch::new

    fn BinaryBatch::new(successes : Int, trials : Int) -> BinaryBatch

    BinaryBatch::success_rate

    fn BinaryBatch::success_rate(self : BinaryBatch) -> Double

    BootstrapSummary

    pub struct BootstrapSummary {
    estimate : Double
    lower : Double
    upper : Double
    replicates : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    BootstrapSummary::estimate

    fn BootstrapSummary::estimate(self : BootstrapSummary) -> Double

    BootstrapSummary::interval

    fn BootstrapSummary::interval(self : BootstrapSummary) -> (Double, Double)

    BootstrapSummary::replicates

    fn BootstrapSummary::replicates(self : BootstrapSummary) -> Int

    CalibrationBin

    pub struct CalibrationBin {
    lower : Double
    upper : Double
    count : Int
    predicted_sum : Double
    observed_sum : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CalibrationBin::add

    fn CalibrationBin::add(self : CalibrationBin, probability : Double, observed : Bool) -> CalibrationBin

    CalibrationBin::count

    fn CalibrationBin::count(self : CalibrationBin) -> Int

    CalibrationBin::gap

    fn CalibrationBin::gap(self : CalibrationBin) -> Double

    CalibrationBin::new

    fn CalibrationBin::new(lower : Double, upper : Double) -> CalibrationBin

    CalibrationBin::observed_rate

    fn CalibrationBin::observed_rate(self : CalibrationBin) -> Double

    CalibrationBin::predicted_mean

    fn CalibrationBin::predicted_mean(self : CalibrationBin) -> Double

    CategoricalClass

    pub struct CategoricalClass {
    label : Int
    counts : Array[Array[Int]]
    total : Int
    prior : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Online categorical Naive Bayes for integer feature vocabularies.

    CategoricalClass::feature_probability

    fn CategoricalClass::feature_probability(self : CategoricalClass, feature : Int, value : Int) -> Double

    CategoricalClass::label

    fn CategoricalClass::label(self : CategoricalClass) -> Int

    CategoricalClass::new

    fn CategoricalClass::new(label : Int, feature_count : Int, vocabulary : Int, prior : Int) -> CategoricalClass

    CategoricalClass::observations

    fn CategoricalClass::observations(self : CategoricalClass) -> Int

    CategoricalClass::score

    fn CategoricalClass::score(self : CategoricalClass, features : Array[Int]) -> Double

    CategoricalClass::update

    fn CategoricalClass::update(self : CategoricalClass, features : Array[Int]) -> CategoricalClass

    CategoricalNaiveBayes

    pub struct CategoricalNaiveBayes {
    classes : Array[CategoricalClass]
    vocabulary : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CategoricalNaiveBayes::accuracy

    fn CategoricalNaiveBayes::accuracy(self : CategoricalNaiveBayes, labels : Array[Int], features : Array[Array[Int]]) -> Double

    CategoricalNaiveBayes::class_count

    fn CategoricalNaiveBayes::class_count(self : CategoricalNaiveBayes) -> Int

    CategoricalNaiveBayes::class_observations

    fn CategoricalNaiveBayes::class_observations(self : CategoricalNaiveBayes, label : Int) -> Int

    CategoricalNaiveBayes::fit

    fn CategoricalNaiveBayes::fit(self : CategoricalNaiveBayes, labels : Array[Int], features : Array[Array[Int]]) -> CategoricalNaiveBayes

    CategoricalNaiveBayes::new

    fn CategoricalNaiveBayes::new(labels : Array[Int], feature_count : Int, vocabulary : Int) -> CategoricalNaiveBayes

    CategoricalNaiveBayes::predict

    fn CategoricalNaiveBayes::predict(self : CategoricalNaiveBayes, features : Array[Int]) -> Int

    CategoricalNaiveBayes::predict_scores

    fn CategoricalNaiveBayes::predict_scores(self : CategoricalNaiveBayes, features : Array[Int]) -> Array[Double]

    CategoricalNaiveBayes::update

    fn CategoricalNaiveBayes::update(self : CategoricalNaiveBayes, label : Int, features : Array[Int]) -> CategoricalNaiveBayes

    CategoricalNaiveBayes::vocabulary_size

    fn CategoricalNaiveBayes::vocabulary_size(self : CategoricalNaiveBayes) -> Int

    CausalEffect

    pub struct CausalEffect {
    estimate : Double
    standard_error : Double
    lower_95 : Double
    upper_95 : Double
    treated : Int
    control : Int
    estimator : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CausalEffect::significant

    fn CausalEffect::significant(self : CausalEffect) -> Bool

    CausalObservation

    pub struct CausalObservation {
    treatment : Bool
    outcome : Double
    propensity : Double
    weight : Double
    stratum : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Practical causal-effect estimators and sensitivity diagnostics.

    CausalObservation::new

    fn CausalObservation::new(treatment : Bool, outcome : Double, propensity : Double) -> CausalObservation

    CausalObservation::with_stratum

    fn CausalObservation::with_stratum(self : CausalObservation, stratum : String) -> CausalObservation

    ChainDiagnostics

    pub struct ChainDiagnostics {
    samples : Int
    acceptance_rate : Double
    effective_sample_size : Double
    mean : Double
    variance : Double
    rhat : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CohortDrift

    pub struct CohortDrift {
    cohort : String
    baseline_count : Int
    current_count : Int
    count_ratio : Double
    score_shift : Double
    drifted : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CohortGap

    pub struct CohortGap {
    reference : String
    cohort : String
    score_gap : Double
    positive_rate_gap : Double
    recall_gap : Double
    precision_ratio : Double
    meets_policy : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CohortMetric

    pub struct CohortMetric {
    cohort : String
    observations : Int
    weighted_observations : Double
    positive_rate : Double
    mean_score : Double
    brier : Double
    precision : Double
    recall : Double
    f1 : Double
    threshold : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CohortObservation

    pub struct CohortObservation {
    cohort : String
    score : Double
    outcome : Bool
    weight : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Cohort and fairness analysis for model evaluation. Cohorts are represented as ordinary strings, which keeps the report portable across data stores and makes subgroup regressions easy to serialize into CI artifacts.

    CohortObservation::new

    fn CohortObservation::new(cohort : String, score : Double, outcome : Bool) -> CohortObservation

    CohortObservation::weighted

    fn CohortObservation::weighted(self : CohortObservation, weight : Double) -> CohortObservation

    CohortReport

    pub struct CohortReport {
    metrics : Array[CohortMetric]
    gaps : Array[CohortGap]
    reference : String
    policy_passed : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ColumnProfile

    pub struct ColumnProfile {
    name : String
    count : Int
    missing : Int
    distinct : Int
    numeric : Bool
    minimum : Double
    maximum : Double
    mean : Double
    variance : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ColumnProfile::has_values

    fn ColumnProfile::has_values(self : ColumnProfile) -> Bool

    ColumnProfile::missing_rate

    fn ColumnProfile::missing_rate(self : ColumnProfile) -> Double

    ColumnProfile::null_rate

    fn ColumnProfile::null_rate(self : ColumnProfile) -> Double

    ColumnProfile::observed

    fn ColumnProfile::observed(self : ColumnProfile) -> Int

    ColumnProfile::range

    fn ColumnProfile::range(self : ColumnProfile) -> Double

    Comparator

    pub enum Comparator {
    LessThan
    LessOrEqual
    GreaterThan
    GreaterOrEqual
    Equal
    NotEqual
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CompatibilityReport

    pub struct CompatibilityReport {
    compatible : Bool
    missing : Array[String]
    type_changes : Array[String]
    newly_required : Array[String]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ConditionalTable

    pub struct ConditionalTable {
    child : String
    parents : Array[String]
    cardinalities : Array[Int]
    probabilities : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ConditionalTable::factor

    fn ConditionalTable::factor(self : ConditionalTable, variables : Array[DiscreteVariable]) -> Factor

    ConditionalTable::new

    fn ConditionalTable::new(child : String, parents : Array[String], cardinalities : Array[Int], probabilities : Array[Double]) -> ConditionalTable

    ConditionalTable::row_count

    fn ConditionalTable::row_count(self : ConditionalTable) -> Int

    ConditionalTable::validate

    fn ConditionalTable::validate(self : ConditionalTable) -> Bool

    ConformalCalibrator

    pub struct ConformalCalibrator {
    residuals : Array[Double]
    level : Double
    quantile : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ConformalCalibrator::coverage

    fn ConformalCalibrator::coverage(self : ConformalCalibrator, actual : Array[Double], predicted : Array[Double]) -> Double

    ConformalCalibrator::fit

    fn ConformalCalibrator::fit(residuals : Array[Double], confidence : Double) -> ConformalCalibrator

    ConformalCalibrator::interval

    fn ConformalCalibrator::interval(self : ConformalCalibrator, prediction : Double) -> PredictionInterval

    ConfusionMatrix

    pub struct ConfusionMatrix {
    true_positive : Int
    true_negative : Int
    false_positive : Int
    false_negative : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    A confusion matrix for binary decisions.

    ConfusionMatrix::accuracy

    fn ConfusionMatrix::accuracy(self : ConfusionMatrix) -> Double

    ConfusionMatrix::add

    fn ConfusionMatrix::add(self : ConfusionMatrix, actual : Bool, predicted : Bool) -> ConfusionMatrix

    ConfusionMatrix::add_all

    fn ConfusionMatrix::add_all(self : ConfusionMatrix, actual : Array[Bool], predicted : Array[Bool]) -> ConfusionMatrix

    ConfusionMatrix::f1

    fn ConfusionMatrix::f1(self : ConfusionMatrix) -> Double

    ConfusionMatrix::new

    ConfusionMatrix::precision

    fn ConfusionMatrix::precision(self : ConfusionMatrix) -> Double

    ConfusionMatrix::recall

    fn ConfusionMatrix::recall(self : ConfusionMatrix) -> Double

    ConfusionMatrix::total

    fn ConfusionMatrix::total(self : ConfusionMatrix) -> Int

    ContractIssue

    pub struct ContractIssue {
    field : String
    message : String
    blocking : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CoordinateSearchResult

    pub struct CoordinateSearchResult {
    parameters : Array[Double]
    loss : Double
    iterations : Int
    converged : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CountBatch

    pub struct CountBatch {
    total : Int
    observations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CountBatch::combine

    fn CountBatch::combine(self : CountBatch, other : CountBatch) -> CountBatch

    CountBatch::new

    fn CountBatch::new(total : Int, observations : Int) -> CountBatch

    CountBatch::rate

    fn CountBatch::rate(self : CountBatch) -> Double

    CounterfactualResult

    pub struct CounterfactualResult {
    original : Double
    counterfactual : Double
    change : Double
    relative_change : Double
    feasible : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CovarianceSummary

    pub struct CovarianceSummary {
    count : Int
    mean_x : Double
    mean_y : Double
    cross_m2 : Double
    variance_x : Double
    variance_y : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CovarianceSummary::correlation

    fn CovarianceSummary::correlation(self : CovarianceSummary) -> Double

    CovarianceSummary::covariance

    fn CovarianceSummary::covariance(self : CovarianceSummary) -> Double

    CovarianceSummary::merge

    CovarianceSummary::new

    CovarianceSummary::push

    fn CovarianceSummary::push(self : CovarianceSummary, x : Double, y : Double) -> CovarianceSummary

    CovariateAdjustment

    pub struct CovariateAdjustment {
    raw_mean : Double
    adjusted_mean : Double
    coefficient : Double
    covariate_mean : Double
    variance_reduction : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CoverageReport

    pub struct CoverageReport {
    count : Int
    covered : Int
    coverage : Double
    target : Double
    error : Double
    average_width : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CusumDetector

    pub struct CusumDetector {
    target : Double
    allowance : Double
    threshold : Double
    positive : Double
    negative : Double
    updates : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    CUSUM detector for a mean shift with a configurable allowance.

    CusumDetector::direction

    fn CusumDetector::direction(self : CusumDetector) -> Int

    CusumDetector::is_drift

    fn CusumDetector::is_drift(self : CusumDetector) -> Bool

    CusumDetector::negative_score

    fn CusumDetector::negative_score(self : CusumDetector) -> Double

    CusumDetector::new

    fn CusumDetector::new(target : Double, allowance : Double, threshold : Double) -> CusumDetector

    CusumDetector::positive_score

    fn CusumDetector::positive_score(self : CusumDetector) -> Double

    CusumDetector::reset

    CusumDetector::update

    fn CusumDetector::update(self : CusumDetector, value : Double) -> CusumDetector

    DataContractSpec

    pub struct DataContractSpec {
    name : String
    required_columns : Array[String]
    min_rows : Int
    max_age : Int
    owner : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    DataContractSpec::at_least

    fn DataContractSpec::at_least(self : DataContractSpec, rows : Int) -> DataContractSpec

    DataContractSpec::fresh_within

    fn DataContractSpec::fresh_within(self : DataContractSpec, age : Int) -> DataContractSpec

    DataContractSpec::new

    fn DataContractSpec::new(name : String) -> DataContractSpec

    DataContractSpec::owned_by

    fn DataContractSpec::owned_by(self : DataContractSpec, owner : String) -> DataContractSpec

    DataContractSpec::require

    fn DataContractSpec::require(self : DataContractSpec, column : String) -> DataContractSpec

    DataSchema

    pub struct DataSchema {
    name : String
    version : String
    fields : Array[SchemaField]
    primary_key : Array[String]
    owner : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    DataSchema::add

    fn DataSchema::add(self : DataSchema, field : SchemaField) -> DataSchema

    DataSchema::field

    fn DataSchema::field(self : DataSchema, name : String) -> SchemaField

    DataSchema::field_count

    fn DataSchema::field_count(self : DataSchema) -> Int

    DataSchema::fingerprint

    fn DataSchema::fingerprint(self : DataSchema) -> String

    DataSchema::key

    fn DataSchema::key(self : DataSchema, fields : Array[String]) -> DataSchema

    DataSchema::new

    fn DataSchema::new(name : String, version : String) -> DataSchema

    DataSchema::required_fields

    fn DataSchema::required_fields(self : DataSchema) -> Array[String]

    Dataset

    pub struct Dataset {
    columns : Array[String]
    rows : Array[Array[Double]]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    A small immutable tabular dataset used by model training and evaluation.

    Dataset::append

    fn Dataset::append(self : Dataset, row : Array[Double]) -> Dataset

    Dataset::batch

    fn Dataset::batch(self : Dataset, size : Int) -> Array[Dataset]

    Dataset::column

    fn Dataset::column(self : Dataset, index : Int) -> Array[Double]

    Dataset::column_count

    fn Dataset::column_count(self : Dataset) -> Int

    Dataset::column_index

    fn Dataset::column_index(self : Dataset, name : String) -> Int

    Dataset::columns

    fn Dataset::columns(self : Dataset) -> Array[String]

    Dataset::correlation

    fn Dataset::correlation(self : Dataset, left : Int, right : Int) -> Double

    Dataset::covariance

    fn Dataset::covariance(self : Dataset, left : Int, right : Int) -> Double

    Dataset::describe

    fn Dataset::describe(self : Dataset) -> Array[OnlineStats]

    Dataset::empty

    fn Dataset::empty(columns : Array[String]) -> Dataset

    Dataset::filter

    fn Dataset::filter(self : Dataset, predicate : (Array[Double]) -> Bool) -> Dataset

    Dataset::join

    fn Dataset::join(self : Dataset, other : Dataset) -> Dataset

    Dataset::map_rows

    fn Dataset::map_rows(self : Dataset, transform : (Array[Double]) -> Array[Double]) -> Dataset

    Dataset::max

    fn Dataset::max(self : Dataset, column : Int) -> Double

    Dataset::mean

    fn Dataset::mean(self : Dataset, column : Int) -> Double

    Dataset::min

    fn Dataset::min(self : Dataset, column : Int) -> Double

    Dataset::missing_count

    fn Dataset::missing_count(self : Dataset, predicate : (Double) -> Bool) -> Int

    Dataset::named_column

    fn Dataset::named_column(self : Dataset, name : String) -> Array[Double]

    Dataset::new

    fn Dataset::new(columns : Array[String], rows : Array[Array[Double]]) -> Dataset

    Dataset::normalize

    fn Dataset::normalize(self : Dataset, column : Int) -> Dataset

    Dataset::row

    fn Dataset::row(self : Dataset, index : Int) -> Array[Double]

    Dataset::row_count

    fn Dataset::row_count(self : Dataset) -> Int

    Dataset::rows

    fn Dataset::rows(self : Dataset) -> Array[Array[Double]]

    Dataset::select_columns

    fn Dataset::select_columns(self : Dataset, indices : Array[Int]) -> Dataset

    Dataset::select_rows

    fn Dataset::select_rows(self : Dataset, indices : Array[Int]) -> Dataset

    Dataset::standardize

    fn Dataset::standardize(self : Dataset, column : Int) -> Dataset

    Dataset::to_matrix

    fn Dataset::to_matrix(self : Dataset) -> DenseMatrix

    Dataset::train_test_split

    fn Dataset::train_test_split(self : Dataset, fraction : Double) -> (Dataset, Dataset)

    Dataset::variance

    fn Dataset::variance(self : Dataset, column : Int) -> Double

    DecisionConfusionMatrix

    pub struct DecisionConfusionMatrix {
    true_positive : Int
    false_positive : Int
    true_negative : Int
    false_negative : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    DecisionCost

    pub struct DecisionCost {
    false_positive : Double
    false_negative : Double
    true_positive : Double
    true_negative : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Decision analysis, threshold policies, and cost-sensitive evaluation.

    DecisionCost::expected

    fn DecisionCost::expected(self : DecisionCost, probabilities : Array[Double], actual : Array[Bool], threshold : Double) -> Double

    DecisionCost::new

    fn DecisionCost::new(false_positive : Double, false_negative : Double) -> DecisionCost

    DecisionLog

    pub struct DecisionLog {
    id : String
    score : Double
    action : Action
    threshold : Double
    reason : String
    timestamp : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    DecisionLog::new

    fn DecisionLog::new(id : String, score : Double, action : Action, threshold : Double, timestamp : Int) -> DecisionLog

    DenseMatrix

    pub struct DenseMatrix {
    rows : Int
    columns : Int
    values : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    A small dense matrix type for low-dimensional Bayesian models. It deliberately exposes copies at the boundary so models remain immutable.

    DenseMatrix::add

    fn DenseMatrix::add(self : DenseMatrix, other : DenseMatrix) -> DenseMatrix

    DenseMatrix::at

    fn DenseMatrix::at(self : DenseMatrix, row : Int, column : Int) -> Double

    DenseMatrix::column

    fn DenseMatrix::column(self : DenseMatrix, column : Int) -> Array[Double]

    DenseMatrix::columns

    fn DenseMatrix::columns(self : DenseMatrix) -> Int

    DenseMatrix::determinant

    fn DenseMatrix::determinant(self : DenseMatrix) -> Double

    DenseMatrix::diagonal

    fn DenseMatrix::diagonal(self : DenseMatrix) -> Array[Double]

    DenseMatrix::frobenius_norm

    fn DenseMatrix::frobenius_norm(self : DenseMatrix) -> Double

    DenseMatrix::from_rows

    fn DenseMatrix::from_rows(rows : Array[Array[Double]]) -> DenseMatrix

    DenseMatrix::hadamard

    fn DenseMatrix::hadamard(self : DenseMatrix, other : DenseMatrix) -> DenseMatrix

    DenseMatrix::identity

    fn DenseMatrix::identity(size : Int) -> DenseMatrix

    DenseMatrix::is_symmetric

    fn DenseMatrix::is_symmetric(self : DenseMatrix, tolerance? : Double) -> Bool

    DenseMatrix::matmul

    fn DenseMatrix::matmul(self : DenseMatrix, other : DenseMatrix) -> DenseMatrix

    DenseMatrix::matvec

    fn DenseMatrix::matvec(self : DenseMatrix, vector : Array[Double]) -> Array[Double]

    DenseMatrix::new

    fn DenseMatrix::new(rows : Int, columns : Int, values : Array[Double]) -> DenseMatrix

    DenseMatrix::row

    fn DenseMatrix::row(self : DenseMatrix, row : Int) -> Array[Double]

    DenseMatrix::rows

    fn DenseMatrix::rows(self : DenseMatrix) -> Int

    DenseMatrix::scale

    fn DenseMatrix::scale(self : DenseMatrix, factor : Double) -> DenseMatrix

    DenseMatrix::set

    fn DenseMatrix::set(self : DenseMatrix, row : Int, column : Int, value : Double) -> DenseMatrix

    DenseMatrix::subtract

    fn DenseMatrix::subtract(self : DenseMatrix, other : DenseMatrix) -> DenseMatrix

    DenseMatrix::trace

    fn DenseMatrix::trace(self : DenseMatrix) -> Double

    DenseMatrix::transpose

    fn DenseMatrix::transpose(self : DenseMatrix) -> DenseMatrix

    DenseMatrix::zeros

    fn DenseMatrix::zeros(rows : Int, columns : Int) -> DenseMatrix

    DeploymentRecord

    pub struct DeploymentRecord {
    model_name : String
    model_version : String
    strategy : DeploymentStrategy
    stage : ModelStage
    traffic_percent : Double
    replicas : Int
    started_at : Int
    ended_at : Int
    rollback_version : String
    approvals : Array[Approval]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    DeploymentRecord::add_approval

    fn DeploymentRecord::add_approval(self : DeploymentRecord, approval : Approval) -> DeploymentRecord

    DeploymentRecord::approved

    fn DeploymentRecord::approved(self : DeploymentRecord, now : Int) -> Bool

    DeploymentRecord::is_complete

    fn DeploymentRecord::is_complete(self : DeploymentRecord) -> Bool

    DeploymentRecord::new

    fn DeploymentRecord::new(model_name : String, model_version : String, strategy : DeploymentStrategy) -> DeploymentRecord

    DeploymentRecord::set_replicas

    fn DeploymentRecord::set_replicas(self : DeploymentRecord, replicas : Int) -> DeploymentRecord

    DeploymentRecord::set_traffic

    fn DeploymentRecord::set_traffic(self : DeploymentRecord, percent : Double) -> DeploymentRecord

    DeploymentRecord::with_rollback

    fn DeploymentRecord::with_rollback(self : DeploymentRecord, version : String) -> DeploymentRecord

    DeploymentStrategy

    pub enum DeploymentStrategy {
    Shadow
    Canary
    BlueGreen
    Rolling
    Batch
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    DeterministicRng

    pub struct DeterministicRng {
    state : UInt64
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    A tiny deterministic generator for reproducible examples and tests.

    DeterministicRng::int

    fn DeterministicRng::int(self : DeterministicRng, upper : Int) -> (DeterministicRng, Int)

    DeterministicRng::new

    fn DeterministicRng::new(seed : UInt64) -> DeterministicRng

    DeterministicRng::next

    fn DeterministicRng::next(self : DeterministicRng) -> (DeterministicRng, UInt64)

    DeterministicRng::uniform

    fn DeterministicRng::uniform(self : DeterministicRng) -> (DeterministicRng, Double)

    DirichletMultinomial

    pub struct DirichletMultinomial {
    alpha : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Dirichlet-Multinomial conjugate model for categorical observations.

    Each element of alpha is the prior concentration for one category. The category order is kept by the caller, so the model can be used for labels such as ["red", "green", "blue"] without introducing a dependency on a map implementation.

    DirichletMultinomial::category_count

    fn DirichletMultinomial::category_count(self : DirichletMultinomial) -> Int

    DirichletMultinomial::entropy

    fn DirichletMultinomial::entropy(self : DirichletMultinomial) -> Double

    DirichletMultinomial::new

    fn DirichletMultinomial::new(alpha : Array[Double]) -> DirichletMultinomial

    Creates a Dirichlet-Multinomial model from positive concentration values.

    DirichletMultinomial::posterior_mean

    fn DirichletMultinomial::posterior_mean(self : DirichletMultinomial) -> Array[Double]

    Returns the posterior mean probability for each category.

    DirichletMultinomial::posterior_mode

    fn DirichletMultinomial::posterior_mode(self : DirichletMultinomial) -> Array[Double]

    DirichletMultinomial::posterior_predictive_mean

    fn DirichletMultinomial::posterior_predictive_mean(self : DirichletMultinomial, trials : Int) -> Array[Double]

    Returns the expected count for each category in trials new observations.

    DirichletMultinomial::posterior_predictive_summary

    fn DirichletMultinomial::posterior_predictive_summary(self : DirichletMultinomial, trials : Int) -> Array[PredictiveSummary]

    DirichletMultinomial::posterior_variance

    fn DirichletMultinomial::posterior_variance(self : DirichletMultinomial) -> Array[Double]

    Returns the posterior variance for each category probability.

    DirichletMultinomial::predictive_distribution

    fn DirichletMultinomial::predictive_distribution(self : DirichletMultinomial) -> Array[Double]

    DirichletMultinomial::predictive_probability

    fn DirichletMultinomial::predictive_probability(self : DirichletMultinomial, category : Int) -> Double

    DirichletMultinomial::sample_without_randomness

    fn DirichletMultinomial::sample_without_randomness(self : DirichletMultinomial, observations : Int) -> Array[Int]

    DirichletMultinomial::summary

    DirichletMultinomial::total_concentration

    fn DirichletMultinomial::total_concentration(self : DirichletMultinomial) -> Double

    DirichletMultinomial::update

    Updates the model with category counts and returns the posterior.

    DirichletMultinomial::update_one

    fn DirichletMultinomial::update_one(self : DirichletMultinomial, index : Int) -> DirichletMultinomial

    Adds one observation for the category at index.

    DisagreementReport

    pub struct DisagreementReport {
    mean_disagreement : Double
    maximum_disagreement : Double
    high_disagreement_points : Array[Int]
    threshold : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    DiscreteVariable

    pub struct DiscreteVariable {
    name : String
    cardinality : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Discrete Bayesian-network factors and variable-elimination inference.

    DiscreteVariable::new

    fn DiscreteVariable::new(name : String, cardinality : Int) -> DiscreteVariable

    DistinctSketch

    pub struct DistinctSketch {
    capacity : Int
    values : Array[String]
    seen : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    DistinctSketch::estimate

    fn DistinctSketch::estimate(self : DistinctSketch) -> Double

    DistinctSketch::merge

    DistinctSketch::new

    fn DistinctSketch::new(capacity : Int) -> DistinctSketch

    DistinctSketch::push

    fn DistinctSketch::push(self : DistinctSketch, value : String) -> DistinctSketch

    DistinctSketch::push_all

    fn DistinctSketch::push_all(self : DistinctSketch, values : Array[String]) -> DistinctSketch

    DistributedSummary

    pub struct DistributedSummary {
    count : Int
    mean : Double
    m2 : Double
    minimum : Double
    maximum : Double
    sum : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Mergeable summaries for distributed telemetry and federated analytics.

    DistributedSummary::merge

    DistributedSummary::new

    DistributedSummary::push

    fn DistributedSummary::push(self : DistributedSummary, value : Double) -> DistributedSummary

    DistributedSummary::push_all

    fn DistributedSummary::push_all(self : DistributedSummary, values : Array[Double]) -> DistributedSummary

    DistributedSummary::standard_deviation

    fn DistributedSummary::standard_deviation(self : DistributedSummary) -> Double

    DistributedSummary::variance

    fn DistributedSummary::variance(self : DistributedSummary) -> Double

    DistributionKind

    pub enum DistributionKind {
    Bernoulli
    Count
    Continuous
    Categorical
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Common summaries for distributions used by applications without requiring callers to know the concrete conjugate model implementation.

    DistributionSummary

    pub struct DistributionSummary {
    kind : DistributionKind
    mean : Double
    variance : Double
    support_lower : Double
    support_upper : Double?
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    DistributionSummary::kind

    DistributionSummary::mean

    fn DistributionSummary::mean(self : DistributionSummary) -> Double

    DistributionSummary::new

    fn DistributionSummary::new(kind : DistributionKind, mean : Double, variance : Double, lower : Double, upper : Double?) -> DistributionSummary

    DistributionSummary::standard_deviation

    fn DistributionSummary::standard_deviation(self : DistributionSummary) -> Double

    DistributionSummary::support_lower

    fn DistributionSummary::support_lower(self : DistributionSummary) -> Double

    DistributionSummary::support_upper

    fn DistributionSummary::support_upper(self : DistributionSummary) -> Double?

    DistributionSummary::variance

    fn DistributionSummary::variance(self : DistributionSummary) -> Double

    EarlyStopping

    pub struct EarlyStopping {
    best : Double
    bad_rounds : Int
    patience : Int
    minimize : Bool
    stopped : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    EarlyStopping::best

    fn EarlyStopping::best(self : EarlyStopping) -> Double

    EarlyStopping::new

    fn EarlyStopping::new(patience : Int, minimize : Bool) -> EarlyStopping

    EarlyStopping::observe

    fn EarlyStopping::observe(self : EarlyStopping, value : Double) -> EarlyStopping

    EarlyStopping::should_stop

    fn EarlyStopping::should_stop(self : EarlyStopping) -> Bool

    EffectEstimate

    pub struct EffectEstimate {
    control : String
    treatment : String
    difference : Double
    relative : Double
    standard_error : Double
    lower_95 : Double
    upper_95 : Double
    probability_positive : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    EffectEstimate::lift

    fn EffectEstimate::lift(self : EffectEstimate) -> Double

    EffectEstimate::significant

    fn EffectEstimate::significant(self : EffectEstimate) -> Bool

    EmpiricalDistribution

    pub struct EmpiricalDistribution {
    values : Array[Double]
    probabilities : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Distribution records and numerical utilities used by simulation and decision layers. These functions use deterministic approximations so the base package stays small and portable across MoonBit backends.

    EmpiricalDistribution::cdf

    fn EmpiricalDistribution::cdf(self : EmpiricalDistribution, value : Double) -> Double

    EmpiricalDistribution::entropy

    fn EmpiricalDistribution::entropy(self : EmpiricalDistribution) -> Double

    EmpiricalDistribution::map_values

    fn EmpiricalDistribution::map_values(self : EmpiricalDistribution, transform : (Double) -> Double) -> EmpiricalDistribution

    EmpiricalDistribution::mean

    fn EmpiricalDistribution::mean(self : EmpiricalDistribution) -> Double

    EmpiricalDistribution::mixture

    EmpiricalDistribution::new

    fn EmpiricalDistribution::new(values : Array[Double], probabilities : Array[Double]) -> EmpiricalDistribution

    EmpiricalDistribution::probabilities

    fn EmpiricalDistribution::probabilities(self : EmpiricalDistribution) -> Array[Double]

    EmpiricalDistribution::quantile

    fn EmpiricalDistribution::quantile(self : EmpiricalDistribution, probability : Double) -> Double

    EmpiricalDistribution::standard_deviation

    fn EmpiricalDistribution::standard_deviation(self : EmpiricalDistribution) -> Double

    EmpiricalDistribution::uniform

    fn EmpiricalDistribution::uniform(values : Array[Double]) -> EmpiricalDistribution

    EmpiricalDistribution::values

    fn EmpiricalDistribution::values(self : EmpiricalDistribution) -> Array[Double]

    EmpiricalDistribution::variance

    fn EmpiricalDistribution::variance(self : EmpiricalDistribution) -> Double

    EncodingMap

    pub struct EncodingMap {
    categories : Array[String]
    unknown_code : Int
    ordered : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    EncodingMap::decode

    fn EncodingMap::decode(self : EncodingMap, code : Int) -> String

    EncodingMap::encode

    fn EncodingMap::encode(self : EncodingMap, value : String) -> Int

    EncodingMap::encode_all

    fn EncodingMap::encode_all(self : EncodingMap, values : Array[String]) -> Array[Int]

    EncodingMap::fit

    fn EncodingMap::fit(values : Array[String], ordered : Bool) -> EncodingMap

    EnsembleMember

    pub struct EnsembleMember {
    name : String
    predictions : Array[Double]
    weight : Double
    validation_loss : Double
    active : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    EnsembleMember::disabled

    EnsembleMember::new

    fn EnsembleMember::new(name : String, predictions : Array[Double]) -> EnsembleMember

    EnsembleMember::with_loss

    fn EnsembleMember::with_loss(self : EnsembleMember, loss : Double) -> EnsembleMember

    EnsembleMember::with_weight

    fn EnsembleMember::with_weight(self : EnsembleMember, weight : Double) -> EnsembleMember

    EnsembleMode

    pub enum EnsembleMode {
    Mean
    Median
    Weighted
    Trimmed
    Voting
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Ensemble weighting, stacking, and disagreement diagnostics.

    EnsemblePrediction

    pub struct EnsemblePrediction {
    values : Array[Double]
    lower : Array[Double]
    upper : Array[Double]
    member_count : Int
    disagreement : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    EqualizedOddsGap

    pub struct EqualizedOddsGap {
    cohort : String
    false_positive_rate_gap : Double
    true_positive_rate_gap : Double
    violation : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    EventStatus

    Survival-analysis utilities for reliability, retention, and time-to-event applications. Censoring is represented explicitly rather than inferred.

    EwmaDetector

    pub struct EwmaDetector {
    decay : Double
    threshold : Double
    level : Double
    initialized : Bool
    updates : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Exponentially weighted drift detector for an online metric.

    EwmaDetector::deviation

    fn EwmaDetector::deviation(self : EwmaDetector, value : Double) -> Double

    EwmaDetector::is_drift

    fn EwmaDetector::is_drift(self : EwmaDetector, value : Double) -> Bool

    EwmaDetector::level

    fn EwmaDetector::level(self : EwmaDetector) -> Double

    EwmaDetector::new

    fn EwmaDetector::new(decay : Double, threshold : Double) -> EwmaDetector

    EwmaDetector::reset

    EwmaDetector::update

    fn EwmaDetector::update(self : EwmaDetector, value : Double) -> EwmaDetector

    EwmaDetector::updates

    fn EwmaDetector::updates(self : EwmaDetector) -> Int

    ExperimentArm

    pub struct ExperimentArm {
    name : String
    observations : Int
    successes : Int
    sum : Double
    sum_squared : Double
    cost : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ExperimentArm::average_cost

    fn ExperimentArm::average_cost(self : ExperimentArm) -> Double

    ExperimentArm::count

    fn ExperimentArm::count(self : ExperimentArm) -> Int

    ExperimentArm::mean

    fn ExperimentArm::mean(self : ExperimentArm) -> Double

    ExperimentArm::new

    fn ExperimentArm::new(name : String) -> ExperimentArm

    ExperimentArm::rate

    fn ExperimentArm::rate(self : ExperimentArm) -> Double

    ExperimentArm::record

    fn ExperimentArm::record(self : ExperimentArm, value : Double) -> ExperimentArm

    ExperimentArm::record_cost

    fn ExperimentArm::record_cost(self : ExperimentArm, value : Double, cost : Double) -> ExperimentArm

    ExperimentArm::standard_error

    fn ExperimentArm::standard_error(self : ExperimentArm) -> Double

    ExperimentArm::variance

    fn ExperimentArm::variance(self : ExperimentArm) -> Double

    ExperimentDecision

    pub struct ExperimentDecision {
    winner : String
    confidence : Double
    stop : Bool
    reason : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ExperimentLog

    pub struct ExperimentLog {
    name : String
    points : Array[ExperimentPoint]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ExperimentLog::best_step

    fn ExperimentLog::best_step(self : ExperimentLog) -> Int

    ExperimentLog::errors

    fn ExperimentLog::errors(self : ExperimentLog) -> Array[Double]

    ExperimentLog::improvement

    fn ExperimentLog::improvement(self : ExperimentLog) -> Double

    ExperimentLog::last

    ExperimentLog::len

    fn ExperimentLog::len(self : ExperimentLog) -> Int

    ExperimentLog::mean_metric

    fn ExperimentLog::mean_metric(self : ExperimentLog) -> Double

    ExperimentLog::merge

    ExperimentLog::metric_variance

    fn ExperimentLog::metric_variance(self : ExperimentLog) -> Double

    ExperimentLog::metrics

    fn ExperimentLog::metrics(self : ExperimentLog) -> Array[Double]

    ExperimentLog::name

    fn ExperimentLog::name(self : ExperimentLog) -> String

    ExperimentLog::new

    fn ExperimentLog::new(name : String) -> ExperimentLog

    ExperimentLog::points

    ExperimentLog::record

    fn ExperimentLog::record(self : ExperimentLog, metric : Double, baseline : Double) -> ExperimentLog

    ExperimentPoint

    pub struct ExperimentPoint {
    step : Int
    metric : Double
    baseline : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Reproducible experiment records for comparing posterior updates.

    ExperimentPoint::error

    fn ExperimentPoint::error(self : ExperimentPoint) -> Double

    ExperimentPoint::metric

    fn ExperimentPoint::metric(self : ExperimentPoint) -> Double

    ExperimentPoint::step

    fn ExperimentPoint::step(self : ExperimentPoint) -> Int

    ExperimentQuality

    pub struct ExperimentQuality {
    sample_ratio_ok : Bool
    guardrails_ok : Bool
    sequential_ok : Bool
    complete : Bool
    ready_for_decision : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Explanation

    pub struct Explanation {
    baseline : Double
    prediction : Double
    bias : Double
    attributions : Array[FeatureAttribution]
    residual : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Explanation::new

    fn Explanation::new(baseline : Double, prediction : Double, attributions : Array[FeatureAttribution]) -> Explanation

    Explanation::positive_share

    fn Explanation::positive_share(self : Explanation) -> Double

    Explanation::top

    fn Explanation::top(self : Explanation, count : Int) -> Array[FeatureAttribution]

    ExponentialDistribution

    pub struct ExponentialDistribution {
    rate : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ExponentialDistribution::cdf

    fn ExponentialDistribution::cdf(self : ExponentialDistribution, value : Double) -> Double

    ExponentialDistribution::hazard

    fn ExponentialDistribution::hazard(self : ExponentialDistribution, _value : Double) -> Double

    ExponentialDistribution::mean

    ExponentialDistribution::new

    ExponentialDistribution::pdf

    fn ExponentialDistribution::pdf(self : ExponentialDistribution, value : Double) -> Double

    ExponentialDistribution::survival

    fn ExponentialDistribution::survival(self : ExponentialDistribution, value : Double) -> Double

    ExponentialDistribution::variance

    fn ExponentialDistribution::variance(self : ExponentialDistribution) -> Double

    ExponentialSurvival

    pub struct ExponentialSurvival {
    rate : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ExponentialSurvival::cdf

    fn ExponentialSurvival::cdf(self : ExponentialSurvival, time : Double) -> Double

    ExponentialSurvival::fit

    ExponentialSurvival::hazard

    fn ExponentialSurvival::hazard(self : ExponentialSurvival) -> Double

    ExponentialSurvival::mean

    fn ExponentialSurvival::mean(self : ExponentialSurvival) -> Double

    ExponentialSurvival::median

    fn ExponentialSurvival::median(self : ExponentialSurvival) -> Double

    ExponentialSurvival::new

    fn ExponentialSurvival::new(rate : Double) -> ExponentialSurvival

    ExponentialSurvival::quantile

    fn ExponentialSurvival::quantile(self : ExponentialSurvival, probability : Double) -> Double

    ExponentialSurvival::rate

    fn ExponentialSurvival::rate(self : ExponentialSurvival) -> Double

    ExponentialSurvival::survival

    fn ExponentialSurvival::survival(self : ExponentialSurvival, time : Double) -> Double

    Factor

    Factor::assignment

    fn Factor::assignment(self : Factor, flat_index : Int) -> Array[Int]

    Factor::at

    fn Factor::at(self : Factor, assignment : Array[Int]) -> Double

    Factor::condition

    fn Factor::condition(self : Factor, evidence : Array[(String, Int)]) -> Factor

    Factor::constant

    fn Factor::constant(value : Double) -> Factor

    Factor::contains

    fn Factor::contains(self : Factor, name : String) -> Bool

    Factor::index_of

    fn Factor::index_of(self : Factor, assignment : Array[Int]) -> Int

    Factor::map_values

    fn Factor::map_values(self : Factor, transform : (Double) -> Double) -> Factor

    Factor::marginalize

    fn Factor::marginalize(self : Factor, variable : String) -> Factor

    Factor::marginalize_all_except

    fn Factor::marginalize_all_except(self : Factor, target : String) -> Factor

    Factor::new

    fn Factor::new(variables : Array[DiscreteVariable], values : Array[Double]) -> Factor

    Factor::normalize

    fn Factor::normalize(self : Factor) -> Factor

    Factor::size

    fn Factor::size(self : Factor) -> Int

    Factor::stride

    fn Factor::stride(self : Factor, variable_index : Int) -> Int

    Factor::sum

    fn Factor::sum(self : Factor) -> Double

    Factor::variable_index

    fn Factor::variable_index(self : Factor, name : String) -> Int

    FairnessGap

    pub struct FairnessGap {
    metric : String
    maximum_gap : Double
    reference : String
    worst_group : String
    passes : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FairnessGroup

    pub struct FairnessGroup {
    name : String
    count : Int
    positive_rate : Double
    selection_rate : Double
    true_positive_rate : Double
    false_positive_rate : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeatureAttribution

    pub struct FeatureAttribution {
    feature : String
    contribution : Double
    absolute_contribution : Double
    rank : Int
    direction : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Model explanation and feature attribution utilities for review workflows.

    FeatureAttribution::new

    fn FeatureAttribution::new(feature : String, contribution : Double) -> FeatureAttribution

    FeatureColumn

    pub struct FeatureColumn {
    name : String
    transform : FeatureTransform
    values : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeatureColumn::clip

    fn FeatureColumn::clip(self : FeatureColumn, lower : Double, upper : Double) -> FeatureColumn

    FeatureColumn::fill

    fn FeatureColumn::fill(self : FeatureColumn, replacement : Double, is_missing : (Double) -> Bool) -> FeatureColumn

    FeatureColumn::fit_minmax

    fn FeatureColumn::fit_minmax(self : FeatureColumn) -> FeatureColumn

    FeatureColumn::fit_zscore

    fn FeatureColumn::fit_zscore(self : FeatureColumn) -> FeatureColumn

    FeatureColumn::missing_count

    fn FeatureColumn::missing_count(self : FeatureColumn, is_missing : (Double) -> Bool) -> Int

    FeatureColumn::name

    fn FeatureColumn::name(self : FeatureColumn) -> String

    FeatureColumn::new

    fn FeatureColumn::new(name : String, values : Array[Double]) -> FeatureColumn

    FeatureColumn::raw_values

    fn FeatureColumn::raw_values(self : FeatureColumn) -> Array[Double]

    FeatureColumn::threshold

    fn FeatureColumn::threshold(self : FeatureColumn, cutoff : Double) -> FeatureColumn

    FeatureColumn::values

    fn FeatureColumn::values(self : FeatureColumn) -> Array[Double]

    FeatureDefinition

    pub struct FeatureDefinition {
    name : String
    kind : FeatureValueKind
    entity : String
    description : String
    default_value : Double
    ttl_seconds : Int
    owner : String
    tags : Array[String]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeatureDefinition::new

    fn FeatureDefinition::new(name : String, entity : String, kind : FeatureValueKind) -> FeatureDefinition

    FeatureDefinition::tagged

    fn FeatureDefinition::tagged(self : FeatureDefinition, tag : String) -> FeatureDefinition

    FeatureDefinition::with_default

    fn FeatureDefinition::with_default(self : FeatureDefinition, default_value : Double) -> FeatureDefinition

    FeatureDefinition::with_ttl

    fn FeatureDefinition::with_ttl(self : FeatureDefinition, ttl_seconds : Int) -> FeatureDefinition

    FeatureDrift

    pub struct FeatureDrift {
    feature : String
    baseline_mean : Double
    current_mean : Double
    standardized_shift : Double
    population_stability : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeatureFreshness

    pub struct FeatureFreshness {
    feature : String
    score : Double
    latest_event : Int
    stale : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeatureObservation

    pub struct FeatureObservation {
    entity_id : String
    feature : String
    value : Double
    event_time : Int
    ingest_time : Int
    source : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeatureObservation::age

    fn FeatureObservation::age(self : FeatureObservation, now : Int) -> Int

    FeatureObservation::is_late

    fn FeatureObservation::is_late(self : FeatureObservation) -> Bool

    FeatureObservation::new

    fn FeatureObservation::new(entity_id : String, feature : String, value : Double, event_time : Int) -> FeatureObservation

    FeatureObservation::with_ingest_time

    fn FeatureObservation::with_ingest_time(self : FeatureObservation, ingest_time : Int) -> FeatureObservation

    FeaturePipeline

    pub struct FeaturePipeline {
    columns : Array[FeatureColumn]
    fitted : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeaturePipeline::column_count

    fn FeaturePipeline::column_count(self : FeaturePipeline) -> Int

    FeaturePipeline::columns

    FeaturePipeline::describe

    FeaturePipeline::drop

    fn FeaturePipeline::drop(self : FeaturePipeline, name : String) -> FeaturePipeline

    FeaturePipeline::fit_minmax

    FeaturePipeline::fit_zscore

    FeaturePipeline::new

    FeaturePipeline::transform

    fn FeaturePipeline::transform(self : FeaturePipeline) -> Dataset

    FeaturePipeline::transform_row

    fn FeaturePipeline::transform_row(self : FeaturePipeline, row : Array[Double]) -> Array[Double]

    FeaturePipeline::with_column

    fn FeaturePipeline::with_column(self : FeaturePipeline, column : FeatureColumn) -> FeaturePipeline

    FeatureSignature

    pub struct FeatureSignature {
    name : String
    data_type : String
    required : Bool
    default_value : String
    minimum : Double
    maximum : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeatureSignature::accepts

    fn FeatureSignature::accepts(self : FeatureSignature, value : Double) -> Bool

    FeatureSignature::is_bounded

    fn FeatureSignature::is_bounded(self : FeatureSignature) -> Bool

    FeatureSnapshot

    pub struct FeatureSnapshot {
    entity_id : String
    as_of : Int
    values : Array[(String, Double)]
    missing : Array[String]
    late_count : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeatureSnapshot::get

    fn FeatureSnapshot::get(self : FeatureSnapshot, feature : String) -> Double

    FeatureSnapshot::has

    fn FeatureSnapshot::has(self : FeatureSnapshot, feature : String) -> Bool

    FeatureSnapshot::new

    fn FeatureSnapshot::new(entity_id : String, as_of : Int) -> FeatureSnapshot

    FeatureSnapshot::vector

    fn FeatureSnapshot::vector(self : FeatureSnapshot, definitions : Array[FeatureDefinition]) -> Array[Double]

    FeatureStore

    FeatureStore::batch_lookup

    fn FeatureStore::batch_lookup(self : FeatureStore, entity_ids : Array[String], feature_names : Array[String], as_of : Int) -> Array[FeatureSnapshot]

    FeatureStore::definition

    fn FeatureStore::definition(self : FeatureStore, name : String) -> FeatureDefinition

    FeatureStore::freshness

    fn FeatureStore::freshness(self : FeatureStore, feature : String, now : Int) -> Double

    FeatureStore::freshness_report

    fn FeatureStore::freshness_report(self : FeatureStore, now : Int) -> Array[FeatureFreshness]

    FeatureStore::lookup

    fn FeatureStore::lookup(self : FeatureStore, entity_id : String, feature_names : Array[String], as_of : Int) -> FeatureSnapshot

    FeatureStore::new

    FeatureStore::observations_for

    fn FeatureStore::observations_for(self : FeatureStore, entity_id : String, feature : String) -> Array[FeatureObservation]

    FeatureStore::register

    fn FeatureStore::register(self : FeatureStore, definition : FeatureDefinition) -> FeatureStore

    FeatureStore::write

    fn FeatureStore::write(self : FeatureStore, observation : FeatureObservation) -> FeatureStore

    FeatureStore::write_batch

    fn FeatureStore::write_batch(self : FeatureStore, observations : Array[FeatureObservation]) -> FeatureStore

    FeatureStoreHealth

    pub struct FeatureStoreHealth {
    definitions : Int
    observations : Int
    missing_rate : Double
    stale_rate : Double
    drift_rate : Double
    score : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FeatureTransform

    pub enum FeatureTransform {
    Identity
    MinMax(lower~ : Double, upper~ : Double)
    ZScore(center~ : Double, scale~ : Double)
    Clip(lower~ : Double, upper~ : Double)
    Threshold(cutoff~ : Double)
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Reusable immutable feature transformations for model pipelines.

    FeatureTransform::apply

    fn FeatureTransform::apply(self : FeatureTransform, value : Double) -> Double

    FeatureTransform::apply_all

    fn FeatureTransform::apply_all(self : FeatureTransform, values : Array[Double]) -> Array[Double]

    FeatureTransform::inverse

    fn FeatureTransform::inverse(self : FeatureTransform, value : Double) -> Double

    FeatureValueKind

    pub enum FeatureValueKind {
    Numeric
    Boolean
    Text
    Vector
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Feature-store contracts, point-in-time lookup, and freshness governance.

    ForecastPoint

    pub struct ForecastPoint {
    step : Int
    value : Double
    lower : Double
    upper : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ForecastPoint::interval

    fn ForecastPoint::interval(self : ForecastPoint) -> (Double, Double)

    ForecastPoint::step

    fn ForecastPoint::step(self : ForecastPoint) -> Int

    ForecastPoint::value

    fn ForecastPoint::value(self : ForecastPoint) -> Double

    FreshnessWindow

    pub struct FreshnessWindow {
    latest : Int
    now : Int
    maximum_age : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    FreshnessWindow::age

    fn FreshnessWindow::age(self : FreshnessWindow) -> Int

    FreshnessWindow::is_fresh

    fn FreshnessWindow::is_fresh(self : FreshnessWindow) -> Bool

    GammaPoisson

    pub(all) struct GammaPoisson {
    shape : Double
    rate : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Gamma-Poisson conjugate model.

    GammaPoisson::credible_interval_95

    fn GammaPoisson::credible_interval_95(self : GammaPoisson) -> (Double, Double)

    Returns a Normal-approximation 95% credible interval (lower, upper).

    GammaPoisson::effective_exposure

    fn GammaPoisson::effective_exposure(self : GammaPoisson) -> Double

    GammaPoisson::new

    fn GammaPoisson::new(shape : Double, rate : Double) -> GammaPoisson

    Creates a new GammaPoisson model with given prior parameters.

    GammaPoisson::posterior_mean

    fn GammaPoisson::posterior_mean(self : GammaPoisson) -> Double

    The mean of the posterior distribution.

    GammaPoisson::posterior_mode

    fn GammaPoisson::posterior_mode(self : GammaPoisson) -> Double

    GammaPoisson::posterior_predictive_mean

    fn GammaPoisson::posterior_predictive_mean(self : GammaPoisson) -> Double

    Returns the posterior predictive mean for a single new observation.

    GammaPoisson::posterior_predictive_summary

    fn GammaPoisson::posterior_predictive_summary(self : GammaPoisson) -> PredictiveSummary

    GammaPoisson::posterior_predictive_variance

    fn GammaPoisson::posterior_predictive_variance(self : GammaPoisson) -> Double

    Returns the posterior predictive variance for a single new observation.

    GammaPoisson::posterior_variance

    fn GammaPoisson::posterior_variance(self : GammaPoisson) -> Double

    The variance of the posterior distribution.

    GammaPoisson::predictive_cdf

    fn GammaPoisson::predictive_cdf(self : GammaPoisson, maximum_count : Int) -> Double

    GammaPoisson::predictive_distribution

    fn GammaPoisson::predictive_distribution(self : GammaPoisson, maximum_count : Int) -> Array[Double]

    GammaPoisson::predictive_probability

    fn GammaPoisson::predictive_probability(self : GammaPoisson, count : Int) -> Double

    Negative-binomial predictive mass for a Gamma-Poisson posterior.

    GammaPoisson::summary

    GammaPoisson::update

    fn GammaPoisson::update(self : GammaPoisson, sum_x : Int, n : Int) -> GammaPoisson

    Update the prior with data to compute the posterior. sum_x is the sum of observed counts. n is the number of observations.

    GateResult

    pub struct GateResult {
    gate : String
    accepted : Bool
    failed_checks : Array[String]
    score : Double
    error_rate : Double
    drift : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    GaussianClass

    pub struct GaussianClass {
    label : Int
    prior : Double
    counts : Array[Int]
    summaries : Array[OnlineStats]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Gaussian Naive Bayes classifier with immutable online updates.

    GaussianClass::feature_count

    fn GaussianClass::feature_count(self : GaussianClass) -> Int

    GaussianClass::label

    fn GaussianClass::label(self : GaussianClass) -> Int

    GaussianClass::mean

    fn GaussianClass::mean(self : GaussianClass, feature : Int) -> Double

    GaussianClass::new

    fn GaussianClass::new(label : Int, feature_count : Int, prior : Double) -> GaussianClass

    GaussianClass::observations

    fn GaussianClass::observations(self : GaussianClass) -> Int

    GaussianClass::prior_probability

    fn GaussianClass::prior_probability(self : GaussianClass) -> Double

    GaussianClass::score

    fn GaussianClass::score(self : GaussianClass, features : Array[Double]) -> Double

    GaussianClass::update

    fn GaussianClass::update(self : GaussianClass, features : Array[Double]) -> GaussianClass

    GaussianClass::variance

    fn GaussianClass::variance(self : GaussianClass, feature : Int) -> Double

    GaussianNaiveBayes

    pub struct GaussianNaiveBayes {
    classes : Array[GaussianClass]
    feature_count : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    GaussianNaiveBayes::accuracy

    fn GaussianNaiveBayes::accuracy(self : GaussianNaiveBayes, labels : Array[Int], features : Array[Array[Double]]) -> Double

    GaussianNaiveBayes::class_count

    fn GaussianNaiveBayes::class_count(self : GaussianNaiveBayes) -> Int

    GaussianNaiveBayes::class_summary

    fn GaussianNaiveBayes::class_summary(self : GaussianNaiveBayes, label : Int) -> GaussianClass

    GaussianNaiveBayes::feature_count

    fn GaussianNaiveBayes::feature_count(self : GaussianNaiveBayes) -> Int

    GaussianNaiveBayes::fit

    fn GaussianNaiveBayes::fit(self : GaussianNaiveBayes, labels : Array[Int], features : Array[Array[Double]]) -> GaussianNaiveBayes

    GaussianNaiveBayes::new

    fn GaussianNaiveBayes::new(labels : Array[Int], feature_count : Int) -> GaussianNaiveBayes

    GaussianNaiveBayes::predict

    fn GaussianNaiveBayes::predict(self : GaussianNaiveBayes, features : Array[Double]) -> Int

    GaussianNaiveBayes::predict_scores

    fn GaussianNaiveBayes::predict_scores(self : GaussianNaiveBayes, features : Array[Double]) -> Array[Double]

    GaussianNaiveBayes::update

    fn GaussianNaiveBayes::update(self : GaussianNaiveBayes, label : Int, features : Array[Double]) -> GaussianNaiveBayes

    GeometricDistribution

    pub struct GeometricDistribution {
    probability : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    GeometricDistribution::cdf

    fn GeometricDistribution::cdf(self : GeometricDistribution, failures : Int) -> Double

    GeometricDistribution::mean

    fn GeometricDistribution::mean(self : GeometricDistribution) -> Double

    GeometricDistribution::new

    fn GeometricDistribution::new(probability : Double) -> GeometricDistribution

    GeometricDistribution::pmf

    fn GeometricDistribution::pmf(self : GeometricDistribution, failures : Int) -> Double

    GeometricDistribution::quantile

    fn GeometricDistribution::quantile(self : GeometricDistribution, probability : Double) -> Int

    GeometricDistribution::variance

    fn GeometricDistribution::variance(self : GeometricDistribution) -> Double

    GraphEdge

    pub struct GraphEdge {
    from : Int
    to : Int
    weight : Double
    label : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Graph and probabilistic dependency utilities for structured models.

    GraphEdge::new

    fn GraphEdge::new(from : Int, to : Int, weight : Double) -> GraphEdge

    GuardrailMetric

    pub struct GuardrailMetric {
    name : String
    control : Double
    treatment : Double
    minimum_ratio : Double
    maximum_drop : Double
    ratio : Double
    passed : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    GuardrailMetric::new

    fn GuardrailMetric::new(name : String, control : Double, treatment : Double, minimum_ratio : Double, maximum_drop : Double) -> GuardrailMetric

    GuardrailReport

    pub struct GuardrailReport {
    metrics : Array[GuardrailMetric]
    passed : Bool
    blocking_failures : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    HazardEstimate

    pub struct HazardEstimate {
    time : Double
    hazard : Double
    lower : Double
    upper : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    HazardEstimate::from_step

    fn HazardEstimate::from_step(step : SurvivalStep) -> HazardEstimate

    HazardEstimate::hazard

    fn HazardEstimate::hazard(self : HazardEstimate) -> Double

    HazardEstimate::lower

    fn HazardEstimate::lower(self : HazardEstimate) -> Double

    HazardEstimate::time

    fn HazardEstimate::time(self : HazardEstimate) -> Double

    HazardEstimate::upper

    fn HazardEstimate::upper(self : HazardEstimate) -> Double

    HistogramAccumulator

    pub struct HistogramAccumulator {
    lower : Double
    upper : Double
    buckets : Array[HistogramBucket]
    total : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    HistogramAccumulator::add

    HistogramAccumulator::add_all

    fn HistogramAccumulator::add_all(self : HistogramAccumulator, values : Array[Double]) -> HistogramAccumulator

    HistogramAccumulator::cdf

    HistogramAccumulator::counts

    HistogramAccumulator::new

    fn HistogramAccumulator::new(lower : Double, upper : Double, bins : Int) -> HistogramAccumulator

    HistogramAccumulator::total

    HistogramBucket

    pub struct HistogramBucket {
    lower : Double
    upper : Double
    count : Int
    weight : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    HistogramBucket::add

    fn HistogramBucket::add(self : HistogramBucket, value : Double, weight : Double) -> HistogramBucket

    HistogramBucket::contains

    fn HistogramBucket::contains(self : HistogramBucket, value : Double) -> Bool

    HistogramBucket::count

    fn HistogramBucket::count(self : HistogramBucket) -> Int

    HistogramBucket::midpoint

    fn HistogramBucket::midpoint(self : HistogramBucket) -> Double

    HistogramBucket::new

    fn HistogramBucket::new(lower : Double, upper : Double) -> HistogramBucket

    HistogramBucket::weight

    fn HistogramBucket::weight(self : HistogramBucket) -> Double

    ImportanceSample

    pub struct ImportanceSample {
    value : Double
    log_weight : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    InterpolationTable

    pub struct InterpolationTable {
    x : Array[Double]
    y : Array[Double]
    allow_extrapolation : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    InterpolationTable::evaluate

    fn InterpolationTable::evaluate(self : InterpolationTable, value : Double) -> Double

    InterpolationTable::evaluate_all

    fn InterpolationTable::evaluate_all(self : InterpolationTable, values : Array[Double]) -> Array[Double]

    InterpolationTable::new

    fn InterpolationTable::new(x : Array[Double], y : Array[Double]) -> InterpolationTable

    InterpolationTable::with_extrapolation

    fn InterpolationTable::with_extrapolation(self : InterpolationTable, enabled : Bool) -> InterpolationTable

    IntervalMethod

    pub enum IntervalMethod {
    Gaussian
    Empirical
    Conformal
    Bootstrap
    Quantile
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Predictive uncertainty, conformal calibration, and interval diagnostics.

    IsotonicPoint

    pub struct IsotonicPoint {
    score : Double
    probability : Double
    weight : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    JoinRow

    pub struct JoinRow {
    key : String
    left_index : Int
    right_index : Int
    matched : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    JoinType

    pub enum JoinType {
    Inner
    Left
    Right
    Full
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    KalmanModel

    pub struct KalmanModel {
    transition : Array[Array[Double]]
    observation : Array[Double]
    process_noise : Array[Array[Double]]
    observation_noise : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    KalmanModel::dimension

    fn KalmanModel::dimension(self : KalmanModel) -> Int

    KalmanModel::local_linear

    fn KalmanModel::local_linear(process_level : Double, process_trend : Double, observation_noise : Double) -> KalmanModel

    KalmanModel::scalar

    fn KalmanModel::scalar(persistence : Double, process_noise : Double, observation_noise : Double) -> KalmanModel

    KalmanModel::validate

    fn KalmanModel::validate(self : KalmanModel) -> Bool

    KalmanUpdate

    pub struct KalmanUpdate {
    estimate : StateEstimate
    innovation : Double
    innovation_variance : Double
    gain : Array[Double]
    log_likelihood : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    KaplanMeier

    pub struct KaplanMeier {
    steps : Array[SurvivalStep]
    observations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    KaplanMeier::confidence_width

    fn KaplanMeier::confidence_width(self : KaplanMeier, time : Double) -> Double

    KaplanMeier::failure_at

    fn KaplanMeier::failure_at(self : KaplanMeier, time : Double) -> Double

    KaplanMeier::fit

    fn KaplanMeier::fit(observations : Array[SurvivalObservation]) -> KaplanMeier

    KaplanMeier::hazard_at

    fn KaplanMeier::hazard_at(self : KaplanMeier, time : Double) -> Double

    KaplanMeier::median_survival

    fn KaplanMeier::median_survival(self : KaplanMeier) -> Double

    KaplanMeier::observations

    fn KaplanMeier::observations(self : KaplanMeier) -> Int

    KaplanMeier::quantile

    fn KaplanMeier::quantile(self : KaplanMeier, probability : Double) -> Double

    KaplanMeier::restricted_mean

    fn KaplanMeier::restricted_mean(self : KaplanMeier, horizon : Double) -> Double

    KaplanMeier::steps

    KaplanMeier::survival_at

    fn KaplanMeier::survival_at(self : KaplanMeier, time : Double) -> Double

    LifeTable

    pub struct LifeTable {
    intervals : Array[Double]
    exposed : Array[Double]
    deaths : Array[Double]
    survival : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    LifeTable::hazard_at

    fn LifeTable::hazard_at(self : LifeTable, interval : Int) -> Double

    LifeTable::intervals

    fn LifeTable::intervals(self : LifeTable) -> Array[Double]

    LifeTable::new

    fn LifeTable::new(intervals : Array[Double]) -> LifeTable

    LifeTable::record

    fn LifeTable::record(self : LifeTable, interval : Int, exposure : Double, deaths : Double) -> LifeTable

    LifeTable::survival_at

    fn LifeTable::survival_at(self : LifeTable, interval : Int) -> Double

    LifeTable::survival_curve

    fn LifeTable::survival_curve(self : LifeTable) -> Array[Double]

    LifeTable::total_deaths

    fn LifeTable::total_deaths(self : LifeTable) -> Double

    LifeTable::total_exposure

    fn LifeTable::total_exposure(self : LifeTable) -> Double

    LineageAsset

    pub struct LineageAsset {
    id : String
    kind : String
    owner : String
    schema_version : String
    tags : Array[String]
    row_count : Int
    updated_at : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Small, serializable data-lineage primitives for feature pipelines and model-training workflows. A lineage graph makes reproducibility and impact analysis explicit without requiring a database-specific implementation.

    LineageAsset::has_tag

    fn LineageAsset::has_tag(self : LineageAsset, tag : String) -> Bool

    LineageAsset::new

    fn LineageAsset::new(id : String, kind : String, owner : String, schema_version : String) -> LineageAsset

    LineageAsset::with_observation

    fn LineageAsset::with_observation(self : LineageAsset, row_count : Int, updated_at : Int) -> LineageAsset

    LineageAsset::with_tag

    fn LineageAsset::with_tag(self : LineageAsset, tag : String) -> LineageAsset

    LineageAudit

    LineageAudit::append

    fn LineageAudit::append(self : LineageAudit, asset_id : String, event : String, actor : String, at : Int, details : String) -> LineageAudit

    LineageAudit::event_count

    fn LineageAudit::event_count(self : LineageAudit) -> Int

    LineageAudit::for_asset

    fn LineageAudit::for_asset(self : LineageAudit, asset_id : String) -> Array[LineageAuditEvent]

    LineageAudit::latest

    fn LineageAudit::latest(self : LineageAudit, asset_id : String) -> LineageAuditEvent?

    LineageAudit::new

    LineageAuditEvent

    pub struct LineageAuditEvent {
    asset_id : String
    event : String
    actor : String
    at : Int
    details : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    LineageFreshnessWindow

    pub struct LineageFreshnessWindow {
    updated_at : Int
    now : Int
    age : Int
    fresh : Bool
    stale_by : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    LineageGraph

    LineageGraph::asset

    fn LineageGraph::asset(self : LineageGraph, id : String) -> LineageAsset?

    LineageGraph::asset_count

    fn LineageGraph::asset_count(self : LineageGraph) -> Int

    LineageGraph::downstream

    fn LineageGraph::downstream(self : LineageGraph, asset_id : String) -> Array[String]

    LineageGraph::impact

    fn LineageGraph::impact(self : LineageGraph, asset_id : String) -> Array[String]

    LineageGraph::new

    LineageGraph::operation_count

    fn LineageGraph::operation_count(self : LineageGraph) -> Int

    LineageGraph::operations_for

    fn LineageGraph::operations_for(self : LineageGraph, asset_id : String) -> Array[LineageOperation]

    LineageGraph::record

    fn LineageGraph::record(self : LineageGraph, operation : LineageOperation) -> LineageGraph

    LineageGraph::register_asset

    fn LineageGraph::register_asset(self : LineageGraph, asset : LineageAsset) -> LineageGraph

    LineageGraph::upstream

    fn LineageGraph::upstream(self : LineageGraph, asset_id : String) -> Array[String]

    LineageOperation

    pub struct LineageOperation {
    id : String
    name : String
    inputs : Array[String]
    outputs : Array[String]
    started_at : Int
    finished_at : Int
    status : String
    code_revision : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    LineageOperation::completed

    fn LineageOperation::completed(self : LineageOperation, at : Int) -> LineageOperation

    LineageOperation::failed

    fn LineageOperation::failed(self : LineageOperation, at : Int) -> LineageOperation

    LineageOperation::new

    fn LineageOperation::new(id : String, name : String, inputs : Array[String], outputs : Array[String]) -> LineageOperation

    LineageOperation::started

    fn LineageOperation::started(self : LineageOperation, at : Int) -> LineageOperation

    LineageOperation::with_revision

    fn LineageOperation::with_revision(self : LineageOperation, revision : String) -> LineageOperation

    LinearFit

    pub struct LinearFit {
    coefficients : Array[Double]
    intercept : Double
    loss : Double
    rmse : Double
    observations : Int
    iterations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    LinearFit::coefficients

    fn LinearFit::coefficients(self : LinearFit) -> Array[Double]

    LinearFit::intercept

    fn LinearFit::intercept(self : LinearFit) -> Double

    LinearFit::predict

    fn LinearFit::predict(self : LinearFit, features : Array[Double]) -> Double

    LinearFit::rmse

    fn LinearFit::rmse(self : LinearFit) -> Double

    LocalLevelModel

    pub struct LocalLevelModel {
    level : Double
    variance : Double
    observation_noise : Double
    process_noise : Double
    observations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    LocalLevelModel::forecast

    fn LocalLevelModel::forecast(self : LocalLevelModel, horizon : Int) -> Array[Double]

    LocalLevelModel::forecast_interval

    fn LocalLevelModel::forecast_interval(self : LocalLevelModel, horizon : Int, confidence : Double) -> Array[PredictionInterval]

    LocalLevelModel::new

    fn LocalLevelModel::new(level : Double, variance : Double, process_noise : Double, observation_noise : Double) -> LocalLevelModel

    LocalLevelModel::update

    fn LocalLevelModel::update(self : LocalLevelModel, value : Double) -> LocalLevelModel

    LossCurvePoint

    pub struct LossCurvePoint {
    threshold : Double
    accepted : Int
    reviewed : Int
    expected_loss : Double
    acceptance_rate : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MarkovChain

    pub struct MarkovChain {
    states : Int
    transition : Array[Array[Double]]
    initial : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MarkovChain::distribution

    fn MarkovChain::distribution(self : MarkovChain, steps : Int) -> Array[Double]

    MarkovChain::expected_state

    fn MarkovChain::expected_state(self : MarkovChain, values : Array[Double], steps : Int) -> Double

    MarkovChain::new

    fn MarkovChain::new(transition : Array[Array[Double]], initial : Array[Double]) -> MarkovChain

    MarkovChain::stationary

    fn MarkovChain::stationary(self : MarkovChain, iterations : Int) -> Array[Double]

    MarkovChain::step

    fn MarkovChain::step(self : MarkovChain, distribution : Array[Double]) -> Array[Double]

    MarkovChainState

    pub struct MarkovChainState {
    value : Double
    accepted : Int
    proposals : Int
    samples : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MarkovChainState::acceptance_rate

    fn MarkovChainState::acceptance_rate(self : MarkovChainState) -> Double

    MarkovChainState::new

    fn MarkovChainState::new(initial : Double) -> MarkovChainState

    MaterializationJob

    pub struct MaterializationJob {
    feature : String
    mode : MaterializationMode
    start_time : Int
    end_time : Int
    rows_written : Int
    status : PipelineStatus
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MaterializationJob::complete

    fn MaterializationJob::complete(self : MaterializationJob, rows : Int) -> MaterializationJob

    MaterializationJob::fail

    MaterializationJob::new

    fn MaterializationJob::new(feature : String, mode : MaterializationMode, start_time : Int, end_time : Int) -> MaterializationJob

    MaterializationMode

    pub enum MaterializationMode {
    Online
    Offline
    Hybrid
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MediationResult

    pub struct MediationResult {
    total_effect : Double
    direct_effect : Double
    indirect_effect : Double
    mediated_fraction : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MetricKind

    pub enum MetricKind {
    Gauge
    Counter
    Rate
    Histogram
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Stateful monitoring primitives represented as immutable snapshots. These types support service metrics, quality gates, alerting, and SLO review.

    MetricSample

    pub struct MetricSample {
    timestamp : Int
    value : Double
    weight : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MetricSample::new

    fn MetricSample::new(timestamp : Int, value : Double) -> MetricSample

    MetricSample::timestamp

    fn MetricSample::timestamp(self : MetricSample) -> Int

    MetricSample::value

    fn MetricSample::value(self : MetricSample) -> Double

    MetricSample::weight

    fn MetricSample::weight(self : MetricSample) -> Double

    MetricSample::weighted

    fn MetricSample::weighted(timestamp : Int, value : Double, weight : Double) -> MetricSample

    MetricStream

    pub struct MetricStream {
    name : String
    kind : MetricKind
    samples : Array[MetricSample]
    total : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MetricStream::change

    fn MetricStream::change(self : MetricStream) -> Double

    MetricStream::first

    fn MetricStream::first(self : MetricStream) -> Double

    MetricStream::histogram

    fn MetricStream::histogram(self : MetricStream, lower : Double, upper : Double, bins : Int) -> Array[Int]

    MetricStream::kind

    MetricStream::latest

    fn MetricStream::latest(self : MetricStream) -> Double

    MetricStream::len

    fn MetricStream::len(self : MetricStream) -> Int

    MetricStream::name

    fn MetricStream::name(self : MetricStream) -> String

    MetricStream::new

    fn MetricStream::new(name : String, kind : MetricKind) -> MetricStream

    MetricStream::push

    fn MetricStream::push(self : MetricStream, sample : MetricSample) -> MetricStream

    MetricStream::push_all

    fn MetricStream::push_all(self : MetricStream, samples : Array[MetricSample]) -> MetricStream

    MetricStream::push_value

    fn MetricStream::push_value(self : MetricStream, timestamp : Int, value : Double) -> MetricStream

    MetricStream::quantile

    fn MetricStream::quantile(self : MetricStream, probability : Double) -> Double

    MetricStream::rate

    fn MetricStream::rate(self : MetricStream, duration : Double) -> Double

    MetricStream::samples

    MetricStream::summary

    fn MetricStream::summary(self : MetricStream) -> OnlineStats

    MetricStream::values

    fn MetricStream::values(self : MetricStream) -> Array[Double]

    MetricStream::weighted_mean

    fn MetricStream::weighted_mean(self : MetricStream) -> Double

    MetricStream::window

    fn MetricStream::window(self : MetricStream, start : Int, finish : Int) -> MetricStream

    MigrationAction

    pub enum MigrationAction {
    AddField
    RemoveField
    RenameField
    CastField
    SetDefault
    RelaxConstraint
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MissingValuePolicy

    pub struct MissingValuePolicy {
    fill : Double
    lower : Double
    upper : Double
    dropped : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MissingnessSummary

    pub struct MissingnessSummary {
    columns : Int
    rows : Int
    total_missing : Int
    complete_rows : Int
    all_missing_columns : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MissingnessSummary::complete_rate

    fn MissingnessSummary::complete_rate(self : MissingnessSummary) -> Double

    MissingnessSummary::missing_rate

    fn MissingnessSummary::missing_rate(self : MissingnessSummary) -> Double

    ModelMetric

    pub struct ModelMetric {
    name : String
    value : Double
    threshold : Double
    higher_is_better : Bool
    validation_set : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ModelMetric::margin

    fn ModelMetric::margin(self : ModelMetric) -> Double

    ModelMetric::passes

    fn ModelMetric::passes(self : ModelMetric) -> Bool

    ModelRoute

    pub struct ModelRoute {
    model_name : String
    stable_version : String
    canary_version : String
    canary_percent : Int
    enabled : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ModelRoute::canary

    fn ModelRoute::canary(self : ModelRoute, version : String, percent : Int) -> ModelRoute

    ModelRoute::disable

    fn ModelRoute::disable(self : ModelRoute) -> ModelRoute

    ModelRoute::enable

    fn ModelRoute::enable(self : ModelRoute) -> ModelRoute

    ModelRoute::new

    fn ModelRoute::new(model_name : String, stable_version : String) -> ModelRoute

    ModelRoute::select

    fn ModelRoute::select(self : ModelRoute, request_id : String) -> String

    ModelScore

    pub struct ModelScore {
    name : String
    score : Double
    complexity : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ModelScore::complexity

    fn ModelScore::complexity(self : ModelScore) -> Int

    ModelScore::name

    fn ModelScore::name(self : ModelScore) -> String

    ModelScore::new

    fn ModelScore::new(name : String, score : Double, complexity : Int) -> ModelScore

    ModelScore::score

    fn ModelScore::score(self : ModelScore) -> Double

    ModelStage

    pub enum ModelStage {
    Draft
    Validating
    Staging
    Production
    Archived
    Rejected
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Reproducible model registry and deployment governance primitives.

    ModelVersion

    pub struct ModelVersion {
    name : String
    version : String
    artifact_uri : String
    source_revision : String
    created_at : Int
    stage : ModelStage
    metrics : Array[ModelMetric]
    features : Array[FeatureSignature]
    tags : Array[String]
    owner : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ModelVersion::add_feature

    fn ModelVersion::add_feature(self : ModelVersion, feature : FeatureSignature) -> ModelVersion

    ModelVersion::add_metric

    fn ModelVersion::add_metric(self : ModelVersion, metric : ModelMetric) -> ModelVersion

    ModelVersion::add_tag

    fn ModelVersion::add_tag(self : ModelVersion, tag : String) -> ModelVersion

    ModelVersion::all_metrics_pass

    fn ModelVersion::all_metrics_pass(self : ModelVersion) -> Bool

    ModelVersion::feature_count

    fn ModelVersion::feature_count(self : ModelVersion) -> Int

    ModelVersion::is_deployable

    fn ModelVersion::is_deployable(self : ModelVersion) -> Bool

    ModelVersion::metric

    fn ModelVersion::metric(self : ModelVersion, name : String) -> Double

    ModelVersion::new

    fn ModelVersion::new(name : String, version : String, artifact_uri : String) -> ModelVersion

    ModelVersion::required_features

    fn ModelVersion::required_features(self : ModelVersion) -> Array[String]

    ModelVersion::with_owner

    fn ModelVersion::with_owner(self : ModelVersion, owner : String) -> ModelVersion

    ModelVersion::with_revision

    fn ModelVersion::with_revision(self : ModelVersion, revision : String, created_at : Int) -> ModelVersion

    MonitorReport

    pub struct MonitorReport {
    name : String
    count : Int
    mean : Double
    deviation : Double
    latest : Double
    min : Double
    max : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MonitorReport::count

    fn MonitorReport::count(self : MonitorReport) -> Int

    MonitorReport::deviation

    fn MonitorReport::deviation(self : MonitorReport) -> Double

    MonitorReport::from_stream

    fn MonitorReport::from_stream(stream : MetricStream) -> MonitorReport

    MonitorReport::latest

    fn MonitorReport::latest(self : MonitorReport) -> Double

    MonitorReport::max

    fn MonitorReport::max(self : MonitorReport) -> Double

    MonitorReport::mean

    fn MonitorReport::mean(self : MonitorReport) -> Double

    MonitorReport::min

    fn MonitorReport::min(self : MonitorReport) -> Double

    MonitorReport::name

    fn MonitorReport::name(self : MonitorReport) -> String

    MonitorReport::z_score

    fn MonitorReport::z_score(self : MonitorReport) -> Double

    MonotonicityReport

    pub struct MonotonicityReport {
    feature : String
    violations : Int
    pairs : Int
    violation_rate : Double
    monotonic : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MonteCarloAccumulator

    pub struct MonteCarloAccumulator {
    count : Int
    mean : Double
    m2 : Double
    weight_sum : Double
    weight_square_sum : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    MonteCarloAccumulator::effective_sample_size

    fn MonteCarloAccumulator::effective_sample_size(self : MonteCarloAccumulator) -> Double

    MonteCarloAccumulator::estimate

    fn MonteCarloAccumulator::estimate(self : MonteCarloAccumulator, confidence : Double) -> MonteCarloEstimate

    MonteCarloAccumulator::new

    MonteCarloAccumulator::push

    MonteCarloAccumulator::push_weighted

    fn MonteCarloAccumulator::push_weighted(self : MonteCarloAccumulator, value : Double, weight : Double) -> MonteCarloAccumulator

    MonteCarloAccumulator::variance

    fn MonteCarloAccumulator::variance(self : MonteCarloAccumulator) -> Double

    MonteCarloEstimate

    pub struct MonteCarloEstimate {
    estimate : Double
    standard_error : Double
    lower_95 : Double
    upper_95 : Double
    samples : Int
    effective_sample_size : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Reproducible Monte Carlo, importance sampling, and chain diagnostics.

    MonteCarloEstimate::precise

    fn MonteCarloEstimate::precise(self : MonteCarloEstimate, tolerance : Double) -> Bool

    MonteCarloEstimate::relative_error

    fn MonteCarloEstimate::relative_error(self : MonteCarloEstimate) -> Double

    MultipleTestingMethod

    pub enum MultipleTestingMethod {
    Bonferroni
    Holm
    BenjaminiHochberg
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    NegativeBinomialDistribution

    pub struct NegativeBinomialDistribution {
    successes : Int
    probability : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    NegativeBinomialDistribution::cdf

    fn NegativeBinomialDistribution::cdf(self : NegativeBinomialDistribution, failures : Int) -> Double

    NegativeBinomialDistribution::mean

    NegativeBinomialDistribution::new

    fn NegativeBinomialDistribution::new(successes : Int, probability : Double) -> NegativeBinomialDistribution

    NegativeBinomialDistribution::pmf

    fn NegativeBinomialDistribution::pmf(self : NegativeBinomialDistribution, failures : Int) -> Double

    NegativeBinomialDistribution::quantile

    fn NegativeBinomialDistribution::quantile(self : NegativeBinomialDistribution, probability : Double) -> Int

    NegativeBinomialDistribution::variance

    NormalInverseGamma

    pub struct NormalInverseGamma {
    mean : Double
    scale : Double
    shape : Double
    rate : Double
    observations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Normal-Inverse-Gamma posterior for an unknown mean and unknown variance.

    NormalInverseGamma::credible_interval_95

    fn NormalInverseGamma::credible_interval_95(self : NormalInverseGamma) -> (Double, Double)

    NormalInverseGamma::information_criterion

    fn NormalInverseGamma::information_criterion(self : NormalInverseGamma, residual : Double) -> Double

    NormalInverseGamma::merge

    NormalInverseGamma::new

    fn NormalInverseGamma::new(mean : Double, scale : Double, shape : Double, rate : Double) -> NormalInverseGamma

    NormalInverseGamma::observations

    fn NormalInverseGamma::observations(self : NormalInverseGamma) -> Int

    NormalInverseGamma::posterior_mean

    fn NormalInverseGamma::posterior_mean(self : NormalInverseGamma) -> Double

    NormalInverseGamma::precision

    fn NormalInverseGamma::precision(self : NormalInverseGamma) -> Double

    NormalInverseGamma::predictive_summary

    fn NormalInverseGamma::predictive_summary(self : NormalInverseGamma) -> PredictiveSummary

    NormalInverseGamma::predictive_variance

    fn NormalInverseGamma::predictive_variance(self : NormalInverseGamma) -> Double

    NormalInverseGamma::standardized

    fn NormalInverseGamma::standardized(self : NormalInverseGamma, value : Double) -> Double

    NormalInverseGamma::update

    fn NormalInverseGamma::update(self : NormalInverseGamma, sample_mean : Double, sample_variance : Double, count : Int) -> NormalInverseGamma

    NormalInverseGamma::update_one

    fn NormalInverseGamma::update_one(self : NormalInverseGamma, value : Double) -> NormalInverseGamma

    NormalInverseGamma::variance_mean

    fn NormalInverseGamma::variance_mean(self : NormalInverseGamma) -> Double

    NormalInverseGamma::variance_mode

    fn NormalInverseGamma::variance_mode(self : NormalInverseGamma) -> Double

    NormalNormal

    pub(all) struct NormalNormal {
    prior_mean : Double
    prior_variance : Double
    data_variance : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Normal-Normal conjugate model for the mean of a normal distribution with known data variance.

    NormalNormal::credible_interval_95

    fn NormalNormal::credible_interval_95(self : NormalNormal) -> (Double, Double)

    Returns an exact 95% credible interval (lower, upper).

    NormalNormal::information_weight

    fn NormalNormal::information_weight(self : NormalNormal) -> Double

    NormalNormal::interval_probability_approx

    fn NormalNormal::interval_probability_approx(self : NormalNormal, lower : Double, upper : Double) -> Double

    NormalNormal::new

    fn NormalNormal::new(prior_mean : Double, prior_variance : Double, data_variance : Double) -> NormalNormal

    Creates a new NormalNormal model.

    NormalNormal::posterior_mean

    fn NormalNormal::posterior_mean(self : NormalNormal) -> Double

    The mean of the posterior distribution.

    NormalNormal::posterior_predictive_mean

    fn NormalNormal::posterior_predictive_mean(self : NormalNormal) -> Double

    Returns the posterior predictive mean for a single new observation.

    NormalNormal::posterior_predictive_summary

    fn NormalNormal::posterior_predictive_summary(self : NormalNormal) -> PredictiveSummary

    NormalNormal::posterior_predictive_variance

    fn NormalNormal::posterior_predictive_variance(self : NormalNormal) -> Double

    Returns the posterior predictive variance for a single new observation.

    NormalNormal::posterior_variance

    fn NormalNormal::posterior_variance(self : NormalNormal) -> Double

    The variance of the posterior distribution.

    NormalNormal::precision

    fn NormalNormal::precision(self : NormalNormal) -> Double

    NormalNormal::standardized

    fn NormalNormal::standardized(self : NormalNormal, value : Double) -> Double

    NormalNormal::summary

    NormalNormal::update

    fn NormalNormal::update(self : NormalNormal, sample_mean : Double, n : Int) -> NormalNormal

    Update the prior with data to compute the posterior. sample_mean is the mean of the observed data. n is the number of observations.

    NumericAggregate

    pub struct NumericAggregate {
    count : Int
    sum : Double
    minimum : Double
    maximum : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    NumericAggregate::mean

    fn NumericAggregate::mean(self : NumericAggregate) -> Double

    NumericAggregate::new

    NumericAggregate::push

    fn NumericAggregate::push(self : NumericAggregate, value : Double) -> NumericAggregate

    NumericAggregate::range

    fn NumericAggregate::range(self : NumericAggregate) -> Double

    NumericalResult

    pub struct NumericalResult {
    value : Double
    iterations : Int
    residual : Double
    converged : Bool
    status : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Deterministic numerical methods used by inference and monitoring code. These routines favor predictable allocations and explicit convergence reports so production callers can distinguish a result from a failure.

    Observation

    pub(all) enum Observation {
    Binary(successes~ : Int, trials~ : Int)
    Counts(sum~ : Int, observations~ : Int)
    Continuous(mean~ : Double, observations~ : Int)
    Categorical(index~ : Int)
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    An observation that can be replayed by a conjugate model ledger.

    OnlineRidge

    pub struct OnlineRidge {
    model : BayesianLinearRegression
    regularization : Double
    updates : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Online ridge regression facade with explicit regularization and diagnostics.

    OnlineRidge::coefficient_uncertainty

    fn OnlineRidge::coefficient_uncertainty(self : OnlineRidge) -> Array[Double]

    OnlineRidge::coefficients

    fn OnlineRidge::coefficients(self : OnlineRidge) -> Array[Double]

    OnlineRidge::feature_importance

    fn OnlineRidge::feature_importance(self : OnlineRidge) -> Array[Double]

    OnlineRidge::fit

    fn OnlineRidge::fit(self : OnlineRidge, features : Array[Array[Double]], targets : Array[Double]) -> OnlineRidge

    OnlineRidge::new

    fn OnlineRidge::new(feature_count : Int, regularization : Double, noise : Double) -> OnlineRidge

    OnlineRidge::predict

    fn OnlineRidge::predict(self : OnlineRidge, features : Array[Double]) -> Double

    OnlineRidge::predict_variance

    fn OnlineRidge::predict_variance(self : OnlineRidge, features : Array[Double]) -> Double

    OnlineRidge::r_squared

    fn OnlineRidge::r_squared(self : OnlineRidge, features : Array[Array[Double]], targets : Array[Double]) -> Double

    OnlineRidge::regularization

    fn OnlineRidge::regularization(self : OnlineRidge) -> Double

    OnlineRidge::residuals

    fn OnlineRidge::residuals(self : OnlineRidge, features : Array[Array[Double]], targets : Array[Double]) -> Array[Double]

    OnlineRidge::update

    fn OnlineRidge::update(self : OnlineRidge, features : Array[Double], target : Double) -> OnlineRidge

    OnlineRidge::updates

    fn OnlineRidge::updates(self : OnlineRidge) -> Int

    OnlineStats

    pub struct OnlineStats {
    count : Int
    mean : Double
    m2 : Double
    minimum : Double
    maximum : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    A numerically simple, allocation-conscious summary for streaming values.

    OnlineStats::count

    fn OnlineStats::count(self : OnlineStats) -> Int

    OnlineStats::max

    fn OnlineStats::max(self : OnlineStats) -> Double

    OnlineStats::mean

    fn OnlineStats::mean(self : OnlineStats) -> Double

    OnlineStats::merge

    fn OnlineStats::merge(self : OnlineStats, other : OnlineStats) -> OnlineStats

    Merges two summaries without replaying their observations.

    OnlineStats::min

    fn OnlineStats::min(self : OnlineStats) -> Double

    OnlineStats::new

    Creates an empty summary. The first observation initializes the extrema.

    OnlineStats::population_variance

    fn OnlineStats::population_variance(self : OnlineStats) -> Double

    OnlineStats::push

    fn OnlineStats::push(self : OnlineStats, value : Double) -> OnlineStats

    Adds one value using Welford's online update.

    OnlineStats::push_all

    fn OnlineStats::push_all(self : OnlineStats, values : Array[Double]) -> OnlineStats

    Adds all values in order.

    OnlineStats::standard_deviation

    fn OnlineStats::standard_deviation(self : OnlineStats) -> Double

    OnlineStats::sum

    fn OnlineStats::sum(self : OnlineStats) -> Double

    OnlineStats::variance

    fn OnlineStats::variance(self : OnlineStats) -> Double

    OperationalCovariateAdjustment

    pub struct OperationalCovariateAdjustment {
    raw_effect : Double
    adjusted_effect : Double
    coefficient : Double
    variance_reduction : Double
    usable_pairs : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    OperationalSequentialBoundary

    pub struct OperationalSequentialBoundary {
    looks : Int
    alpha : Double
    spending : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    OperationalSequentialBoundary::critical_value

    fn OperationalSequentialBoundary::critical_value(self : OperationalSequentialBoundary, look : Int) -> Double

    OperationalSequentialBoundary::new

    fn OperationalSequentialBoundary::new(looks : Int, alpha : Double) -> OperationalSequentialBoundary

    OptimizationConfig

    pub struct OptimizationConfig {
    learning_rate : Double
    max_iterations : Int
    tolerance : Double
    l2_penalty : Double
    patience : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Production-oriented optimization primitives for fitting small Bayesian and statistical models without pulling a heavyweight numerical runtime into a MoonBit application.

    OptimizationConfig::new

    OptimizationConfig::with_iterations

    fn OptimizationConfig::with_iterations(self : OptimizationConfig, value : Int) -> OptimizationConfig

    OptimizationConfig::with_l2

    fn OptimizationConfig::with_l2(self : OptimizationConfig, value : Double) -> OptimizationConfig

    OptimizationConfig::with_learning_rate

    fn OptimizationConfig::with_learning_rate(self : OptimizationConfig, value : Double) -> OptimizationConfig

    OptimizationConfig::with_patience

    fn OptimizationConfig::with_patience(self : OptimizationConfig, value : Int) -> OptimizationConfig

    OptimizationConfig::with_tolerance

    fn OptimizationConfig::with_tolerance(self : OptimizationConfig, value : Double) -> OptimizationConfig

    OptimizationPoint

    pub struct OptimizationPoint {
    iteration : Int
    loss : Double
    gradient_norm : Double
    step_size : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    OptimizationTrace

    pub struct OptimizationTrace {
    points : Array[OptimizationPoint]
    parameters : Array[Double]
    loss : Double
    iterations : Int
    converged : Bool
    stopped_by_patience : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    OptimizationTrace::best_loss

    fn OptimizationTrace::best_loss(self : OptimizationTrace) -> Double

    OptimizationTrace::history

    OptimizationTrace::is_successful

    fn OptimizationTrace::is_successful(self : OptimizationTrace) -> Bool

    OptimizationTrace::parameter_count

    fn OptimizationTrace::parameter_count(self : OptimizationTrace) -> Int

    PartialDependencePoint

    pub struct PartialDependencePoint {
    feature_value : Double
    average_prediction : Double
    lower : Double
    upper : Double
    samples : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PipelinePlan

    pub struct PipelinePlan {
    name : String
    version : String
    stages : Array[PipelineStage]
    schedule : Array[String]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PipelinePlan::add

    PipelinePlan::new

    fn PipelinePlan::new(name : String, version : String) -> PipelinePlan

    PipelinePlan::stage

    fn PipelinePlan::stage(self : PipelinePlan, name : String) -> PipelineStage

    PipelinePlan::topological_order

    fn PipelinePlan::topological_order(self : PipelinePlan) -> Array[String]

    PipelinePlan::validate

    fn PipelinePlan::validate(self : PipelinePlan) -> Array[String]

    PipelineRun

    pub struct PipelineRun {
    pipeline : String
    run_id : String
    status : PipelineStatus
    results : Array[StageResult]
    started_at : Int
    ended_at : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PipelineRun::duration

    fn PipelineRun::duration(self : PipelineRun) -> Int

    PipelineRun::failed

    fn PipelineRun::failed(self : PipelineRun) -> Bool

    PipelineRun::finish

    fn PipelineRun::finish(self : PipelineRun, ended_at : Int) -> PipelineRun

    PipelineRun::new

    fn PipelineRun::new(pipeline : String, run_id : String, started_at : Int) -> PipelineRun

    PipelineRun::record

    fn PipelineRun::record(self : PipelineRun, result : StageResult) -> PipelineRun

    PipelineRun::row_counts

    fn PipelineRun::row_counts(self : PipelineRun) -> Array[(String, Int, Int)]

    PipelineRun::total_input

    fn PipelineRun::total_input(self : PipelineRun) -> Int

    PipelineRun::total_output

    fn PipelineRun::total_output(self : PipelineRun) -> Int

    PipelineStage

    pub struct PipelineStage {
    name : String
    kind : StageKind
    dependencies : Array[String]
    retries : Int
    timeout_ms : Int
    enabled : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PipelineStage::depends_on

    fn PipelineStage::depends_on(self : PipelineStage, dependency : String) -> PipelineStage

    PipelineStage::disabled

    fn PipelineStage::disabled(self : PipelineStage) -> PipelineStage

    PipelineStage::new

    fn PipelineStage::new(name : String, kind : StageKind) -> PipelineStage

    PipelineStage::with_retries

    fn PipelineStage::with_retries(self : PipelineStage, retries : Int) -> PipelineStage

    PipelineStage::with_timeout

    fn PipelineStage::with_timeout(self : PipelineStage, timeout_ms : Int) -> PipelineStage

    PipelineStatus

    pub enum PipelineStatus {
    Pending
    Running
    Succeeded
    Failed
    Skipped
    Cancelled
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PlattCalibrator

    pub struct PlattCalibrator {
    slope : Double
    intercept : Double
    iterations : Int
    converged : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PlattCalibrator::apply

    fn PlattCalibrator::apply(self : PlattCalibrator, score : Double) -> Double

    PlattCalibrator::new

    PlattCalibrator::transform

    fn PlattCalibrator::transform(self : PlattCalibrator, scores : Array[Double]) -> Array[Double]

    PoissonDistribution

    pub struct PoissonDistribution {
    rate : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PoissonDistribution::cdf

    fn PoissonDistribution::cdf(self : PoissonDistribution, count : Int) -> Double

    PoissonDistribution::mean

    fn PoissonDistribution::mean(self : PoissonDistribution) -> Double

    PoissonDistribution::new

    fn PoissonDistribution::new(rate : Double) -> PoissonDistribution

    PoissonDistribution::pmf

    fn PoissonDistribution::pmf(self : PoissonDistribution, count : Int) -> Double

    PoissonDistribution::tail

    fn PoissonDistribution::tail(self : PoissonDistribution, count : Int) -> Double

    PoissonDistribution::variance

    fn PoissonDistribution::variance(self : PoissonDistribution) -> Double

    PolicyAction

    pub struct PolicyAction {
    arm : Int
    probability : Double
    expected_reward : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PortfolioRiskSummary

    pub struct PortfolioRiskSummary {
    count : Int
    mean_probability : Double
    expected_events : Double
    high_risk_count : Int
    total_exposure : Double
    expected_loss : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PosteriorPredictive

    pub struct PosteriorPredictive {
    probabilities : Array[Double]
    entropy : Double
    most_likely : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PowerEstimate

    pub struct PowerEstimate {
    effect : Double
    alpha : Double
    power : Double
    required_per_arm : Int
    achieved_power : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PowerPlan

    pub struct PowerPlan {
    baseline_rate : Double
    minimum_effect : Double
    alpha : Double
    power : Double
    required_per_arm : Int
    detectable_effect : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PredictionAuditEntry

    pub struct PredictionAuditEntry {
    request_id : String
    entity_id : String
    model_version : String
    value : Double
    interval_width : Double
    latency_ms : Int
    at : Int
    outcome : Double?
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PredictionAuditLog

    pub struct PredictionAuditLog {
    capacity : Int
    entries : Array[PredictionAuditEntry]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PredictionAuditLog::append

    PredictionAuditLog::attach_outcome

    fn PredictionAuditLog::attach_outcome(self : PredictionAuditLog, request_id : String, outcome : Double) -> PredictionAuditLog

    PredictionAuditLog::entry_count

    fn PredictionAuditLog::entry_count(self : PredictionAuditLog) -> Int

    PredictionAuditLog::new

    fn PredictionAuditLog::new(capacity : Int) -> PredictionAuditLog

    PredictionAuditLog::observed_error

    fn PredictionAuditLog::observed_error(self : PredictionAuditLog, absolute_threshold : Double) -> Double

    PredictionBounds

    pub struct PredictionBounds {
    minimum : Double
    maximum : Double
    reject_outside : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PredictionBounds::apply

    PredictionBounds::new

    fn PredictionBounds::new(minimum : Double, maximum : Double) -> PredictionBounds

    PredictionBounds::reject

    fn PredictionBounds::reject(self : PredictionBounds, value : Bool) -> PredictionBounds

    PredictionInterval

    pub struct PredictionInterval {
    prediction : Double
    lower : Double
    upper : Double
    confidence : Double
    interval_method : IntervalMethod
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PredictionInterval::contains

    fn PredictionInterval::contains(self : PredictionInterval, value : Double) -> Bool

    PredictionInterval::new

    fn PredictionInterval::new(prediction : Double, lower : Double, upper : Double, confidence : Double, interval_method : IntervalMethod) -> PredictionInterval

    PredictionInterval::relative_width

    fn PredictionInterval::relative_width(self : PredictionInterval) -> Double

    PredictionInterval::width

    fn PredictionInterval::width(self : PredictionInterval) -> Double

    PredictiveSummary

    pub struct PredictiveSummary {
    mean : Double
    variance : Double
    lower_95 : Double
    upper_95 : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    A compact immutable record of a model's posterior state and predictive checks.

    PredictiveSummary::credible_interval

    fn PredictiveSummary::credible_interval(self : PredictiveSummary) -> (Double, Double)

    PredictiveSummary::mean

    fn PredictiveSummary::mean(self : PredictiveSummary) -> Double

    PredictiveSummary::new

    fn PredictiveSummary::new(mean : Double, variance : Double, lower_95 : Double, upper_95 : Double) -> PredictiveSummary

    PredictiveSummary::standard_deviation

    fn PredictiveSummary::standard_deviation(self : PredictiveSummary) -> Double

    PredictiveSummary::variance

    fn PredictiveSummary::variance(self : PredictiveSummary) -> Double

    PrivacyBudget

    pub struct PrivacyBudget {
    epsilon : Double
    delta : Double
    consumed_epsilon : Double
    consumed_delta : Double
    releases : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PrivacyBudget::can_spend

    fn PrivacyBudget::can_spend(self : PrivacyBudget, epsilon : Double, delta : Double) -> Bool

    PrivacyBudget::new

    fn PrivacyBudget::new(epsilon : Double, delta : Double) -> PrivacyBudget

    PrivacyBudget::remaining_delta

    fn PrivacyBudget::remaining_delta(self : PrivacyBudget) -> Double

    PrivacyBudget::remaining_epsilon

    fn PrivacyBudget::remaining_epsilon(self : PrivacyBudget) -> Double

    PrivacyBudget::spend

    fn PrivacyBudget::spend(self : PrivacyBudget, epsilon : Double, delta : Double) -> PrivacyBudget

    PrivacyMechanism

    pub enum PrivacyMechanism {
    Laplace
    Gaussian
    RandomizedResponse
    Exponential
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Privacy accounting and controlled release utilities for statistical outputs.

    PrivacyReport

    pub struct PrivacyReport {
    releases : Int
    epsilon : Double
    delta : Double
    consumed_epsilon : Double
    consumed_delta : Double
    utilization : Double
    exhausted : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    PrivateRelease

    pub struct PrivateRelease {
    value : Double
    mechanism : PrivacyMechanism
    epsilon : Double
    delta : Double
    scale : Double
    clipped : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ProbabilityCalibrationBin

    pub struct ProbabilityCalibrationBin {
    lower : Double
    upper : Double
    count : Int
    positive : Int
    mean_probability : Double
    observed_rate : Double
    gap : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Probability calibration and threshold-selection tools for production classifiers. The APIs operate on plain arrays so they can be used both in offline evaluation and in a lightweight prediction service.

    ProbabilityCalibrationReport

    pub struct ProbabilityCalibrationReport {
    bins : Array[ProbabilityCalibrationBin]
    brier_score : Double
    expected_calibration_error : Double
    maximum_calibration_error : Double
    log_loss : Double
    observations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ProbabilityCalibrationReport::bin_count

    ProbabilityCalibrationReport::is_calibrated

    fn ProbabilityCalibrationReport::is_calibrated(self : ProbabilityCalibrationReport, tolerance : Double) -> Bool

    ProjectionBox

    pub struct ProjectionBox {
    lower : Array[Double]
    upper : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ProjectionBox::distance_to_boundary

    fn ProjectionBox::distance_to_boundary(self : ProjectionBox, values : Array[Double]) -> Double

    ProjectionBox::new

    fn ProjectionBox::new(lower : Array[Double], upper : Array[Double]) -> ProjectionBox

    ProjectionBox::project

    fn ProjectionBox::project(self : ProjectionBox, values : Array[Double]) -> Array[Double]

    QuadratureResult

    pub struct QuadratureResult {
    integral : Double
    evaluations : Int
    error_estimate : Double
    converged : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    QualityIssue

    pub struct QualityIssue {
    rule : String
    column : String
    severity : QualitySeverity
    row : Int
    value : String
    message : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    QualityIssue::is_blocking

    fn QualityIssue::is_blocking(self : QualityIssue) -> Bool

    QualityIssue::new

    fn QualityIssue::new(rule : String, column : String, severity : QualitySeverity, row : Int, value : String, message : String) -> QualityIssue

    QualityReport

    pub struct QualityReport {
    dataset : String
    rows : Int
    columns : Int
    checked_rules : Int
    passed_rules : Int
    issues : Array[QualityIssue]
    profiles : Array[ColumnProfile]
    score : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    QualityReport::error_count

    fn QualityReport::error_count(self : QualityReport) -> Int

    QualityReport::has_errors

    fn QualityReport::has_errors(self : QualityReport) -> Bool

    QualityReport::issue_count

    fn QualityReport::issue_count(self : QualityReport) -> Int

    QualityReport::issues

    QualityReport::new

    fn QualityReport::new(dataset : String, rows : Int) -> QualityReport

    QualityReport::pass_rate

    fn QualityReport::pass_rate(self : QualityReport) -> Double

    QualityReport::profiles

    QualityReport::quality_score

    fn QualityReport::quality_score(self : QualityReport) -> Double

    QualityReport::warning_count

    fn QualityReport::warning_count(self : QualityReport) -> Int

    QualityRuleKind

    pub enum QualityRuleKind {
    Required
    NumericRange
    StringLength
    AllowedValues
    Unique
    Monotonic
    Freshness
    Cardinality
    DistributionDrift
    NullRate
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    QualitySeverity

    pub enum QualitySeverity {
    Info
    Warning
    Error
    Critical
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Data quality primitives for validating model and analytics inputs.

    QuantileLoss

    pub struct QuantileLoss {
    quantile : Double
    mean_loss : Double
    observations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    QuantileSketch

    pub struct QuantileSketch {
    capacity : Int
    samples : Array[Double]
    seen : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    QuantileSketch::merge

    QuantileSketch::new

    fn QuantileSketch::new(capacity : Int) -> QuantileSketch

    QuantileSketch::push

    fn QuantileSketch::push(self : QuantileSketch, value : Double) -> QuantileSketch

    QuantileSketch::push_all

    fn QuantileSketch::push_all(self : QuantileSketch, values : Array[Double]) -> QuantileSketch

    QuantileSketch::quantile

    fn QuantileSketch::quantile(self : QuantileSketch, probability : Double) -> Double

    QuantileSketch::rank

    fn QuantileSketch::rank(self : QuantileSketch, value : Double) -> Double

    RankingReport

    pub struct RankingReport {
    cohorts : Array[String]
    ordering : Array[String]
    rank_gap : Int
    top_cohort : String
    bottom_cohort : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RateSummary

    pub struct RateSummary {
    successes : Int
    failures : Int
    exposure : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RateSummary::exposure_rate

    fn RateSummary::exposure_rate(self : RateSummary) -> Double

    RateSummary::merge

    fn RateSummary::merge(self : RateSummary, other : RateSummary) -> RateSummary

    RateSummary::new

    RateSummary::rate

    fn RateSummary::rate(self : RateSummary) -> Double

    RateSummary::record

    fn RateSummary::record(self : RateSummary, success : Bool, exposure : Double) -> RateSummary

    RedactionPolicy

    pub enum RedactionPolicy {
    Suppress
    Bucket
    Round
    Hash
    Keep
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Registry

    Registry::audit_for

    fn Registry::audit_for(self : Registry, name : String) -> Array[AuditEvent]

    Registry::deploy

    fn Registry::deploy(self : Registry, record : DeploymentRecord, actor : String, timestamp : Int) -> Registry

    Registry::find

    fn Registry::find(self : Registry, name : String, version : String) -> ModelVersion

    Registry::latest

    fn Registry::latest(self : Registry, name : String) -> ModelVersion

    Registry::new

    fn Registry::new() -> Registry

    Registry::production

    fn Registry::production(self : Registry, name : String) -> Array[ModelVersion]

    Registry::promote

    fn Registry::promote(self : Registry, name : String, version : String, target : ModelStage, gate : ValidationGate, score : Double, error_rate : Double, drift : Double, actor : String, timestamp : Int) -> (Registry, GateResult)

    Registry::register

    fn Registry::register(self : Registry, model : ModelVersion, actor : String, timestamp : Int) -> Registry

    Registry::rollback

    fn Registry::rollback(self : Registry, name : String, version : String, rollback_version : String, actor : String, timestamp : Int) -> Registry

    Registry::versions

    fn Registry::versions(self : Registry, name : String) -> Array[ModelVersion]

    RegressionReport

    pub struct RegressionReport {
    count : Int
    mae : Double
    rmse : Double
    mean_actual : Double
    mean_prediction : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RegressionReport::bias

    fn RegressionReport::bias(self : RegressionReport) -> Double

    RegressionReport::count

    fn RegressionReport::count(self : RegressionReport) -> Int

    RegressionReport::from_predictions

    fn RegressionReport::from_predictions(predicted : Array[Double], actual : Array[Double]) -> RegressionReport

    RegressionReport::mae

    fn RegressionReport::mae(self : RegressionReport) -> Double

    RegressionReport::rmse

    fn RegressionReport::rmse(self : RegressionReport) -> Double

    RegretLedger

    pub struct RegretLedger {
    points : Array[RegretPoint]
    cumulative : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RegretLedger::average_regret

    fn RegretLedger::average_regret(self : RegretLedger) -> Double

    RegretLedger::max_drawdown

    fn RegretLedger::max_drawdown(self : RegretLedger) -> Double

    RegretLedger::new

    RegretLedger::record

    fn RegretLedger::record(self : RegretLedger, chosen : Int, reward : Double, arm_means : Array[Double]) -> RegretLedger

    RegretPoint

    pub struct RegretPoint {
    time : Int
    chosen : Int
    reward : Double
    best_expected : Double
    instantaneous : Double
    cumulative : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ReliabilityReport

    pub struct ReliabilityReport {
    brier : Double
    log_loss : Double
    ece : Double
    mce : Double
    resolution : Double
    refinement : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RepairAction

    pub enum RepairAction {
    ImputeMean
    ImputeMedian
    ImputeConstant
    DropRow
    DropColumn
    ClipRange
    Deduplicate
    Reject
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RepairPlan

    pub struct RepairPlan {
    column : String
    action : RepairAction
    parameter : Double
    affected_rows : Int
    rationale : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RepairPlan::is_lossy

    fn RepairPlan::is_lossy(self : RepairPlan) -> Bool

    RiskBand

    pub struct RiskBand {
    name : String
    lower : Double
    upper : Double
    action : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Interpretable risk-scorecard primitives for turning posterior probabilities into operational bands, actions, and monitored portfolio summaries.

    RiskBand::contains

    fn RiskBand::contains(self : RiskBand, probability : Double) -> Bool

    RiskBand::new

    fn RiskBand::new(name : String, lower : Double, upper : Double, action : String) -> RiskBand

    RiskCalibrationRow

    pub struct RiskCalibrationRow {
    lower : Double
    upper : Double
    count : Int
    predicted : Double
    observed : Double
    calibration_gap : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RiskDecision

    pub struct RiskDecision {
    probability : Double
    band : String
    action : String
    expected_loss : Double
    accepted : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RiskFeatureContribution

    pub struct RiskFeatureContribution {
    name : String
    value : Double
    weight : Double
    contribution : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RiskFeatureContribution::new

    fn RiskFeatureContribution::new(name : String, value : Double, weight : Double) -> RiskFeatureContribution

    RiskScorecard

    pub struct RiskScorecard {
    intercept : Double
    features : Array[RiskFeatureContribution]
    bands : Array[RiskBand]
    minimum : Double
    maximum : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RiskScorecard::add_band

    fn RiskScorecard::add_band(self : RiskScorecard, band : RiskBand) -> RiskScorecard

    RiskScorecard::add_feature

    RiskScorecard::band

    fn RiskScorecard::band(self : RiskScorecard) -> RiskBand?

    RiskScorecard::explain

    RiskScorecard::logit

    fn RiskScorecard::logit(self : RiskScorecard) -> Double

    RiskScorecard::new

    fn RiskScorecard::new(intercept : Double) -> RiskScorecard

    RiskScorecard::probability

    fn RiskScorecard::probability(self : RiskScorecard) -> Double

    RiskScorecard::with_bounds

    fn RiskScorecard::with_bounds(self : RiskScorecard, minimum : Double, maximum : Double) -> RiskScorecard

    RobustCorrelation

    pub struct RobustCorrelation {
    correlation : Double
    covariance : Double
    left_scale : Double
    right_scale : Double
    valid_pairs : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RobustDrift

    pub struct RobustDrift {
    baseline : RobustLocation
    current : RobustLocation
    location_shift : Double
    scale_ratio : Double
    drifted : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RobustLocation

    pub struct RobustLocation {
    estimate : Double
    scale : Double
    observations : Int
    retained : Int
    estimator : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Robust estimators for telemetry and noisy scientific data. They provide bounded-influence alternatives to ordinary moments and return the diagnostics needed to decide whether an observation should be reviewed.

    RobustObservation

    pub struct RobustObservation {
    value : Double
    score : Double
    outlier : Bool
    lower_fence : Double
    upper_fence : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RobustScaler

    pub struct RobustScaler {
    center : Double
    scale : Double
    clip : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RobustScaler::fit

    fn RobustScaler::fit(values : Array[Double], clip : Double) -> RobustScaler

    RobustScaler::inverse

    fn RobustScaler::inverse(self : RobustScaler, value : Double) -> Double

    RobustScaler::transform

    fn RobustScaler::transform(self : RobustScaler, value : Double) -> Double

    RobustScaler::transform_all

    fn RobustScaler::transform_all(self : RobustScaler, values : Array[Double]) -> Array[Double]

    RobustWindow

    pub struct RobustWindow {
    capacity : Int
    values : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RobustWindow::location

    fn RobustWindow::location(self : RobustWindow) -> RobustLocation

    RobustWindow::new

    fn RobustWindow::new(capacity : Int) -> RobustWindow

    RobustWindow::outlier_rate

    fn RobustWindow::outlier_rate(self : RobustWindow, multiplier : Double) -> Double

    RobustWindow::push

    fn RobustWindow::push(self : RobustWindow, value : Double) -> RobustWindow

    RollingWindow

    pub struct RollingWindow {
    capacity : Int
    values : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Fixed-capacity rolling numeric window for dashboards and online validation.

    RollingWindow::capacity

    fn RollingWindow::capacity(self : RollingWindow) -> Int

    RollingWindow::clear

    RollingWindow::is_full

    fn RollingWindow::is_full(self : RollingWindow) -> Bool

    RollingWindow::len

    fn RollingWindow::len(self : RollingWindow) -> Int

    RollingWindow::map

    fn RollingWindow::map(self : RollingWindow, transform : (Double) -> Double) -> RollingWindow

    RollingWindow::max

    fn RollingWindow::max(self : RollingWindow) -> Double

    RollingWindow::mean

    fn RollingWindow::mean(self : RollingWindow) -> Double

    RollingWindow::min

    fn RollingWindow::min(self : RollingWindow) -> Double

    RollingWindow::new

    fn RollingWindow::new(capacity : Int) -> RollingWindow

    RollingWindow::push

    fn RollingWindow::push(self : RollingWindow, value : Double) -> RollingWindow

    RollingWindow::push_all

    fn RollingWindow::push_all(self : RollingWindow, values : Array[Double]) -> RollingWindow

    RollingWindow::quantile

    fn RollingWindow::quantile(self : RollingWindow, probability : Double) -> Double

    RollingWindow::stats

    RollingWindow::trend

    fn RollingWindow::trend(self : RollingWindow) -> Double

    RollingWindow::values

    fn RollingWindow::values(self : RollingWindow) -> Array[Double]

    RollingWindow::variance

    fn RollingWindow::variance(self : RollingWindow) -> Double

    RolloutCounter

    pub struct RolloutCounter {
    stable_requests : Int
    canary_requests : Int
    stable_errors : Int
    canary_errors : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RolloutCounter::canary_error_rate

    fn RolloutCounter::canary_error_rate(self : RolloutCounter) -> Double

    RolloutCounter::canary_is_healthy

    fn RolloutCounter::canary_is_healthy(self : RolloutCounter, maximum_error_rate : Double, minimum_requests : Int) -> Bool

    RolloutCounter::new

    RolloutCounter::record

    fn RolloutCounter::record(self : RolloutCounter, version : String, error : Bool, canary_version : String) -> RolloutCounter

    RolloutCounter::stable_error_rate

    fn RolloutCounter::stable_error_rate(self : RolloutCounter) -> Double

    RootBracket

    pub struct RootBracket {
    left : Double
    right : Double
    left_value : Double
    right_value : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    RootBracket::new

    fn RootBracket::new(left : Double, right : Double, function : (Double) -> Double) -> RootBracket

    RootBracket::width

    fn RootBracket::width(self : RootBracket) -> Double

    RowValidation

    pub struct RowValidation {
    valid : Bool
    missing_required : Array[String]
    unknown_fields : Array[String]
    type_errors : Array[String]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SampleRatioReport

    pub struct SampleRatioReport {
    expected_treatment : Double
    observed_treatment : Double
    z_score : Double
    p_value : Double
    suspicious : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SchemaChange

    pub struct SchemaChange {
    field : String
    breaking : Bool
    description : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SchemaCompatibility

    pub struct SchemaCompatibility {
    compatible : Bool
    changes : Array[SchemaChange]
    added : Int
    removed : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SchemaField

    pub struct SchemaField {
    name : String
    kind : SchemaType
    required : Bool
    nullable : Bool
    repeated : Bool
    description : String
    tags : Array[String]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SchemaField::array

    fn SchemaField::array(self : SchemaField) -> SchemaField

    SchemaField::new

    fn SchemaField::new(name : String, kind : SchemaType) -> SchemaField

    SchemaField::optional

    fn SchemaField::optional(self : SchemaField) -> SchemaField

    SchemaField::required

    fn SchemaField::required(self : SchemaField) -> SchemaField

    SchemaField::tag

    fn SchemaField::tag(self : SchemaField, value : String) -> SchemaField

    SchemaMigration

    pub struct SchemaMigration {
    from_version : String
    to_version : String
    action : MigrationAction
    field : String
    target : String
    reversible : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SchemaType

    pub enum SchemaType {
    Integer
    Number
    Boolean
    String
    Timestamp
    Array
    Object
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Schema contracts and compatibility checks for data interfaces.

    Seasonality

    pub enum Seasonality {
    None
    Additive(period~ : Int)
    Multiplicative(period~ : Int)
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Production-oriented time-series primitives for forecasting, monitoring, and feature extraction. All transformations return owned arrays or immutable records so callers can safely reuse the original stream.

    Sensitivity

    pub struct Sensitivity {
    lower : Double
    upper : Double
    adjacency : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Sensitivity::mean_sensitivity

    fn Sensitivity::mean_sensitivity(self : Sensitivity, count : Int) -> Double

    Sensitivity::new

    fn Sensitivity::new(lower : Double, upper : Double, adjacency : Double) -> Sensitivity

    Sensitivity::range

    fn Sensitivity::range(self : Sensitivity) -> Double

    SensitivityCurve

    pub struct SensitivityCurve {
    bias_factor : Double
    adjusted_effect : Double
    adjusted_lower : Double
    adjusted_upper : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SequentialBoundary

    pub struct SequentialBoundary {
    looks : Int
    alpha : Double
    spending : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SequentialBoundary::can_stop

    fn SequentialBoundary::can_stop(self : SequentialBoundary, estimate : EffectEstimate, look : Int) -> Bool

    SequentialBoundary::critical_z

    fn SequentialBoundary::critical_z(self : SequentialBoundary, look : Int) -> Double

    SequentialBoundary::new

    fn SequentialBoundary::new(looks : Int, alpha : Double) -> SequentialBoundary

    SequentialDecision

    pub struct SequentialDecision {
    look : Int
    z_score : Double
    p_value_proxy : Double
    boundary : Double
    stop_for_efficacy : Bool
    stop_for_futility : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ServiceHealth

    pub struct ServiceHealth {
    window_start : Int
    window_end : Int
    requests : Int
    successes : Int
    errors : Int
    latency_ms : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ServiceHealth::availability

    fn ServiceHealth::availability(self : ServiceHealth) -> Double

    ServiceHealth::error_rate

    fn ServiceHealth::error_rate(self : ServiceHealth) -> Double

    ServiceHealth::meets_slo

    fn ServiceHealth::meets_slo(self : ServiceHealth, minimum_availability : Double, maximum_p95_ms : Double) -> Bool

    ServiceHealth::new

    fn ServiceHealth::new(start : Int) -> ServiceHealth

    ServiceHealth::p95_latency

    fn ServiceHealth::p95_latency(self : ServiceHealth) -> Double

    ServiceHealth::record

    fn ServiceHealth::record(self : ServiceHealth, at : Int, latency_ms : Double, success : Bool) -> ServiceHealth

    ServingBatchReport

    pub struct ServingBatchReport {
    predictions : Array[ServingPrediction]
    failures : Array[ServingFailure]
    total : Int
    success_rate : Double
    mean_latency_ms : Double
    p95_latency_ms : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ServingFailure

    pub struct ServingFailure {
    request_id : String
    code : String
    message : String
    retryable : Bool
    at : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ServingFailure::new

    fn ServingFailure::new(request_id : String, code : String, message : String, retryable : Bool, at : Int) -> ServingFailure

    ServingPrediction

    pub struct ServingPrediction {
    request_id : String
    value : Double
    lower : Double
    upper : Double
    model_name : String
    model_version : String
    latency_ms : Int
    produced_at : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ServingPrediction::interval_width

    fn ServingPrediction::interval_width(self : ServingPrediction) -> Double

    ServingPrediction::new

    fn ServingPrediction::new(request_id : String, value : Double, model_name : String, model_version : String, latency_ms : Int, produced_at : Int) -> ServingPrediction

    ServingPrediction::with_interval

    fn ServingPrediction::with_interval(self : ServingPrediction, lower : Double, upper : Double) -> ServingPrediction

    ServingRequest

    pub struct ServingRequest {
    request_id : String
    entity_id : String
    features : Array[Double]
    received_at : Int
    schema_version : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Runtime-facing records and guards for serving probabilistic predictions. The package remains model-agnostic: inference is performed by the caller, while this layer handles validation, interval policy, rollout accounting, and auditable service health signals.

    ServingRequest::new

    fn ServingRequest::new(request_id : String, entity_id : String, features : Array[Double], received_at : Int) -> ServingRequest

    ServingRequest::with_schema

    fn ServingRequest::with_schema(self : ServingRequest, schema_version : String) -> ServingRequest

    ShortestPath

    pub struct ShortestPath {
    distance : Double
    nodes : Array[Int]
    reachable : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SloTarget

    pub struct SloTarget {
    name : String
    target : Double
    window : Int
    good : Int
    total : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SloTarget::attainment

    fn SloTarget::attainment(self : SloTarget) -> Double

    SloTarget::error_budget

    fn SloTarget::error_budget(self : SloTarget) -> Double

    SloTarget::good

    fn SloTarget::good(self : SloTarget) -> Int

    SloTarget::is_met

    fn SloTarget::is_met(self : SloTarget) -> Bool

    SloTarget::name

    fn SloTarget::name(self : SloTarget) -> String

    SloTarget::new

    fn SloTarget::new(name : String, target : Double, window : Int) -> SloTarget

    SloTarget::record

    fn SloTarget::record(self : SloTarget, good : Bool) -> SloTarget

    SloTarget::remaining_budget

    fn SloTarget::remaining_budget(self : SloTarget) -> Int

    SloTarget::target

    fn SloTarget::target(self : SloTarget) -> Double

    SloTarget::total

    fn SloTarget::total(self : SloTarget) -> Int

    SolveLinearResult

    pub struct SolveLinearResult {
    solution : Array[Double]
    residual_norm : Double
    condition_warning : Bool
    solved : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SplitResult

    pub struct SplitResult {
    train_indices : Array[Int]
    test_indices : Array[Int]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Result of a deterministic train/test split.

    SplitResult::test_indices

    fn SplitResult::test_indices(self : SplitResult) -> Array[Int]

    SplitResult::test_size

    fn SplitResult::test_size(self : SplitResult) -> Int

    SplitResult::train_indices

    fn SplitResult::train_indices(self : SplitResult) -> Array[Int]

    SplitResult::train_size

    fn SplitResult::train_size(self : SplitResult) -> Int

    StackingReport

    pub struct StackingReport {
    member_count : Int
    training_loss : Double
    weighted_loss : Double
    diversity : Double
    selected : Array[String]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    StageKind

    pub enum StageKind {
    Source
    Map
    Filter
    Join
    Aggregate
    Window
    Sink
    Validate
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Deterministic batch pipeline planning and execution records.

    StageResult

    pub struct StageResult {
    name : String
    status : PipelineStatus
    input_rows : Int
    output_rows : Int
    duration_ms : Int
    attempts : Int
    error : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    StageResult::failure

    fn StageResult::failure(name : String, input_rows : Int, duration_ms : Int, attempts : Int, error : String) -> StageResult

    StageResult::selectivity

    fn StageResult::selectivity(self : StageResult) -> Double

    StageResult::success

    fn StageResult::success(name : String, input_rows : Int, output_rows : Int, duration_ms : Int, attempts : Int) -> StageResult

    StateEstimate

    pub struct StateEstimate {
    mean : Array[Double]
    covariance : Array[Array[Double]]
    timestamp : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    State-space filtering for noisy sensors, demand signals, and online control.

    StateEstimate::dimension

    fn StateEstimate::dimension(self : StateEstimate) -> Int

    StateEstimate::predict

    fn StateEstimate::predict(self : StateEstimate, model : KalmanModel) -> StateEstimate

    StateEstimate::standard_deviation

    fn StateEstimate::standard_deviation(self : StateEstimate, index : Int) -> Double

    StateEstimate::update

    fn StateEstimate::update(self : StateEstimate, model : KalmanModel, observation_value : Double) -> KalmanUpdate

    StateEstimate::variance

    fn StateEstimate::variance(self : StateEstimate, index : Int) -> Double

    StateEstimate::with_timestamp

    fn StateEstimate::with_timestamp(self : StateEstimate, timestamp : Int) -> StateEstimate

    StratumEffect

    pub struct StratumEffect {
    stratum : String
    effect : CausalEffect
    weight : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SurvivalObservation

    pub struct SurvivalObservation {
    duration : Double
    status : EventStatus
    weight : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SurvivalObservation::duration

    fn SurvivalObservation::duration(self : SurvivalObservation) -> Double

    SurvivalObservation::new

    fn SurvivalObservation::new(duration : Double, status : EventStatus) -> SurvivalObservation

    SurvivalObservation::status

    SurvivalObservation::weight

    fn SurvivalObservation::weight(self : SurvivalObservation) -> Double

    SurvivalObservation::weighted

    fn SurvivalObservation::weighted(duration : Double, status : EventStatus, weight : Double) -> SurvivalObservation

    SurvivalStep

    pub struct SurvivalStep {
    time : Double
    at_risk : Double
    events : Double
    censored : Double
    survival : Double
    hazard : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    SurvivalStep::at_risk

    fn SurvivalStep::at_risk(self : SurvivalStep) -> Double

    SurvivalStep::censored

    fn SurvivalStep::censored(self : SurvivalStep) -> Double

    SurvivalStep::events

    fn SurvivalStep::events(self : SurvivalStep) -> Double

    SurvivalStep::hazard

    fn SurvivalStep::hazard(self : SurvivalStep) -> Double

    SurvivalStep::survival

    fn SurvivalStep::survival(self : SurvivalStep) -> Double

    SurvivalStep::time

    fn SurvivalStep::time(self : SurvivalStep) -> Double

    ThresholdConfusionMatrix

    pub struct ThresholdConfusionMatrix {
    true_positive : Int
    false_positive : Int
    true_negative : Int
    false_negative : Int
    threshold : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ThresholdConfusionMatrix::accuracy

    fn ThresholdConfusionMatrix::accuracy(self : ThresholdConfusionMatrix) -> Double

    ThresholdConfusionMatrix::f1

    ThresholdConfusionMatrix::precision

    fn ThresholdConfusionMatrix::precision(self : ThresholdConfusionMatrix) -> Double

    ThresholdConfusionMatrix::recall

    ThresholdConfusionMatrix::specificity

    fn ThresholdConfusionMatrix::specificity(self : ThresholdConfusionMatrix) -> Double

    ThresholdCost

    pub struct ThresholdCost {
    false_positive : Double
    false_negative : Double
    true_positive : Double
    true_negative : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ThresholdCost::new

    fn ThresholdCost::new(false_positive : Double, false_negative : Double, true_positive : Double, true_negative : Double) -> ThresholdCost

    ThresholdPoint

    pub struct ThresholdPoint {
    threshold : Double
    metrics : ThresholdConfusionMatrix
    predicted_positive_rate : Double
    utility : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ThresholdReport

    pub struct ThresholdReport {
    threshold : Double
    expected_cost : Double
    accuracy : Double
    precision : Double
    recall : Double
    f1 : Double
    selected_rate : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TimeSeries

    pub struct TimeSeries {
    timestamps : Array[Int]
    values : Array[Double]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TimeSeries::append

    fn TimeSeries::append(self : TimeSeries, timestamp : Int, value : Double) -> TimeSeries

    TimeSeries::at

    fn TimeSeries::at(self : TimeSeries, index : Int) -> Double

    TimeSeries::difference

    fn TimeSeries::difference(self : TimeSeries, lag : Int) -> TimeSeries

    TimeSeries::filter

    fn TimeSeries::filter(self : TimeSeries, predicate : (Int, Double) -> Bool) -> TimeSeries

    TimeSeries::from_values

    fn TimeSeries::from_values(values : Array[Double]) -> TimeSeries

    TimeSeries::is_empty

    fn TimeSeries::is_empty(self : TimeSeries) -> Bool

    TimeSeries::lag

    fn TimeSeries::lag(self : TimeSeries, offset : Int) -> TimeSeries

    TimeSeries::len

    fn TimeSeries::len(self : TimeSeries) -> Int

    TimeSeries::map

    fn TimeSeries::map(self : TimeSeries, transform : (Double) -> Double) -> TimeSeries

    TimeSeries::map_indexed

    fn TimeSeries::map_indexed(self : TimeSeries, transform : (Int, Double) -> Double) -> TimeSeries

    TimeSeries::new

    fn TimeSeries::new(timestamps : Array[Int], values : Array[Double]) -> TimeSeries

    TimeSeries::normalize

    fn TimeSeries::normalize(self : TimeSeries) -> TimeSeries

    TimeSeries::percentage_change

    fn TimeSeries::percentage_change(self : TimeSeries, lag : Int) -> TimeSeries

    TimeSeries::resample_mean

    fn TimeSeries::resample_mean(self : TimeSeries, bucket : Int) -> TimeSeries

    TimeSeries::resample_sum

    fn TimeSeries::resample_sum(self : TimeSeries, bucket : Int) -> TimeSeries

    TimeSeries::rolling

    fn TimeSeries::rolling(self : TimeSeries, window : Int, statistic : (Array[Double]) -> Double) -> TimeSeries

    TimeSeries::rolling_max

    fn TimeSeries::rolling_max(self : TimeSeries, window : Int) -> TimeSeries

    TimeSeries::rolling_mean

    fn TimeSeries::rolling_mean(self : TimeSeries, window : Int) -> TimeSeries

    TimeSeries::rolling_min

    fn TimeSeries::rolling_min(self : TimeSeries, window : Int) -> TimeSeries

    TimeSeries::rolling_variance

    fn TimeSeries::rolling_variance(self : TimeSeries, window : Int) -> TimeSeries

    TimeSeries::seasonal_average

    fn TimeSeries::seasonal_average(self : TimeSeries, period : Int) -> Array[Double]

    TimeSeries::slice

    fn TimeSeries::slice(self : TimeSeries, start : Int, finish : Int) -> TimeSeries

    TimeSeries::standardize

    fn TimeSeries::standardize(self : TimeSeries) -> TimeSeries

    TimeSeries::timestamp_at

    fn TimeSeries::timestamp_at(self : TimeSeries, index : Int) -> Int

    TimeSeries::timestamps

    fn TimeSeries::timestamps(self : TimeSeries) -> Array[Int]

    TimeSeries::trend

    fn TimeSeries::trend(self : TimeSeries) -> Double

    TimeSeries::values

    fn TimeSeries::values(self : TimeSeries) -> Array[Double]

    TokenBudget

    pub struct TokenBudget {
    capacity : Double
    refill_per_second : Double
    tokens : Double
    last_at : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TokenBudget::new

    fn TokenBudget::new(capacity : Double, refill_per_second : Double, at : Int) -> TokenBudget

    TokenBudget::remaining

    fn TokenBudget::remaining(self : TokenBudget, at : Int) -> Double

    TokenBudget::try_acquire

    fn TokenBudget::try_acquire(self : TokenBudget, amount : Double, at : Int) -> (TokenBudget, Bool)

    TransformAudit

    pub struct TransformAudit {
    rows : Int
    missing_before : Int
    missing_after : Int
    clipped : Int
    mean_before : Double
    mean_after : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TransformKind

    pub enum TransformKind {
    Identity
    Standardize
    MinMax
    Robust
    Log1p
    Clip
    Quantile
    Rank
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    Production-safe numeric transforms and reversible preprocessing metadata.

    TransformParameters

    pub struct TransformParameters {
    kind : TransformKind
    center : Double
    scale : Double
    lower : Double
    upper : Double
    fitted_count : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TransformParameters::apply

    fn TransformParameters::apply(self : TransformParameters, value : Double) -> Double

    TransformParameters::fit_clip

    fn TransformParameters::fit_clip(values : Array[Double], lower : Double, upper : Double) -> TransformParameters

    TransformParameters::fit_minmax

    fn TransformParameters::fit_minmax(values : Array[Double], lower : Double, upper : Double) -> TransformParameters

    TransformParameters::fit_robust

    fn TransformParameters::fit_robust(values : Array[Double]) -> TransformParameters

    TransformParameters::fit_standard

    fn TransformParameters::fit_standard(values : Array[Double]) -> TransformParameters

    TransformParameters::identity

    TransformParameters::inverse

    fn TransformParameters::inverse(self : TransformParameters, value : Double) -> Double

    TransformPipeline

    pub struct TransformPipeline {
    parameters : Array[TransformParameters]
    names : Array[String]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TransformPipeline::add

    fn TransformPipeline::add(self : TransformPipeline, name : String, parameters : TransformParameters) -> TransformPipeline

    TransformPipeline::apply

    fn TransformPipeline::apply(self : TransformPipeline, values : Array[Double]) -> Array[Double]

    TransformPipeline::inverse

    fn TransformPipeline::inverse(self : TransformPipeline, values : Array[Double]) -> Array[Double]

    TransformPipeline::new

    TransitionEstimate

    pub struct TransitionEstimate {
    counts : Array[Array[Int]]
    probabilities : Array[Array[Double]]
    smoothing : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TreatmentPolicyValue

    pub struct TreatmentPolicyValue {
    treated_value : Double
    control_value : Double
    policy_value : Double
    treatment_rate : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TrendEstimate

    pub struct TrendEstimate {
    slope : Double
    intercept : Double
    r_squared : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TrendEstimate::intercept

    fn TrendEstimate::intercept(self : TrendEstimate) -> Double

    TrendEstimate::new

    fn TrendEstimate::new(slope : Double, intercept : Double, r_squared : Double) -> TrendEstimate

    TrendEstimate::predict

    fn TrendEstimate::predict(self : TrendEstimate, x : Double) -> Double

    TrendEstimate::r_squared

    fn TrendEstimate::r_squared(self : TrendEstimate) -> Double

    TrendEstimate::slope

    fn TrendEstimate::slope(self : TrendEstimate) -> Double

    TrendForecast

    pub struct TrendForecast {
    level : Double
    trend : Double
    level_variance : Double
    trend_variance : Double
    observations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    TrendForecast::forecast

    fn TrendForecast::forecast(self : TrendForecast, horizon : Int) -> Array[Double]

    TrendForecast::forecast_intervals

    fn TrendForecast::forecast_intervals(self : TrendForecast, horizon : Int, confidence : Double) -> Array[PredictionInterval]

    UncertaintyBootstrapSummary

    pub struct UncertaintyBootstrapSummary {
    estimate : Double
    standard_error : Double
    lower : Double
    upper : Double
    samples : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    UncertaintyCalibrationBin

    pub struct UncertaintyCalibrationBin {
    lower : Double
    upper : Double
    count : Int
    predicted_mean : Double
    observed_rate : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    UniformDistribution

    pub struct UniformDistribution {
    lower : Double
    upper : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    UniformDistribution::cdf

    fn UniformDistribution::cdf(self : UniformDistribution, value : Double) -> Double

    UniformDistribution::clamp

    fn UniformDistribution::clamp(self : UniformDistribution, value : Double) -> Double

    UniformDistribution::mean

    fn UniformDistribution::mean(self : UniformDistribution) -> Double

    UniformDistribution::new

    fn UniformDistribution::new(lower : Double, upper : Double) -> UniformDistribution

    UniformDistribution::pdf

    fn UniformDistribution::pdf(self : UniformDistribution, value : Double) -> Double

    UniformDistribution::variance

    fn UniformDistribution::variance(self : UniformDistribution) -> Double

    UpdateLedger

    pub struct UpdateLedger {
    observations : Array[Observation]
    binary : BetaBinomial
    counts : GammaPoisson
    continuous : NormalNormal
    categorical : DirichletMultinomial
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    A deterministic audit trail for online updates. It keeps immutable snapshots so callers can compare revisions or replay a production data window.

    UpdateLedger::binary

    fn UpdateLedger::binary(self : UpdateLedger) -> BetaBinomial

    UpdateLedger::categorical

    UpdateLedger::continuous

    fn UpdateLedger::continuous(self : UpdateLedger) -> NormalNormal

    UpdateLedger::counts

    fn UpdateLedger::counts(self : UpdateLedger) -> GammaPoisson

    UpdateLedger::len

    fn UpdateLedger::len(self : UpdateLedger) -> Int

    UpdateLedger::new

    fn UpdateLedger::new(binary : BetaBinomial, counts : GammaPoisson, continuous : NormalNormal, categorical : DirichletMultinomial) -> UpdateLedger

    UpdateLedger::observations

    fn UpdateLedger::observations(self : UpdateLedger) -> Array[Observation]

    UpdateLedger::push

    fn UpdateLedger::push(self : UpdateLedger, observation : Observation) -> UpdateLedger

    UpdateLedger::push_all

    fn UpdateLedger::push_all(self : UpdateLedger, observations : Array[Observation]) -> UpdateLedger

    UpliftSegment

    pub struct UpliftSegment {
    label : String
    count : Int
    treatment_mean : Double
    control_mean : Double
    uplift : Double
    standard_error : Double
    priority : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    UtilityCurvePoint

    pub struct UtilityCurvePoint {
    threshold : Double
    net_benefit : Double
    treated : Int
    true_positives : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ValidationGate

    pub struct ValidationGate {
    name : String
    required_metrics : Array[String]
    minimum_score : Double
    maximum_error_rate : Double
    maximum_drift : Double
    require_revision : Bool
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    ValidationGate::accepts

    fn ValidationGate::accepts(self : ValidationGate, model : ModelVersion, score : Double, error_rate : Double, drift : Double) -> Bool

    ValidationGate::production

    fn ValidationGate::production() -> ValidationGate

    WeibullSurvival

    pub struct WeibullSurvival {
    shape : Double
    scale : Double
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    WeibullSurvival::cdf

    fn WeibullSurvival::cdf(self : WeibullSurvival, time : Double) -> Double

    WeibullSurvival::hazard

    fn WeibullSurvival::hazard(self : WeibullSurvival, time : Double) -> Double

    WeibullSurvival::new

    fn WeibullSurvival::new(shape : Double, scale : Double) -> WeibullSurvival

    WeibullSurvival::quantile

    fn WeibullSurvival::quantile(self : WeibullSurvival, probability : Double) -> Double

    WeibullSurvival::scale

    fn WeibullSurvival::scale(self : WeibullSurvival) -> Double

    WeibullSurvival::shape

    fn WeibullSurvival::shape(self : WeibullSurvival) -> Double

    WeibullSurvival::survival

    fn WeibullSurvival::survival(self : WeibullSurvival, time : Double) -> Double

    WeightFit

    pub struct WeightFit {
    weights : Array[Double]
    intercept : Double
    training_loss : Double
    iterations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    WeightedGraph

    pub struct WeightedGraph {
    nodes : Int
    directed : Bool
    edges : Array[GraphEdge]
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    WeightedGraph::add_edge

    fn WeightedGraph::add_edge(self : WeightedGraph, edge : GraphEdge) -> WeightedGraph

    WeightedGraph::adjacency_matrix

    fn WeightedGraph::adjacency_matrix(self : WeightedGraph) -> Array[Array[Double]]

    WeightedGraph::degree

    fn WeightedGraph::degree(self : WeightedGraph, node : Int) -> Int

    WeightedGraph::edge_count

    fn WeightedGraph::edge_count(self : WeightedGraph) -> Int

    WeightedGraph::has_edge

    fn WeightedGraph::has_edge(self : WeightedGraph, from : Int, to : Int) -> Bool

    WeightedGraph::incoming

    fn WeightedGraph::incoming(self : WeightedGraph, node : Int) -> Array[(Int, Double)]

    WeightedGraph::neighbors

    fn WeightedGraph::neighbors(self : WeightedGraph, node : Int) -> Array[(Int, Double)]

    WeightedGraph::new

    fn WeightedGraph::new(nodes : Int, directed : Bool) -> WeightedGraph

    WeightedGraph::outgoing_weight

    fn WeightedGraph::outgoing_weight(self : WeightedGraph, node : Int) -> Double

    WeightedGraph::total_weight

    fn WeightedGraph::total_weight(self : WeightedGraph) -> Double

    WeightedSummary

    pub struct WeightedSummary {
    weight : Double
    weighted_mean : Double
    weighted_m2 : Double
    observations : Int
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    WeightedSummary::merge

    WeightedSummary::new

    WeightedSummary::push

    fn WeightedSummary::push(self : WeightedSummary, value : Double, weight : Double) -> WeightedSummary

    WeightedSummary::variance

    fn WeightedSummary::variance(self : WeightedSummary) -> Double

    WindowSpec

    pub struct WindowSpec {
    size : Int
    slide : Int
    offset : Int
    timestamp_column : String
    } derive(Eq, ToJson,
    Debug
    ,
    FromJson
    )

    WindowSpec::sliding

    fn WindowSpec::sliding(size : Int, slide : Int) -> WindowSpec

    WindowSpec::tumbling

    fn WindowSpec::tumbling(size : Int) -> WindowSpec

    WindowSpec::window_id

    fn WindowSpec::window_id(self : WindowSpec, timestamp : Int) -> Int

    WindowSpec::with_offset

    fn WindowSpec::with_offset(self : WindowSpec, offset : Int) -> WindowSpec

    achieved_power

    fn achieved_power(baseline : Double, treatment : Double, per_arm : Int, alpha : Double) -> PowerEstimate

    adam_optimize

    fn adam_optimize(objective : (Array[Double]) -> Double, gradient : (Array[Double]) -> Array[Double], initial : Array[Double], config : AdamConfig) -> OptimizationTrace

    add_trend

    fn add_trend(values : Array[Double], trend : TrendEstimate) -> Array[Double]

    adjust_analysis_covariate

    fn adjust_analysis_covariate(control : AnalysisArm, treatment : AnalysisArm) -> OperationalCovariateAdjustment

    Applies a CUPED-style linear adjustment using a shared pre-period metric.

    adjust_p_values

    fn adjust_p_values(p_values : Array[Double], strategy : MultipleTestingMethod) -> Array[Double]

    aggregate_stratified_effect

    fn aggregate_stratified_effect(effects : Array[StratumEffect]) -> CausalEffect

    aggregate_streams

    fn aggregate_streams(streams : Array[MetricStream]) -> MetricStream

    aic

    fn aic(residual_sum : Double, observations : Int, parameters : Int) -> Double

    all_cohort_metrics

    fn all_cohort_metrics(observations : Array[CohortObservation], threshold : Double) -> Array[CohortMetric]

    allocate_epsilon_greedy

    fn allocate_epsilon_greedy(arms : Array[ExperimentArm], total : Int, epsilon : Double) -> Array[Int]

    allocate_fixed_ratio

    fn allocate_fixed_ratio(total : Int, treatment_fraction : Double) -> (Int, Int)

    append_profile

    fn append_profile(report : QualityReport, profile : ColumnProfile) -> QualityReport

    apply_isotonic_calibrator

    fn apply_isotonic_calibrator(calibrator : Array[IsotonicPoint], scores : Array[Double]) -> Array[Double]

    apply_numeric_default

    fn apply_numeric_default(values : Array[Double], default_value : Double) -> Array[Double]

    assess_freshness

    fn assess_freshness(updated_at : Int, now : Int, maximum_age : Int) -> LineageFreshnessWindow

    autocorrelation

    fn autocorrelation(values : Array[Double], lag : Int) -> Double

    autocorrelation_series

    fn autocorrelation_series(values : Array[Double], maximum_lag : Int) -> Array[Double]

    autocovariance

    fn autocovariance(values : Array[Double], lag : Int) -> Double

    backtracking_step

    fn backtracking_step(objective : (Array[Double]) -> Double, parameters : Array[Double], gradient : Array[Double], initial_step : Double, shrink : Double, sufficient_decrease : Double) -> Double

    Armijo backtracking keeps a proposed gradient step inside a useful local neighborhood. It is also useful to callers that implement their own loop.

    balance_table

    fn balance_table(treated : Array[Array[Double]], control : Array[Array[Double]], threshold : Double) -> Array[BalanceReport]

    balanced_accuracy

    fn balanced_accuracy(matrix : DecisionConfusionMatrix) -> Double

    bayesian_experiment_decision

    fn bayesian_experiment_decision(control_mean : Double, control_error : Double, treatment_mean : Double, treatment_error : Double, required_probability : Double) -> BayesianExperimentDecision

    Uses a normal posterior approximation for a quick release decision. The caller supplies prior means and standard errors so the decision remains transparent and reproducible.

    bernoulli_summary

    fn bernoulli_summary(probability : Double) -> DistributionSummary

    best_threshold

    fn best_threshold(scores : Array[Double], outcomes : Array[Bool], cost : ThresholdCost, steps : Int) -> ThresholdPoint

    bic

    fn bic(residual_sum : Double, observations : Int, parameters : Int) -> Double

    binary_log_loss

    fn binary_log_loss(probabilities : Array[Double], outcomes : Array[Bool]) -> Double

    bootstrap_distribution

    fn bootstrap_distribution(rng : DeterministicRng, values : Array[Double], replicates : Int) -> (DeterministicRng, Array[Double])

    bootstrap_indices

    fn bootstrap_indices(rng : DeterministicRng, size : Int, samples : Int) -> (DeterministicRng, Array[Int])

    bootstrap_mean

    fn bootstrap_mean(rng : DeterministicRng, values : Array[Double], replicates : Int) -> (DeterministicRng, BootstrapSummary)

    bootstrap_summary

    fn bootstrap_summary(estimates : Array[Double], confidence : Double) -> UncertaintyBootstrapSummary

    break_even_probability

    fn break_even_probability(benefit : Double, cost : Double) -> Double

    brier_score

    fn brier_score(probabilities : Array[Double], observed : Array[Bool]) -> Double

    brier_survival_score

    fn brier_survival_score(actual : Array[Double], status : Array[Bool], predicted : Array[Double], horizon : Double) -> Double

    build_batch_report

    fn build_batch_report(predictions : Array[ServingPrediction], failures : Array[ServingFailure], total : Int) -> ServingBatchReport

    build_cohort_report

    fn build_cohort_report(observations : Array[CohortObservation], reference : String, threshold : Double, maximum_score_gap : Double, maximum_recall_gap : Double) -> CohortReport

    calibrate_scale

    fn calibrate_scale(predicted : Array[Double], actual : Array[Double], target : Double) -> Double

    calibration_bins

    fn calibration_bins(probabilities : Array[Double], outcomes : Array[Bool], bins : Int) -> Array[UncertaintyCalibrationBin]

    calibration_brier_score

    fn calibration_brier_score(probabilities : Array[Double], outcomes : Array[Bool]) -> Double

    calibration_error

    fn calibration_error(probabilities : Array[Double], observed : Array[Bool], bins : Int) -> Double

    calibration_report

    fn calibration_report(probabilities : Array[Double], outcomes : Array[Bool], bucket_count : Int) -> ProbabilityCalibrationReport

    categorical_summary

    fn categorical_summary(probabilities : Array[Double]) -> Array[DistributionSummary]

    central_derivative

    fn central_derivative(function : (Double) -> Double, value : Double, step : Double) -> Double

    chain_autocorrelation

    fn chain_autocorrelation(samples : Array[Double], lag : Int) -> Double

    chain_diagnostics

    fn chain_diagnostics(chains : Array[Array[Double]], maximum_lag : Int) -> ChainDiagnostics

    check_allowed_values

    fn check_allowed_values(report : QualityReport, column : String, values : Array[String], allowed : Array[String]) -> QualityReport

    check_analysis_allocation

    fn check_analysis_allocation(control_count : Int, treatment_count : Int, expected_control : Double, tolerance : Double) -> AllocationCheck

    check_cardinality

    fn check_cardinality(report : QualityReport, column : String, values : Array[String], minimum : Int, maximum : Int) -> QualityReport

    check_distribution_drift

    fn check_distribution_drift(report : QualityReport, column : String, baseline : Array[Double], current : Array[Double], threshold : Double) -> QualityReport

    check_finite

    fn check_finite(report : QualityReport, column : String, values : Array[Double]) -> QualityReport

    check_freshness

    fn check_freshness(report : QualityReport, column : String, timestamps : Array[Int], now : Int, maximum_age : Int) -> QualityReport

    check_monotonic

    fn check_monotonic(report : QualityReport, column : String, values : Array[Double], increasing : Bool) -> QualityReport

    check_null_rate

    fn check_null_rate(report : QualityReport, column : String, values : Array[String], maximum_rate : Double) -> QualityReport

    check_numeric_range

    fn check_numeric_range(report : QualityReport, column : String, values : Array[Double], minimum : Double, maximum : Double, severity : QualitySeverity) -> QualityReport

    check_required

    fn check_required(report : QualityReport, column : String, values : Array[String], severity : QualitySeverity) -> QualityReport

    check_string_length

    fn check_string_length(report : QualityReport, column : String, values : Array[String], minimum : Int, maximum : Int) -> QualityReport

    check_unique

    fn check_unique(report : QualityReport, column : String, values : Array[String]) -> QualityReport

    cholesky

    fn cholesky(matrix : DenseMatrix) -> DenseMatrix

    Cholesky factorization for positive definite matrices.

    choose_action

    fn choose_action(score : Double, rules : Array[ActionRule], fallback : Action) -> Action

    chronological_split

    fn chronological_split(size : Int, test_fraction : Double) -> SplitResult

    Splits indices in their original order. This is preferable for time series data where random shuffling would leak future observations.

    clamp

    fn clamp(value : Double, lower : Double, upper : Double) -> Double

    Returns a copy with the supplied value clamped to an interval.

    clip_value

    fn clip_value(value : Double, lower : Double, upper : Double) -> Double

    clip_values

    fn clip_values(values : Array[Double], lower : Double, upper : Double) -> Array[Double]

    cohort_gaps

    fn cohort_gaps(observations : Array[CohortObservation], reference : String, threshold : Double, maximum_score_gap : Double, maximum_recall_gap : Double) -> Array[CohortGap]

    cohort_metric

    fn cohort_metric(observations : Array[CohortObservation], cohort : String, threshold : Double) -> CohortMetric

    combine_beta_negative_binomial

    fn combine_beta_negative_binomial(left : BetaNegativeBinomial, right : BetaNegativeBinomial) -> BetaNegativeBinomial

    combine_predictions

    fn combine_predictions(members : Array[EnsembleMember], mode : EnsembleMode) -> EnsemblePrediction

    compare_analysis_arms

    fn compare_analysis_arms(control : AnalysisArm, treatment : AnalysisArm) -> AnalysisContrast

    compare_arms

    fn compare_arms(control : ExperimentArm, treatment : ExperimentArm) -> EffectEstimate

    compare_binary_models

    fn compare_binary_models(predictions : Array[Array[Double]], observed : Array[Bool]) -> Array[ModelScore]

    compare_cohort_distributions

    fn compare_cohort_distributions(baseline : Array[CohortObservation], current : Array[CohortObservation], minimum_count_ratio : Double, maximum_score_shift : Double) -> Array[CohortDrift]

    compare_feature_signatures

    fn compare_feature_signatures(old : ModelVersion, newer : ModelVersion) -> CompatibilityReport

    compare_robust_windows

    fn compare_robust_windows(baseline : Array[Double], current : Array[Double], shift_tolerance : Double, scale_ratio_tolerance : Double) -> RobustDrift

    compare_schemas

    fn compare_schemas(old : DataSchema, newer : DataSchema) -> SchemaCompatibility

    compare_value

    fn compare_value(comparator : Comparator, actual : Double, expected : Double, tolerance : Double) -> Bool

    competing_risk_cumulative_incidence

    fn competing_risk_cumulative_incidence(events : Array[Int], causes : Array[Int], target_cause : Int) -> Array[Double]

    compose_budgets

    fn compose_budgets(budgets : Array[PrivacyBudget]) -> PrivacyBudget

    concordance_index

    fn concordance_index(actual : Array[Double], predicted : Array[Double], status : Array[Bool]) -> Double

    conformal_quantile

    fn conformal_quantile(residuals : Array[Double], confidence : Double) -> Double

    confusion_matrix

    fn confusion_matrix(predicted : Array[Bool], actual : Array[Bool]) -> DecisionConfusionMatrix

    contract_passes

    fn contract_passes(issues : Array[ContractIssue]) -> Bool

    fn coordinate_search(objective : (Array[Double]) -> Double, initial : Array[Double], step : Double, tolerance : Double, max_iterations : Int) -> CoordinateSearchResult

    Derivative-free coordinate search is useful for small hyperparameter and calibration problems where an analytic gradient is unavailable.

    correlation

    fn correlation(left : Array[Double], right : Array[Double]) -> Double

    cost_from_confusion

    fn cost_from_confusion(matrix : DecisionConfusionMatrix, cost : DecisionCost) -> Double

    counterfactual

    fn counterfactual(original : Double, counterfactual_value : Double, minimum : Double, maximum : Double) -> CounterfactualResult

    covariance

    fn covariance(left : Array[Double], right : Array[Double]) -> Double

    covariance_matrix

    fn covariance_matrix(samples : Array[Array[Double]]) -> DenseMatrix

    covariate_balance

    fn covariate_balance(treated : Array[Double], control : Array[Double], threshold : Double) -> BalanceReport

    cross_validated_rmse

    fn cross_validated_rmse(folds : Array[RegressionReport]) -> Double

    cumulative_sum

    fn cumulative_sum(values : Array[Double]) -> Array[Double]

    cuped_adjust

    fn cuped_adjust(outcomes : Array[Double], covariates : Array[Double], target_covariate_mean : Double) -> CovariateAdjustment

    damped_trend_forecast

    fn damped_trend_forecast(values : Array[Double], level_decay : Double, trend_decay : Double, damping : Double, horizon : Int) -> Array[Double]

    decide_experiment

    fn decide_experiment(control : ExperimentArm, treatment : ExperimentArm, boundary : SequentialBoundary, look : Int) -> ExperimentDecision

    decide_risk

    fn decide_risk(scorecard : RiskScorecard, loss_if_positive : Double, loss_if_negative : Double, accept_loss : Double) -> RiskDecision

    decision_consistency

    fn decision_consistency(logs : Array[DecisionLog]) -> Double

    detect_step

    fn detect_step(values : Array[Double], baseline : Double, threshold : Double) -> Int?

    detrend

    fn detrend(values : Array[Double]) -> Array[Double]

    difference_in_means

    fn difference_in_means(treated : Array[Double], control : Array[Double]) -> CausalEffect

    dijkstra

    fn dijkstra(graph : WeightedGraph, start : Int, target : Int) -> ShortestPath

    disagreement_report

    fn disagreement_report(disagreement : Array[Double], threshold : Double) -> DisagreementReport

    distribution_cdf

    fn distribution_cdf(values : Array[Double], probabilities : Array[Double], value : Double) -> Double

    distribution_mean

    fn distribution_mean(values : Array[Double], probabilities : Array[Double]) -> Double

    distribution_quantile

    fn distribution_quantile(values : Array[Double], probabilities : Array[Double], probability : Double) -> Double

    distribution_variance

    fn distribution_variance(values : Array[Double], probabilities : Array[Double]) -> Double

    diversity_matrix

    fn diversity_matrix(members : Array[EnsembleMember]) -> Array[Array[Double]]

    dot

    fn dot(left : Array[Double], right : Array[Double]) -> Double

    drift_forecast

    fn drift_forecast(values : Array[Double], horizon : Int) -> Array[ForecastPoint]

    effect_heterogeneity

    fn effect_heterogeneity(effects : Array[CausalEffect]) -> Double

    effective_sample_size

    fn effective_sample_size(samples : Array[Double], maximum_lag : Int) -> Double

    empirical_cdf

    fn empirical_cdf(values : Array[Double], value : Double) -> Double

    empirical_entropy

    fn empirical_entropy(values : Array[Int]) -> Double

    empirical_quantile

    fn empirical_quantile(values : Array[Double], probability : Double) -> Double

    ensemble_bias

    fn ensemble_bias(predicted : Array[Double], actual : Array[Double]) -> Double

    ensemble_rank

    fn ensemble_rank(members : Array[EnsembleMember]) -> Array[String]

    ensemble_rmse

    fn ensemble_rmse(predicted : Array[Double], actual : Array[Double]) -> Double

    entropy_bernoulli

    fn entropy_bernoulli(probability : Double) -> Double

    entropy_from_probabilities

    fn entropy_from_probabilities(probabilities : Array[Double]) -> Double

    equalized_odds_gaps

    fn equalized_odds_gaps(observations : Array[CohortObservation], reference : String, threshold : Double, tolerance : Double) -> Array[EqualizedOddsGap]

    estimate_probability

    fn estimate_probability(rng : DeterministicRng, samples : Int, event : (Double) -> Bool) -> (DeterministicRng, MonteCarloEstimate)

    estimate_transitions

    fn estimate_transitions(sequence : Array[Int], states : Int, smoothing : Double) -> TransitionEstimate

    evaluate_gate

    fn evaluate_gate(gate : ValidationGate, model : ModelVersion, score : Double, error_rate : Double, drift : Double) -> GateResult

    evaluate_guardrails

    fn evaluate_guardrails(metrics : Array[GuardrailMetric]) -> GuardrailReport

    evaluate_intervals

    fn evaluate_intervals(intervals : Array[PredictionInterval], actual : Array[Double], target : Double) -> CoverageReport

    evaluate_policy

    fn evaluate_policy(rewards : Array[Double], weights : Array[Double]) -> BanditEvaluation

    evaluate_quantile

    fn evaluate_quantile(actual : Array[Double], predicted : Array[Double], quantile : Double) -> QuantileLoss

    evaluate_sequential_look

    fn evaluate_sequential_look(boundary : OperationalSequentialBoundary, look : Int, estimate : Double, standard_error : Double, futility_z : Double) -> SequentialDecision

    ewma_forecast

    fn ewma_forecast(values : Array[Double], decay : Double, horizon : Int) -> Array[Double]

    expected_calibration_error

    fn expected_calibration_error(bins : Array[UncertaintyCalibrationBin]) -> Double

    expected_value

    fn expected_value(probability : Double, benefit : Double, cost : Double) -> Double

    experiment_quality

    fn experiment_quality(allocation : AllocationCheck, guardrails : GuardrailReport, sequential : SequentialDecision, expected_observations : Int, observed_observations : Int) -> ExperimentQuality

    explanation_stability

    fn explanation_stability(left : Explanation, right : Explanation) -> Double

    exponential_moving_average

    fn exponential_moving_average(values : Array[Double], decay : Double) -> Array[Double]

    exponentially_weighted_variance

    fn exponentially_weighted_variance(values : Array[Double], decay : Double) -> Array[Double]

    factor_kl_divergence

    fn factor_kl_divergence(left : Factor, right : Factor) -> Double

    factor_total_variation

    fn factor_total_variation(left : Factor, right : Factor) -> Double

    fairness_gap

    fn fairness_gap(groups : Array[FairnessGroup], metric : String, tolerance : Double) -> FairnessGap

    fairness_group

    fn fairness_group(name : String, predicted : Array[Bool], actual : Array[Bool]) -> FairnessGroup

    feature_drift

    fn feature_drift(feature : String, baseline : Array[Double], current : Array[Double]) -> FeatureDrift

    feature_store_health

    fn feature_store_health(store : FeatureStore, now : Int) -> FeatureStoreHealth

    finite_difference_gradient

    fn finite_difference_gradient(objective : (Array[Double]) -> Double, parameters : Array[Double], step : Double) -> Array[Double]

    Computes a central finite-difference gradient for black-box objectives.

    fit_isotonic_calibrator

    fn fit_isotonic_calibrator(scores : Array[Double], outcomes : Array[Bool]) -> Array[IsotonicPoint]

    Pool-adjacent-violators calibration. It preserves monotonicity and is a good default when scores are already rank-ordered but poorly scaled.

    fit_linear_model

    fn fit_linear_model(features : Array[Array[Double]], targets : Array[Double], config : OptimizationConfig) -> LinearFit

    Fits an ordinary or ridge-regularized linear model using stable batch gradients. This is intentionally small and deterministic for embedded use.

    fit_linear_stacker

    fn fit_linear_stacker(features : Array[Array[Double]], target : Array[Double], iterations : Int, learning_rate : Double) -> WeightFit

    fit_local_level

    fn fit_local_level(values : Array[Double], process_noise : Double, observation_noise : Double) -> LocalLevelModel

    fit_local_trend

    fn fit_local_trend(values : Array[Double], smoothing : Double, trend_smoothing : Double) -> TrendForecast

    fit_platt_calibrator

    fn fit_platt_calibrator(scores : Array[Double], outcomes : Array[Bool], max_iterations : Int, tolerance : Double) -> PlattCalibrator

    Fits a two-parameter logistic calibration map with damped Newton updates.

    fit_trend

    fn fit_trend(values : Array[Double]) -> TrendEstimate

    forecast_bias

    fn forecast_bias(actual : Array[Double], predicted : Array[Double]) -> Double

    forecast_mase

    fn forecast_mase(actual : Array[Double], predicted : Array[Double], training : Array[Double], seasonal_period : Int) -> Double

    forecast_smape

    fn forecast_smape(actual : Array[Double], predicted : Array[Double]) -> Double

    forecast_values

    fn forecast_values(points : Array[ForecastPoint]) -> Array[Double]

    gaussian_interval

    fn gaussian_interval(prediction : Double, standard_error : Double, confidence : Double) -> PredictionInterval

    gaussian_release

    fn gaussian_release(value : Double, sensitivity : Double, epsilon : Double, delta : Double, noise : Double) -> PrivateRelease

    generate_migrations

    fn generate_migrations(old : DataSchema, newer : DataSchema) -> Array[SchemaMigration]

    gini_from_probabilities

    fn gini_from_probabilities(probabilities : Array[Double]) -> Double

    gini_impurity

    fn gini_impurity(probabilities : Array[Double]) -> Double

    gradient_descent

    fn gradient_descent(objective : (Array[Double]) -> Double, gradient : (Array[Double]) -> Array[Double], initial : Array[Double], config : OptimizationConfig) -> OptimizationTrace

    Batch gradient descent with optional L2 regularization and an immutable trace that can be serialized into experiment metadata.

    graph_bfs

    fn graph_bfs(graph : WeightedGraph, start : Int) -> Array[Int]

    graph_clustering_coefficient

    fn graph_clustering_coefficient(graph : WeightedGraph, node : Int) -> Double

    graph_dfs

    fn graph_dfs(graph : WeightedGraph, start : Int) -> Array[Int]

    group_window_ids

    fn group_window_ids(timestamps : Array[Int], window : WindowSpec) -> Array[Int]

    hazard_table

    fn hazard_table(model : KaplanMeier) -> Array[HazardEstimate]

    hellinger_distance

    fn hellinger_distance(left : Array[Double], right : Array[Double]) -> Double

    histogram

    fn histogram(values : Array[Double], lower : Double, upper : Double, bins : Int) -> Array[Int]

    holt_linear_forecast

    fn holt_linear_forecast(values : Array[Double], level_decay : Double, trend_decay : Double, horizon : Int) -> Array[Double]

    huber_location

    fn huber_location(values : Array[Double], tuning : Double, tolerance : Double, max_iterations : Int) -> RobustLocation

    identity_matrix

    fn identity_matrix(size : Int) -> Array[Array[Double]]

    importance_estimate

    fn importance_estimate(samples : Array[ImportanceSample], function : (Double) -> Double) -> MonteCarloEstimate

    impute_mean

    fn impute_mean(values : Array[Double], is_missing : (Double) -> Bool) -> Array[Double]

    impute_median

    fn impute_median(values : Array[Double], is_missing : (Double) -> Bool) -> Array[Double]

    innovation_outlier_rate

    fn innovation_outlier_rate(updates : Array[KalmanUpdate], z_threshold : Double) -> Double

    integrate_adaptive

    fn integrate_adaptive(function : (Double) -> Double, left : Double, right : Double, tolerance : Double, max_refinements : Int) -> QuadratureResult

    integrate_simpson

    fn integrate_simpson(function : (Double) -> Double, left : Double, right : Double, slices : Int) -> QuadratureResult

    integrate_trapezoid

    fn integrate_trapezoid(function : (Double) -> Double, left : Double, right : Double, slices : Int) -> QuadratureResult

    integrate_uniform

    fn integrate_uniform(rng : DeterministicRng, lower : Double, upper : Double, samples : Int, function : (Double) -> Double) -> (DeterministicRng, MonteCarloEstimate)

    integrated_brier_score

    fn integrated_brier_score(times : Array[Double], status : Array[Bool], curves : Array[Array[Double]], horizons : Array[Double]) -> Double

    interaction_matrix

    fn interaction_matrix(left : Array[Double], right : Array[Double]) -> DenseMatrix

    interquartile_range

    fn interquartile_range(values : Array[Double]) -> Double

    interval_score

    fn interval_score(interval : PredictionInterval, actual : Double, alpha : Double) -> Double

    inverse_loss_weights

    fn inverse_loss_weights(members : Array[EnsembleMember], floor : Double) -> Array[EnsembleMember]

    inverse_probability_effect

    fn inverse_probability_effect(observations : Array[CausalObservation]) -> CausalEffect

    inverse_values

    fn inverse_values(parameters : TransformParameters, values : Array[Double]) -> Array[Double]

    issue_summary

    fn issue_summary(report : QualityReport) -> Array[(String, Int)]

    jackknife_bias

    fn jackknife_bias(values : Array[Double], statistic : (Array[Double]) -> Double) -> Double

    jackknife_estimates

    fn jackknife_estimates(values : Array[Double], statistic : (Array[Double]) -> Double) -> Array[Double]

    js_divergence

    fn js_divergence(left : Array[Double], right : Array[Double]) -> Double

    k_anonymity_satisfied

    fn k_anonymity_satisfied(group_sizes : Array[Int], k : Int) -> Bool

    kalman_filter

    fn kalman_filter(model : KalmanModel, observations : Array[Double], initial : StateEstimate) -> Array[KalmanUpdate]

    kalman_initial

    fn kalman_initial(mean : Double, variance : Double, timestamp : Int) -> StateEstimate

    kalman_log_likelihood

    fn kalman_log_likelihood(updates : Array[KalmanUpdate]) -> Double

    kalman_rmse

    fn kalman_rmse(updates : Array[KalmanUpdate], observations : Array[Double]) -> Double

    kl_divergence

    fn kl_divergence(left : Array[Double], right : Array[Double]) -> Double

    local_sensitivity

    fn local_sensitivity(values : Array[Double], epsilon : Double) -> Double

    log_loss

    fn log_loss(probabilities : Array[Double], observed : Array[Bool], epsilon? : Double) -> Double

    log_sum_exp

    fn log_sum_exp(values : Array[Double]) -> Double

    materialize

    fn materialize(store : FeatureStore, feature : String, entity_ids : Array[String], start_time : Int, end_time : Int) -> (FeatureStore, MaterializationJob)

    matrix_subtract

    fn matrix_subtract(left : Array[Array[Double]], right : Array[Array[Double]]) -> Array[Array[Double]]

    matrix_vector_distance

    fn matrix_vector_distance(left : Array[Double], right : Array[Double]) -> Double

    maximum_calibration_error

    fn maximum_calibration_error(bins : Array[UncertaintyCalibrationBin]) -> Double

    mean

    fn mean(values : Array[Double]) -> Double

    Returns the arithmetic mean, or zero for an empty array.

    mean_absolute_error

    fn mean_absolute_error(predicted : Array[Double], actual : Array[Double]) -> Double

    mean_interval_score

    fn mean_interval_score(intervals : Array[PredictionInterval], actual : Array[Double], alpha : Double) -> Double

    median

    fn median(values : Array[Double]) -> Double

    Robust and exploratory statistics for production data streams.

    median_absolute_deviation

    fn median_absolute_deviation(values : Array[Double]) -> Double

    mediation_decomposition

    fn mediation_decomposition(total : CausalEffect, direct : CausalEffect) -> MediationResult

    merge_quality_reports

    fn merge_quality_reports(left : QualityReport, right : QualityReport) -> QualityReport

    merge_summaries

    fn merge_summaries(summaries : Array[DistributedSummary]) -> DistributedSummary

    metric_snapshot

    fn metric_snapshot(streams : Array[MetricStream]) -> Array[MonitorReport]

    metropolis

    fn metropolis(rng : DeterministicRng, initial : Double, iterations : Int, burn_in : Int, proposal_scale : Double, log_density : (Double) -> Double) -> (DeterministicRng, MarkovChainState)

    metropolis_step

    fn metropolis_step(state : MarkovChainState, rng : DeterministicRng, proposal_scale : Double, log_density : (Double) -> Double) -> (MarkovChainState, DeterministicRng)

    minimum_loss_policy

    fn minimum_loss_policy(points : Array[LossCurvePoint]) -> LossCurvePoint

    monitor_drift

    fn monitor_drift(stream : MetricStream, baseline : OnlineStats, threshold : Double) -> Bool

    monitor_outliers

    fn monitor_outliers(stream : MetricStream, z_threshold : Double) -> Array[MetricSample]

    monotonicity_report

    fn monotonicity_report(feature : String, values : Array[Double], predictions : Array[Double], increasing : Bool, tolerance : Double) -> MonotonicityReport

    monte_carlo

    fn monte_carlo(rng : DeterministicRng, samples : Int, sampler : (DeterministicRng) -> (DeterministicRng, Double), statistic : (Double) -> Double) -> (DeterministicRng, MonteCarloEstimate)

    moving_average

    fn moving_average(values : Array[Double], window : Int) -> Array[Double]

    multiply_all

    fn multiply_all(factors : Array[Factor]) -> Factor

    multiply_factors

    fn multiply_factors(left : Factor, right : Factor) -> Factor

    naive_forecast

    fn naive_forecast(values : Array[Double], horizon : Int) -> Array[ForecastPoint]

    noisy_count

    fn noisy_count(count : Int, sensitivity : Double, epsilon : Double, noise : Double) -> PrivateRelease

    noisy_mean

    fn noisy_mean(values : Array[Double], sensitivity : Sensitivity, epsilon : Double, noise : Double) -> PrivateRelease

    noisy_proportion

    fn noisy_proportion(successes : Int, trials : Int, epsilon : Double, noise : Double) -> PrivateRelease

    noisy_sum

    fn noisy_sum(values : Array[Double], sensitivity : Sensitivity, epsilon : Double, noise : Double) -> PrivateRelease

    normal_cdf

    fn normal_cdf(value : Double) -> Double

    normal_quantile

    fn normal_quantile(probability : Double) -> Double

    normal_summary

    fn normal_summary(mean_value : Double, variance_value : Double) -> DistributionSummary

    normalize_l1

    fn normalize_l1(values : Array[Double]) -> Array[Double]

    normalize_l2

    fn normalize_l2(values : Array[Double]) -> Array[Double]

    normalize_probabilities

    fn normalize_probabilities(values : Array[Double]) -> Array[Double]

    off_policy_value

    fn off_policy_value(rewards : Array[Double], actions : Array[Int], target_probabilities : Array[Double], logging_probabilities : Array[Double]) -> Double

    one_hot

    fn one_hot(index : Int, categories : Int) -> Array[Double]

    one_hot_all

    fn one_hot_all(indices : Array[Int], categories : Int) -> Array[Array[Double]]

    optimize_threshold

    fn optimize_threshold(probabilities : Array[Double], actual : Array[Bool], cost : DecisionCost, steps : Int) -> ThresholdReport

    outer_product

    fn outer_product(left : Array[Double], right : Array[Double]) -> DenseMatrix

    pagerank

    fn pagerank(graph : WeightedGraph, damping : Double, iterations : Int) -> Array[Double]

    pairwise_products

    fn pairwise_products(values : Array[Double]) -> Array[Double]

    partial_autocorrelation

    fn partial_autocorrelation(values : Array[Double], lag : Int) -> Double

    partial_dependence

    fn partial_dependence(predictions : Array[Array[Double]], feature_index : Int, grid : Array[Double]) -> Array[PartialDependencePoint]

    percentile_rank

    fn percentile_rank(values : Array[Double], value : Double) -> Double

    permutation_difference

    fn permutation_difference(rng : DeterministicRng, left : Array[Double], right : Array[Double], permutations : Int) -> (DeterministicRng, Double)

    permutation_importance

    fn permutation_importance(actual : Array[Double], baseline : Array[Double], feature_values : Array[Array[Double]], shuffled_values : Array[Array[Double]]) -> Array[FeatureAttribution]

    perplexity

    fn perplexity(probabilities : Array[Double]) -> Double

    pipeline_success_rate

    fn pipeline_success_rate(runs : Array[PipelineRun]) -> Double

    plan_binary_experiment

    fn plan_binary_experiment(baseline_rate : Double, minimum_effect : Double, alpha : Double, power : Double) -> PowerPlan

    plan_join

    fn plan_join(left_keys : Array[String], right_keys : Array[String], join_type : JoinType) -> Array[JoinRow]

    poisson_summary

    fn poisson_summary(rate : Double) -> DistributionSummary

    policy_distribution

    fn policy_distribution(context : BanditContext, temperature : Double) -> Array[PolicyAction]

    policy_value

    fn policy_value(observations : Array[CausalObservation], policy_treat : Array[Bool]) -> TreatmentPolicyValue

    polynomial_features

    fn polynomial_features(values : Array[Double], degree : Int) -> Array[Double]

    posterior_predictive

    fn posterior_predictive(factor : Factor, target : String) -> PosteriorPredictive

    posterior_predictive_check

    fn posterior_predictive_check(observed : Array[Double], simulated : Array[Array[Double]], statistic : (Array[Double]) -> Double) -> Double

    prediction_variance_decomposition

    fn prediction_variance_decomposition(predictions : Array[Array[Double]]) -> (Double, Double)

    privacy_report

    fn privacy_report(budget : PrivacyBudget) -> PrivacyReport

    privacy_risk_score

    fn privacy_risk_score(unique_count : Int, total_count : Int, epsilon : Double) -> Double

    profile_numeric

    fn profile_numeric(column : String, values : Array[Double]) -> ColumnProfile

    profile_strings

    fn profile_strings(column : String, values : Array[String]) -> ColumnProfile

    propensity_overlap

    fn propensity_overlap(observations : Array[CausalObservation]) -> Double

    quality_gate

    fn quality_gate(report : QualityReport, minimum_score : Double) -> Bool

    quantile

    fn quantile(values : Array[Double], q : Double) -> Double

    Deterministic linear interpolation quantile. q is in the closed interval [0, 1].

    quantile_loss

    fn quantile_loss(actual : Double, predicted : Double, quantile : Double) -> Double

    randomized_response

    fn randomized_response(value : Bool, probability_truthful : Double, random_value : Double) -> Bool

    rank_attributions

    fn rank_attributions(attributions : Array[FeatureAttribution]) -> Array[FeatureAttribution]

    rank_cohorts_by_metric

    fn rank_cohorts_by_metric(metrics : Array[CohortMetric], descending : Bool) -> RankingReport

    rank_descending

    fn rank_descending(values : Array[Double]) -> Array[Int]

    rank_features

    fn rank_features(matrix : Array[Array[Double]]) -> Array[Int]

    rank_models

    fn rank_models(scores : Array[ModelScore]) -> Array[Int]

    rank_segments

    fn rank_segments(segments : Array[UpliftSegment]) -> Array[UpliftSegment]

    redact_numeric

    fn redact_numeric(value : Double, policy : RedactionPolicy, bucket : Double) -> Double

    registry_health

    fn registry_health(registry : Registry, now : Int) -> Double

    reliability_report

    fn reliability_report(probabilities : Array[Double], outcomes : Array[Bool], bins : Int) -> ReliabilityReport

    risk_calibration_error

    fn risk_calibration_error(rows : Array[RiskCalibrationRow]) -> Double

    risk_calibration_table

    fn risk_calibration_table(probabilities : Array[Double], outcomes : Array[Bool], buckets : Int) -> Array[RiskCalibrationRow]

    risk_loss_curve

    fn risk_loss_curve(probabilities : Array[Double], exposures : Array[Double], loss_if_event : Double, review_cost : Double, steps : Int) -> Array[LossCurvePoint]

    rmst_difference

    fn rmst_difference(left : KaplanMeier, right : KaplanMeier, horizon : Double) -> Double

    robust_correlation

    fn robust_correlation(left : Array[Double], right : Array[Double]) -> RobustCorrelation

    robust_mad

    fn robust_mad(values : Array[Double]) -> Double

    robust_median

    fn robust_median(values : Array[Double]) -> Double

    robust_observations

    fn robust_observations(values : Array[Double], multiplier : Double) -> Array[RobustObservation]

    robust_trimmed_mean

    fn robust_trimmed_mean(values : Array[Double], trim_fraction : Double) -> RobustLocation

    roc_auc

    fn roc_auc(scores : Array[Double], outcomes : Array[Bool]) -> Double

    rolling_center

    fn rolling_center(values : Array[Double], window : Int) -> Array[Double]

    rolling_iqr

    fn rolling_iqr(values : Array[Double], window : Int) -> Array[Double]

    rolling_median

    fn rolling_median(values : Array[Double], window : Int) -> Array[Double]

    rolling_quantile

    fn rolling_quantile(values : Array[Double], window : Int, probability : Double) -> Array[Double]

    rolling_scale

    fn rolling_scale(values : Array[Double], window : Int) -> Array[Double]

    rolling_z_scores

    fn rolling_z_scores(values : Array[Double], window : Int) -> Array[Double]

    root_mean_squared_error

    fn root_mean_squared_error(predicted : Array[Double], actual : Array[Double]) -> Double

    safe_divide

    fn safe_divide(numerator : Array[Double], denominator : Array[Double], default_value : Double) -> Array[Double]

    sample_ratio_check

    fn sample_ratio_check(control : Int, treatment : Int, allocation : Double, alpha : Double) -> SampleRatioReport

    sample_size_for_proportion

    fn sample_size_for_proportion(baseline : Double, absolute_effect : Double, alpha : Double, power : Double) -> Int

    schema_has_unique_key

    fn schema_has_unique_key(schema : DataSchema) -> Bool

    schema_quality

    fn schema_quality(schema : DataSchema) -> Double

    schema_required_coverage

    fn schema_required_coverage(schema : DataSchema, observed : Array[String]) -> Double

    seasonal_lag_features

    fn seasonal_lag_features(values : Array[Double], period : Int, lags : Int) -> Array[Array[Double]]

    seasonal_naive

    fn seasonal_naive(values : Array[Double], season : Int, horizon : Int) -> Array[ForecastPoint]

    second_derivative

    fn second_derivative(function : (Double) -> Double, value : Double, step : Double) -> Double

    select_diverse_members

    fn select_diverse_members(members : Array[EnsembleMember], limit : Int) -> Array[EnsembleMember]

    select_epsilon_greedy

    fn select_epsilon_greedy(context : BanditContext, epsilon : Double, random_value : Double) -> Int

    select_lowest_score

    fn select_lowest_score(scores : Array[ModelScore]) -> Int

    select_thompson

    fn select_thompson(context : BanditContext, random_values : Array[Double]) -> Int

    select_ucb

    fn select_ucb(context : BanditContext, exploration : Double) -> Int

    self_normalized_off_policy_value

    fn self_normalized_off_policy_value(rewards : Array[Double], target_probabilities : Array[Double], logging_probabilities : Array[Double]) -> Double

    sensitivity_curve

    fn sensitivity_curve(effect : CausalEffect, factors : Array[Double]) -> Array[SensitivityCurve]

    sharpness

    fn sharpness(probabilities : Array[Double]) -> Double

    shuffle

    fn shuffle(rng : DeterministicRng, values : Array[Int]) -> (DeterministicRng, Array[Int])

    skewness

    fn skewness(values : Array[Double]) -> Double

    solve_bisection

    fn solve_bisection(function : (Double) -> Double, bracket : RootBracket, tolerance : Double, max_iterations : Int) -> NumericalResult

    solve_diagonal

    fn solve_diagonal(diagonal : Array[Double], right : Array[Double]) -> Array[Double]

    solve_linear_system

    fn solve_linear_system(matrix : Array[Array[Double]], vector : Array[Double], tolerance : Double) -> SolveLinearResult

    Gaussian elimination with partial pivoting for small dense systems.

    solve_lower

    fn solve_lower(lower : DenseMatrix, right : Array[Double]) -> Array[Double]

    Solves a lower-triangular system by forward substitution.

    solve_newton

    fn solve_newton(function : (Double) -> Double, derivative : (Double) -> Double, initial : Double, tolerance : Double, max_iterations : Int) -> NumericalResult

    solve_secant

    fn solve_secant(function : (Double) -> Double, first : Double, second : Double, tolerance : Double, max_iterations : Int) -> NumericalResult

    solve_upper

    fn solve_upper(upper : DenseMatrix, right : Array[Double]) -> Array[Double]

    stable_softmax

    fn stable_softmax(values : Array[Double]) -> Array[Double]

    stacking_report

    fn stacking_report(members : Array[EnsembleMember], prediction : EnsemblePrediction) -> StackingReport

    stage_failure_rate

    fn stage_failure_rate(results : Array[StageResult]) -> Double

    standardize_effect

    fn standardize_effect(effect : CausalEffect, outcome_standard_deviation : Double) -> CausalEffect

    standardized

    fn standardized(values : Array[Double]) -> Array[Double]

    state_space_residuals

    fn state_space_residuals(updates : Array[KalmanUpdate]) -> Array[Double]

    stratified_effect

    fn stratified_effect(observations : Array[CausalObservation]) -> Array[StratumEffect]

    suggest_numeric_repairs

    fn suggest_numeric_repairs(profile : ColumnProfile, maximum_missing_rate : Double) -> Array[RepairPlan]

    sum

    fn sum(values : Array[Double]) -> Double

    sum_out

    fn sum_out(factors : Array[Factor], variable : String) -> Array[Factor]

    summarize_missingness

    fn summarize_missingness(matrix : Array[Array[Bool]]) -> MissingnessSummary

    summarize_portfolio

    fn summarize_portfolio(probabilities : Array[Double], exposures : Array[Double], high_risk_threshold : Double, loss_if_event : Double) -> PortfolioRiskSummary

    suppress_small_groups

    fn suppress_small_groups(values : Array[Double], group_sizes : Array[Int], k : Int) -> Array[Double]

    threshold_confusion_matrix

    fn threshold_confusion_matrix(scores : Array[Double], outcomes : Array[Bool], threshold : Double) -> ThresholdConfusionMatrix

    threshold_curve

    fn threshold_curve(scores : Array[Double], outcomes : Array[Bool], steps : Int) -> Array[ThresholdPoint]

    threshold_report

    fn threshold_report(probabilities : Array[Double], actual : Array[Bool], threshold : Double, cost : DecisionCost) -> ThresholdReport

    threshold_utility

    fn threshold_utility(metrics : ThresholdConfusionMatrix, cost : ThresholdCost) -> Double

    throughput

    fn throughput(rows : Int, duration_ms : Int) -> Double

    total_variation

    fn total_variation(left : Array[Double], right : Array[Double]) -> Double

    transform_audit

    fn transform_audit(before : Array[Double], after : Array[Double], lower : Double, upper : Double) -> TransformAudit

    transform_impute_mean

    fn transform_impute_mean(values : Array[Double]) -> (Array[Double], MissingValuePolicy)

    transform_impute_median

    fn transform_impute_median(values : Array[Double]) -> (Array[Double], MissingValuePolicy)

    transform_one_hot

    fn transform_one_hot(values : Array[Int], classes : Int) -> Array[Array[Double]]

    transform_values

    fn transform_values(parameters : TransformParameters, values : Array[Double]) -> Array[Double]

    transform_winsorize

    fn transform_winsorize(values : Array[Double], lower_quantile : Double, upper_quantile : Double) -> Array[Double]

    transition_log_likelihood

    fn transition_log_likelihood(estimate : TransitionEstimate, sequence : Array[Int]) -> Double

    treatment_effect_by_stratum

    fn treatment_effect_by_stratum(labels : Array[String], treatment : Array[Bool], outcomes : Array[Double]) -> Array[UpliftSegment]

    treatment_on_treated

    fn treatment_on_treated(effect : CausalEffect, treatment_rate : Double) -> Double

    tukey_fences

    fn tukey_fences(values : Array[Double], multiplier : Double) -> (Double, Double)

    uniform_grid

    fn uniform_grid(lower : Double, upper : Double, count : Int) -> Array[Double]

    uplift_segment

    fn uplift_segment(label : String, treatment : Array[Double], control : Array[Double], value_per_unit : Double) -> UpliftSegment

    utility_curve

    fn utility_curve(probabilities : Array[Double], actual : Array[Bool], harm : Double, steps : Int) -> Array[UtilityCurvePoint]

    validate_data_contract

    fn validate_data_contract(contract : DataContractSpec, columns : Array[String], rows : Int, now : Int, updated_at : Int) -> Array[ContractIssue]

    validate_row

    fn validate_row(schema : DataSchema, present : Array[String], numeric_fields : Array[String]) -> RowValidation

    value_of_information

    fn value_of_information(current : Double, improved : Double, information_cost : Double) -> Double

    variance

    fn variance(values : Array[Double]) -> Double

    walk_forward_folds

    fn walk_forward_folds(size : Int, folds : Int) -> Array[SplitResult]

    Creates contiguous folds for walk-forward validation.

    weighted_choice

    fn weighted_choice(rng : DeterministicRng, weights : Array[Double]) -> (DeterministicRng, Int)

    weighted_loss

    fn weighted_loss(members : Array[EnsembleMember]) -> Double

    weighted_mean

    fn weighted_mean(values : Array[Double], weights : Array[Double]) -> Double

    weighted_quality_score

    fn weighted_quality_score(report : QualityReport, weights : Array[Double]) -> Double

    window_aggregate

    fn window_aggregate(timestamps : Array[Int], values : Array[Double], window : WindowSpec) -> Array[(Int, NumericAggregate)]

    winsorize

    fn winsorize(values : Array[Double], lower_probability : Double, upper_probability : Double) -> Array[Double]

    winsorized_mean

    fn winsorized_mean(values : Array[Double], tail_fraction : Double) -> RobustLocation