Enum SpineLaw 

pub enum SpineLaw {
    Linear(f64),
    Through(Vec<(f64, f64)>),
    Function(SpineFunction),
}

How a quantity runs along a pipe’s spine, against the share of the spine’s length run: from its value at the start (one for a scale, naught for a twist) at a share of naught.

Variants

Linear(f64)

Linearly to this value at the spine’s end.

Through(Vec<(f64, f64)>)

Through these (share, value) points, the shares rising strictly and the last of them one, the spine’s end. Between two neighbouring points the law is the cubic that keeps between their values, and it runs on through each point with one slope (the monotone cubic Hermite interpolant): a value the points never leave, the law never leaves either.

Function(SpineFunction)

The value the function gives at each share, from naught to one. It gives the start value at naught exactly. The sweep reads it at its stations and wherever it checks its skin between them, and holds the skin to the tolerance against what it reads there; it is to be continuous over the spine, and a scale law above naught all along.

Trait Implementations

impl Clone for SpineLaw

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 SpineLaw

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

Formats the value using the given formatter.

impl PartialEq for SpineLaw

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for SpineLaw