Struct NonNegativeRate 

pub struct NonNegativeRate(/* private fields */);

A finite, non-negative f32 rate, valid by construction.

A NonNegativeRate can never hold a NaN, an infinity, or a negative: the invariant is is_finite() && r >= 0.0. Unlike Probability it has no upper bound — it is the right type for an unbounded magnitude such as BLX-α’s expansion factor or Gaussian mutation’s σ, where the hazard is a NaN/Inf poisoning the offspring tensor rather than an out-of-[0,1] saturation.

Construct with new for literals (panics on an invalid value) or try_new for runtime data (returns NonNegativeRateError). Deserialize routes through try_new via TryFrom, so a rate loaded from a file cannot deserialize into a non-finite or negative NonNegativeRate.

Implementations

impl NonNegativeRate

pub const fn new(r: f32) -> Self

Builds a rate from a compile-time-known value, panicking on an invalid one.

This is the constructor for literals and Defaults — the bad value is right at the call site, mirroring the documented builder-setter panic exception of ADR 0026. Prefer try_new for any value derived from runtime or user-supplied data.

Panics

Panics when r is negative, NaN, or infinite.

pub fn try_new(r: f32) -> Result<Self, NonNegativeRateError>

Builds a rate from a runtime / user-supplied value.

Errors

Returns NonNegativeRateError when r is negative, NaN, or infinite.

pub const fn get(self) -> f32

The wrapped rate, guaranteed finite and >= 0.

Trait Implementations

impl Clone for NonNegativeRate

fn clone(&self) -> NonNegativeRate

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for NonNegativeRate

impl Debug for NonNegativeRate

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NonNegativeRate

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<NonNegativeRate> for f32

fn from(r: NonNegativeRate) -> Self

Converts to this type from the input type.

impl PartialEq for NonNegativeRate

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for NonNegativeRate

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 NonNegativeRate

impl TryFrom<f32> for NonNegativeRate

type Error = NonNegativeRateError

The type returned in the event of a conversion error.

fn try_from(r: f32) -> Result<Self, Self::Error>

Performs the conversion.