Struct ClampedQuantity 

pub struct ClampedQuantity<T>
where
    T: IsQuantityFunction,
{ /* private fields */ }

A wrapper around a type implementing IsQuantityFunction trait object which clamps the output of IsQuantityFunction::call using the provided upper and lower limits.

If the serde feature is not activated, it implements IsQuantityFunction in a generic manner and can therefore be used in a QuantityFunction. If serde is activated, it is unfortately not possible to provide a generic implementation due to the macro #[typetag::serde] not being able to deal with generics. As a workaround, it is possible to provide a simple custom implementation for each concrete type in your own crate:

#[cfg_attr(feature = "serde", typetag::serde)]
impl IsQuantityFunction for ClampedQuantity<YourTypeHere> {
    fn call(&self, conditions: &[DynQuantity<f64>]) -> DynQuantity<f64> {
        return self.call_clamped(conditions);
    }
}

This approach is used for all the implementors of IsQuantityFunction provided with this crate.

Implementations

impl<T> ClampedQuantity<T>

where T: IsQuantityFunction,

pub fn new( upper_limit: f64, lower_limit: f64, function: T, ) -> Result<ClampedQuantity<T>, &'static str>

Checks if upper_limit >= lower_limit and returns a new instance of ClampedQuantity if true.

pub fn inner(&self) -> &T

Returns the underlying IsQuantityFunction.

pub fn inner_dyn(&self) -> &(dyn IsQuantityFunction + 'static)

Returns the underlying IsQuantityFunction as a trait object.

pub fn upper_limit(&self) -> f64

Returns the upper limit.

pub fn lower_limit(&self) -> f64

Returns the lower limit.

pub fn call_clamped(&self, conditions: &[DynQuantity<f64>]) -> DynQuantity<f64>

Clamps the output value of T::call using the provided upper and lower limits. This function is mainly here to simplify custom IsQuantityFunction implementations, see the ClampedQuantity docstring.

Trait Implementations

impl<T> Clone for ClampedQuantity<T>

where T: Clone + IsQuantityFunction,

fn clone(&self) -> ClampedQuantity<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de, T> Deserialize<'de> for ClampedQuantity<T>

where T: IsQuantityFunction + Deserialize<'de>,

fn deserialize<__D>( __deserializer: __D, ) -> Result<ClampedQuantity<T>, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl IsQuantityFunction for ClampedQuantity<Exponential>

fn call(&self, conditions: &[DynQuantity<f64>]) -> DynQuantity<f64>

Returns a quantity as a function of conditions. See the IsQuantityFunction trait docstring for examples.

fn dyn_eq(&self, other: &(dyn IsQuantityFunction + 'static)) -> bool

Returns true if self and other are identical and false otherwise.

impl IsQuantityFunction for ClampedQuantity<FirstOrderTaylor>

fn call(&self, conditions: &[DynQuantity<f64>]) -> DynQuantity<f64>

Returns a quantity as a function of conditions. See the IsQuantityFunction trait docstring for examples.

fn dyn_eq(&self, other: &(dyn IsQuantityFunction + 'static)) -> bool

Returns true if self and other are identical and false otherwise.

impl IsQuantityFunction for ClampedQuantity<Linear>

fn call(&self, conditions: &[DynQuantity<f64>]) -> DynQuantity<f64>

Returns a quantity as a function of conditions. See the IsQuantityFunction trait docstring for examples.

fn dyn_eq(&self, other: &(dyn IsQuantityFunction + 'static)) -> bool

Returns true if self and other are identical and false otherwise.

impl IsQuantityFunction for ClampedQuantity<Polynomial>

fn call(&self, conditions: &[DynQuantity<f64>]) -> DynQuantity<f64>

Returns a quantity as a function of conditions. See the IsQuantityFunction trait docstring for examples.

fn dyn_eq(&self, other: &(dyn IsQuantityFunction + 'static)) -> bool

Returns true if self and other are identical and false otherwise.

impl<T> PartialEq for ClampedQuantity<T>

where T: PartialEq + IsQuantityFunction,

fn eq(&self, other: &ClampedQuantity<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for ClampedQuantity<T>

where T: IsQuantityFunction + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> StructuralPartialEq for ClampedQuantity<T>

where T: IsQuantityFunction,