Struct float_duration::duration::FloatDuration

pub struct FloatDuration { /* fields omitted */ }

A time duration stored as a floating point quantity.

Unlike std::time::Duration or chrono::Duration, FloatDuration aims to be convenient and fast to use in simulation and mathematical expressions rather than to behave like a calendar or perfectly accurately represent precise time scales.

Internally, a FloatDuration stores a single f64 number of floating-point seconds, thus it is only as precise as the f64 type.

Methods

impl FloatDuration

pub fn years(years: f64) -> FloatDuration

Create a new FloatDuration representing a number of years.

float_duration considers one year to be exactly 365 days, with no consideration of leap years.

pub fn days(days: f64) -> FloatDuration

Create a new FloatDuration representing a number of days.

pub fn hours(hours: f64) -> FloatDuration

Create a new FloatDuration representing a number of hours.

pub fn minutes(mins: f64) -> FloatDuration

Create a new FloatDuration representing a number of minutes.

pub fn seconds(secs: f64) -> FloatDuration

Create a new FloatDuration representing a number of seconds.

pub fn milliseconds(millis: f64) -> FloatDuration

Create a new FloatDuration representing a number of milliseconds.

pub fn microseconds(micros: f64) -> FloatDuration

Create a new FloatDuration representing a number of microseconds.

pub fn nanoseconds(nanos: f64) -> FloatDuration

Create a new FloatDuration representing a number of nanoseconds.

pub fn as_years(&self) -> f64

Return the total number of fractional years represented by the FloatDuration.

float_duration considers one year to be exactly 365 days, with no consideration of leap years.

pub fn as_days(&self) -> f64

Return the total number of fractional days represented by the FloatDuration.

pub fn as_hours(&self) -> f64

Return the total number of fractional hours represented by the FloatDuration.

pub fn as_minutes(&self) -> f64

Return the total number of fractional minutes represented by the FloatDuration.

pub fn as_seconds(&self) -> f64

Return the total number of fractional seconds represented by the FloatDuration.

pub fn as_milliseconds(&self) -> f64

Return the total number of fractional milliseconds represented by the FloatDuration.

pub fn as_microseconds(&self) -> f64

Return the total number of fractional microseconds represented by the FloatDuration.

pub fn as_nanoseconds(&self) -> f64

Return the total number of fractional nanoseconds represented by the FloatDuration.

pub fn abs(self) -> FloatDuration

Compute the absolute value of this duration.

pub fn zero() -> FloatDuration

Return a new FloatDuration that represents zero elapsed time.

pub fn is_zero(&self) -> bool

Returns true is this duration represents zero elapsed time (equals FloatDuration::zero()).

pub fn is_positive(&self) -> bool

Returns true if the FloatDuration holds a positive amount of time.

pub fn is_negative(&self) -> bool

Returns true if the FloatDuration holds a negative amount of time.

pub fn signum(&self) -> f64

Return a number that represents the sign of self.

• 1.0 if the value is positive, +0.0 or INFINITY
• -1.0 if the value is negative, -0.0 or NEG_INFINITY
• NAN if the value is NAN

pub fn max(self, other: FloatDuration) -> FloatDuration

Return the maximum of two durations.

pub fn min(self, other: FloatDuration) -> FloatDuration

Return the minimum of two durations.

pub fn min_value() -> FloatDuration

Return a new FloatDuration with the minimum possible value.

pub fn max_value() -> FloatDuration

Return a new FloatDuration with the maximum possible value.

pub fn to_std(&self) -> Result<Duration, OutOfRangeError>

Create a std::time::Duration object from a FloatDuration.

Errors

std::time::Duration does not support negative values or seconds greater than std::u64::MAX. This function will return a DurationError::StdOutOfRange if the FloatDuration value is outside of either of those bounds.

pub fn from_std(duration: Duration) -> FloatDuration

Create a FloatDuration object from a std::time::Duration.

Equivalent to using FloatDuration::from(duration)

impl FloatDuration

pub fn to_chrono(&self) -> Result<Duration, OutOfRangeError>

Create a chrono::Duration object from a FloatDuration.

Errors

Presently, the conversion to chrono::Duration first goes through std::time::Duration and return an error if to_std returns an error.

pub fn from_chrono(duration: Duration) -> FloatDuration

Create a FloatDuration object from a chrono::Duration.

