Sign in

    zhaoyuanjuns/moonbit_extractor/calibration does not have a README file

    BootstrapFit

    pub(all) struct BootstrapFit {
    replicate : Int
    model : RegressionModel
    prediction_at_reference : Double
    residual_scale : Double
    accepted : Bool
    } derive(Eq, ToJson,
    Debug
    )

    Resampling and uncertainty summaries for calibration models.

    CoefficientSummary

    pub(all) struct CoefficientSummary {
    index : Int
    mean : Double
    standard_deviation : Double
    minimum : Double
    maximum : Double
    } derive(Eq, ToJson,
    Debug
    )

    CrossValidation

    pub(all) struct CrossValidation {
    folds : Int
    mean_squared_error : Double
    worst_squared_error : Double
    predictions : Array[Double]
    } derive(Eq, ToJson,
    Debug
    )

    EfficiencyCalibration

    pub(all) struct EfficiencyCalibration {
    model : RegressionModel
    predicted_efficiencies : Array[Double]
    clamped_count : Int
    } derive(Eq, ToJson,
    Debug
    )

    FitUncertainty

    pub(all) struct FitUncertainty {
    reference_x : Double
    mean_prediction : Double
    standard_deviation : Double
    lower_prediction : Double
    upper_prediction : Double
    relative_uncertainty : Double
    replicates : Int
    } derive(Eq, ToJson,
    Debug
    )

    MeasuredPoint

    pub(all) struct MeasuredPoint {
    run_id : String
    x : Double
    y : Double
    standard_uncertainty : Double
    replicate : Int
    } derive(Eq, ToJson,
    Debug
    )

    A measured point with an explicit run identifier and optional uncertainty.

    MeasuredPoint::new

    fn MeasuredPoint::new(run_id~ : String, x~ : Double, y~ : Double, standard_uncertainty? : Double, replicate? : Int) -> MeasuredPoint raise
    ExtractionError

    MeasuredPoint::weight

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

    ModelComparison

    pub(all) struct ModelComparison {
    first_rmse : Double
    second_rmse : Double
    first_mae : Double
    second_mae : Double
    preferred : String
    improvement_fraction : Double
    } derive(Eq, ToJson,
    Debug
    )

    Compare two fitted models on the same measured points.

    Observation

    pub(all) struct Observation {
    x : Double
    y : Double
    weight : Double
    } derive(Eq, ToJson,
    Debug
    )

    Small, dependency-free regression primitives for measured equilibrium data. The implementation deliberately keeps the normal equations visible so that a process engineer can audit the fit and its residuals without a black box.

    Observation::new

    fn Observation::new(x~ : Double, y~ : Double, weight? : Double) -> Observation raise
    ExtractionError

    PredictionInterval

    pub(all) struct PredictionInterval {
    x : Double
    prediction : Double
    lower : Double
    upper : Double
    half_width : Double
    confidence_level : Double
    } derive(Eq, ToJson,
    Debug
    )

    RegressionDiagnostics

    pub(all) struct RegressionDiagnostics {
    count : Int
    residuals : Array[ResidualRecord]
    mean_absolute_error : Double
    median_absolute_error : Double
    root_mean_squared_error : Double
    maximum_absolute_error : Double
    bias : Double
    r_squared : Double
    outlier_count : Int
    } derive(Eq, ToJson,
    Debug
    )

    RegressionModel

    pub(all) struct RegressionModel {
    coefficients : Array[Double]
    degree : Int
    observations : Int
    weighted_mean_y : Double
    residual_sum_squares : Double
    total_sum_squares : Double
    r_squared : Double
    root_mean_squared_error : Double
    max_absolute_error : Double
    } derive(Eq, ToJson,
    Debug
    )

    RegressionModel::coefficient

    RegressionModel::predict

    fn RegressionModel::predict(self : RegressionModel, x : Double) -> Double

    RegressionModel::residual

    fn RegressionModel::residual(self : RegressionModel, observation : Observation) -> Double

    RegressionModel::summary

    fn RegressionModel::summary(self : RegressionModel) -> String

    ResidualRecord

    pub(all) struct ResidualRecord {
    run_id : String
    x : Double
    observed : Double
    predicted : Double
    residual : Double
    standardized_residual : Double
    leverage : Double
    } derive(Eq, ToJson,
    Debug
    )

    ResponseSurfaceModel

    pub(all) struct ResponseSurfaceModel {
    coefficients : Array[Double]
    observations : Int
    residual_sum_squares : Double
    r_squared : Double
    first_center : Double
    second_center : Double
    first_scale : Double
    second_scale : Double
    } derive(Eq, ToJson,
    Debug
    )

    ResponseSurfaceModel::coefficient

    ResponseSurfaceModel::gradient

    fn ResponseSurfaceModel::gradient(self : ResponseSurfaceModel, first : Double, second : Double) -> (Double, Double)

    ResponseSurfaceModel::grid

    fn ResponseSurfaceModel::grid(self : ResponseSurfaceModel, first_lower~ : Double, first_upper~ : Double, second_lower~ : Double, second_upper~ : Double, count~ : Int) -> Array[SurfaceGridPoint] raise
    ExtractionError

    ResponseSurfaceModel::predict

    fn ResponseSurfaceModel::predict(self : ResponseSurfaceModel, first : Double, second : Double) -> Double

    RobustFit

    pub(all) struct RobustFit {
    model : RegressionModel
    iterations : Int
    removed_points : Int
    diagnostics : RegressionDiagnostics
    } derive(Eq, ToJson,
    Debug
    )

    A robust fit result after iteratively down-weighting large residuals.

    SurfaceGridPoint

    pub(all) struct SurfaceGridPoint {
    first : Double
    second : Double
    response : Double
    first_gradient : Double
    second_gradient : Double
    } derive(Eq, ToJson,
    Debug
    )

    SurfaceObservation

    pub(all) struct SurfaceObservation {
    first : Double
    second : Double
    response : Double
    weight : Double
    } derive(Eq, ToJson,
    Debug
    )

    A response-surface observation for two process variables.

    SurfaceObservation::new

    fn SurfaceObservation::new(first~ : Double, second~ : Double, response~ : Double, weight? : Double) -> SurfaceObservation raise
    ExtractionError

    SurfaceResidual

    pub(all) struct SurfaceResidual {
    first : Double
    second : Double
    observed : Double
    predicted : Double
    residual : Double
    } derive(Eq, ToJson,
    Debug
    )

    accepted_bootstrap_fits

    fn accepted_bootstrap_fits(fits : ArrayView[BootstrapFit]) -> Array[BootstrapFit]

    bootstrap_acceptance_rate

    fn bootstrap_acceptance_rate(fits : ArrayView[BootstrapFit]) -> Double

    bootstrap_fits

    fn bootstrap_fits(observations : ArrayView[Observation], degree : Int, replicates : Int, reference_x : Double, maximum_rmse : Double) -> Array[BootstrapFit] raise
    ExtractionError

    bootstrap_sample

    calibrate_efficiency

    fn calibrate_efficiency(ideal_stages : ArrayView[Double], actual_stages : ArrayView[Double]) -> EfficiencyCalibration raise
    ExtractionError

    Calibrate stage efficiency from measured ideal/actual stage pairs. Efficiencies are physically constrained to (0, 1] after prediction.

    calibration_quality_label

    fn calibration_quality_label(rmse : Double, relative_uncertainty : Double) -> String

    compare_fit_predictions

    fn compare_fit_predictions(first : RegressionModel, second : RegressionModel, xs : ArrayView[Double]) -> Array[Double]

    cross_validated_rmse

    fn cross_validated_rmse(observations : ArrayView[Observation], degree : Int, folds : Int) -> Double raise
    ExtractionError

    diagnose

    Build residual and leverage diagnostics for an existing polynomial model.

    fit_polynomial

    Fit y = c0 + c1*x + ... + cn*x^n by weighted least squares.

    fit_uncertainty_markdown

    fn fit_uncertainty_markdown(uncertainty : FitUncertainty, label : String) -> String

    learning_curve

    fn learning_curve(observations : ArrayView[Observation], degree : Int, minimum_size : Int) -> Array[Double] raise
    ExtractionError

    leave_one_out

    Leave-one-out validation is useful for small laboratory equilibrium tables.

    maximum_prediction_difference

    fn maximum_prediction_difference(first : RegressionModel, second : RegressionModel, xs : ArrayView[Double]) -> Double

    model_prediction_band

    fn model_prediction_band(model : RegressionModel, observations : ArrayView[Observation], xs : ArrayView[Double], confidence_multiplier : Double) -> Array[(Double, Double, Double)]

    model_sensitivity

    fn model_sensitivity(model : RegressionModel, x : Double, relative_step? : Double) -> Double raise
    ExtractionError

    Calculate a normalized sensitivity of a fitted correlation at one point.

    prediction_grid

    fn prediction_grid(model : RegressionModel, lower~ : Double, upper~ : Double, count~ : Int) -> Array[PredictionInterval] raise
    ExtractionError

    Evaluate a model on a regular grid for plotting or process screening.

    prediction_interval

    fn prediction_interval(model : RegressionModel, points : ArrayView[MeasuredPoint], x : Double, confidence_level? : Double) -> PredictionInterval raise
    ExtractionError

    Estimate a prediction interval using model residual dispersion.

    residual_scale

    fn residual_scale(model : RegressionModel, observations : ArrayView[Observation]) -> Double

    response_surface_residuals

    fn response_surface_residuals(model : ResponseSurfaceModel, observations : ArrayView[SurfaceObservation]) -> Array[SurfaceResidual]

    robust_polynomial_fit

    fn robust_polynomial_fit(points : ArrayView[MeasuredPoint], degree : Int, maximum_iterations? : Int, cutoff? : Double) -> RobustFit raise
    ExtractionError

    Iteratively reweighted least squares for noisy equilibrium measurements.

    select_surface_optimum

    summarize_coefficients

    fn summarize_coefficients(fits : ArrayView[BootstrapFit], coefficient_count : Int) -> Array[CoefficientSummary]

    summarize_fit_uncertainty

    fn summarize_fit_uncertainty(fits : ArrayView[BootstrapFit], reference_x : Double, lower_probability : Double, upper_probability : Double) -> FitUncertainty raise
    ExtractionError