Struct Wrap

pub struct Wrap {
    pub minimum: f64,
    pub range: f64,
    pub value: f64,
}

Wraps the value to [minimum, minimum + range)

Examples

use com_croftsoft_core::math::math_lib::*;
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    360.0,
    value:   -190.0,
  }.calculate().unwrap(),
  170.0);
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    360.0,
    value:    190.0,
  }.calculate().unwrap(),
  -170.0);
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    360.0,
    value:    180.0,
  }.calculate().unwrap(),
  -180.0);
assert_eq!(
  Wrap {
    minimum:  f64::MAX,
    range:    360.0,
    value:    190.0,
  }.calculate().unwrap_err(),
  WrapError::FloatResolution(
    WrapErrorFloatResolution::DeltaIsNegativeMinimum));
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    360.0,
    value:    f64::MAX,
  }.calculate().unwrap_err(),
  WrapError::FloatResolution(
    WrapErrorFloatResolution::DeltaIsValue));
assert_eq!(
  Wrap {
    minimum:  f64::INFINITY,
    range:    360.0,
    value:    190.0,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::MinimumIsInfinite(f64::INFINITY)));
assert_eq!(
  Wrap {
    minimum:  f64::NEG_INFINITY,
    range:    360.0,
    value:    190.0,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::MinimumIsInfinite(f64::NEG_INFINITY)));
assert_eq!(
  Wrap {
    minimum:  f64::NAN,
    range:    360.0,
    value:    190.0,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::MinimumIsNotANumber));
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    f64::INFINITY,
    value:    190.0,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::RangeIsInfinite(f64::INFINITY)));
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    f64::NEG_INFINITY,
    value:    190.0,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::RangeIsInfinite(f64::NEG_INFINITY)));
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:   -360.0,
    value:    180.0,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::RangeIsNonPositive(-360.0)));
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    f64::NAN,
    value:    190.0,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::RangeIsNotANumber));
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    360.0,
    value:    f64::INFINITY,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::ValueIsInfinite(f64::INFINITY)));
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    360.0,
    value:    f64::NEG_INFINITY,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::ValueIsInfinite(f64::NEG_INFINITY)));
assert_eq!(
  Wrap {
    minimum: -180.0,
    range:    360.0,
    value:    f64::NAN,
  }.calculate().unwrap_err(),
  WrapError::InvalidArgument(
    WrapErrorInvalidArgument::ValueIsNotANumber));

Fields

minimum: f64

range: f64

value: f64

Implementations

impl Wrap

pub fn calculate(&self) -> Result<f64, WrapError>

Trait Implementations

impl Clone for Wrap

fn clone(&self) -> Wrap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Wrap

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

Formats the value using the given formatter.

impl PartialEq for Wrap

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

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

const 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 StructuralPartialEq for Wrap