chrono::Duration does not provide a way to access sub-millisecond precision if the duration is too large to be entirely represented as a single value. Thus, if the absolute value of the total number of nanoseconds is greater than i64::MAX, only millisecond precision will be captured.

Equivalent to using FloatDuration::from(duration)

Trait Implementations

impl FromDuration<Duration> for FloatDuration

type Error = ()

fn from_duration(from: Duration) -> Result<FloatDuration, ()>

Convert from into a Self object.

impl FromDuration<Duration> for FloatDuration

type Error = ()

fn from_duration(from: Duration) -> Result<FloatDuration, ()>

Convert from into a Self object.

impl FromDuration<FloatDuration> for Duration

type Error = OutOfRangeError

fn from_duration(from: FloatDuration) -> Result<Duration, OutOfRangeError>

Convert from into a Self object.

impl FromDuration<FloatDuration> for Duration

type Error = OutOfRangeError

fn from_duration(from: FloatDuration) -> Result<Duration, OutOfRangeError>

Convert from into a Self object.

impl PartialOrd<FloatDuration> for FloatDuration

fn partial_cmp(&self, other: &FloatDuration) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &FloatDuration) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &FloatDuration) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &FloatDuration) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &FloatDuration) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Default for FloatDuration

fn default() -> FloatDuration

Returns the "default value" for a type.

impl PartialEq<FloatDuration> for FloatDuration

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl From<Duration> for FloatDuration

fn from(from: Duration) -> FloatDuration

Performs the conversion.

impl From<Duration> for FloatDuration

fn from(from: Duration) -> FloatDuration

Performs the conversion.

impl Clone for FloatDuration

fn clone(&self) -> FloatDuration

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for FloatDuration

impl Display for FloatDuration

fn fmt(&self, fmt: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Debug for FloatDuration

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

Formats the value using the given formatter.

impl Add<FloatDuration> for FloatDuration

type Output = FloatDuration

The resulting type after applying the + operator.

fn add(self, rhs: FloatDuration) -> FloatDuration

Performs the + operation.

impl Sub<FloatDuration> for FloatDuration

type Output = FloatDuration

The resulting type after applying the - operator.

fn sub(self, rhs: FloatDuration) -> FloatDuration

Performs the - operation.

impl Mul<f64> for FloatDuration

type Output = FloatDuration

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> FloatDuration

Performs the * operation.

impl Mul<FloatDuration> for f64

type Output = FloatDuration

The resulting type after applying the * operator.

fn mul(self, rhs: FloatDuration) -> FloatDuration

Performs the * operation.

impl Div<f64> for FloatDuration

type Output = FloatDuration

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> FloatDuration

Performs the / operation.

impl Div<FloatDuration> for FloatDuration

type Output = f64

The resulting type after applying the / operator.

fn div(self, rhs: FloatDuration) -> f64

Performs the / operation.

impl Neg for FloatDuration

type Output = FloatDuration

The resulting type after applying the - operator.

fn neg(self) -> FloatDuration

Performs the unary - operation.

impl AddAssign<FloatDuration> for FloatDuration

fn add_assign(&mut self, rhs: FloatDuration)

Performs the += operation.

impl SubAssign<FloatDuration> for FloatDuration

fn sub_assign(&mut self, rhs: FloatDuration)

Performs the -= operation.

impl MulAssign<f64> for FloatDuration

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl DivAssign<f64> for FloatDuration

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl Sum<FloatDuration> for FloatDuration

fn sum<I>(iter: I) -> FloatDuration where     I: Iterator<Item = FloatDuration>,

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<'a> Sum<&'a FloatDuration> for FloatDuration

fn sum<I>(iter: I) -> FloatDuration where     I: Iterator<Item = &'a FloatDuration>,

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl ApproxEq for FloatDuration

type Epsilon = f64

Used for specifying relative comparisons.

fn default_epsilon() -> f64

The default tolerance to use when testing values that are close together.

fn default_max_relative() -> f64

The default relative tolerance for testing values that are far-apart.

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn relative_eq(     &self,     other: &FloatDuration,     epsilon: f64,     max_relative: f64 ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn ulps_eq(&self, other: &FloatDuration, epsilon: f64, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn relative_ne(     &self,     other: &Self,     epsilon: Self::Epsilon,     max_relative: Self::Epsilon ) -> bool

The inverse of ApproxEq::relative_eq.

fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of ApproxEq::ulps_eq.

impl Serialize for FloatDuration

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where     S: Serializer,

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for FloatDuration

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> where     D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.