Struct Approximation 

pub struct Approximation {
    pub code: String,
    pub body: String,
    pub measured: f64,
    pub bar: f64,
    pub volume_bound: Option<f64>,
    pub edges: Vec<OffCarrierEdge>,
    pub budget: Option<ApproximationBudget>,
    pub message: String,
}

A MEASURED approximation a SUCCESSFUL result carries: the result stands, and this says by how much, and why, it is not exact. Distinct from a refusal (the result does not stand) and from a fulfilment (what was done of what was asked) — the typed-refusal plan’s third kind of report.

The one producer today is the STEP import’s shell-closure gate (io/step_import/builder/closure.rs): a body whose closed shell’s trims enclose more vector area than the pcurve fit floor accounts for, but less than the size-relative cap that refuses it, is imported and carries this. volume_bound is what the measurement implies for the body’s volume: an open shell’s divergence integral reads V − R·A/3 about a reference R, so two references inside the body disagree by up to |A| × diagonal / 3, which is the band inside which no oracle can say the volume is wrong.

Fields

code: String

Stable code, e.g. import.shell_closure.

body: String

The body it is about, by the name the consumer knows it under: the import’s file-order index until the feature names it, then the scene name.

measured: f64

The measured quantity (for import.shell_closure, the shell’s vector area residual, mm²) and the bar it is read against.

bar: f64

volume_bound: Option<f64>

The bound the measurement puts on the body’s VOLUME, mm³ — the reference-lever term above. None when the code does not imply one.

edges: Vec<OffCarrierEdge>

The edges that carry the approximation, worst first, with their origin.

budget: Option<ApproximationBudget>

Why a construction REQUEST went unmet (blend.wall_model), or why a blend wall shipped from a rung that never met its acceptance bars (blend.wall_acceptance), and the budget it spent. None for every other code.

message: String

The human text, verbatim.

Trait Implementations

impl Clone for Approximation

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Approximation

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Approximation

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Approximation

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Approximation

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Approximation