Struct twofloat::TwoFloat

pub struct TwoFloat { /* fields omitted */ }

Represents a two-word floating point type, represented as the sum of two non-overlapping f64 values.

Methods

impl TwoFloat

pub fn new_add(x: f64, y: f64) -> TwoFloat

Creates a new TwoFloat by adding two f64 values using Algorithm 2 from Joldes et al. (2017).

pub fn new_sub(x: f64, y: f64) -> TwoFloat

Creates a new TwoFloat by subtracting two f64 values using Algorithm 2 from Joldes et al. (2017) modified for negative right-hand side.

pub fn new_mul(x: f64, y: f64) -> TwoFloat

Creates a new TwoFloat by multiplying two f64 values using Algorithm 3 from Joldes et al. (2017).

pub fn new_div(x: f64, y: f64) -> TwoFloat

Creates a new TwoFloat by dividing two f64 values using Algorithm 15 from Joldes et al. (2017) modified for the left-hand-side having a zero value in the low word.

impl TwoFloat

pub fn try_new(a: f64, b: f64) -> Result<TwoFloat, ()>

Attempts to construct a new TwoFloat from two f64 values. This can be used to reconstitute a TwoFloat from the values returned by the data method.

Errors

An error will be returned if the supplied f64 values overlap.

Examples

let a = 1.0;
let b = 1.0e-200;
let result1 = TwoFloat::try_new(a, b)?;
let result2 = TwoFloat::try_new(1.0, 2.0);

assert_eq!(result1.data(), (a, b));
assert!(result2.is_err());

pub fn data(&self) -> (f64, f64)

Returns the high and low words of self as a tuple.

Examples

let value = TwoFloat::new_add(1.0, 1.0e-200);
assert_eq!(value.data(), (1.0, 1.0e-200));

pub fn is_valid(&self) -> bool

Returns true if self is a valid value, where both components are finite (not infinity or NaN).

Examples

let a = TwoFloat::new_add(1.0, 1.0e-300).is_valid();
let b = TwoFloat::new_mul(1.0e300, 1.0e300).is_valid();

assert!(a);
assert!(!b);

pub fn min(&self, other: &TwoFloat) -> TwoFloat

Returns the minimum of two numbers. If one of the arguments is NAN, the other is returned.

Examples

let a = TwoFloat::new_add(35.2, 1e-84);
let b = TwoFloat::new_add(35.2, -1e-93);

assert_eq!(a.min(&b), b);

pub fn max(&self, other: &TwoFloat) -> TwoFloat

Returns the maximum of two numbers. If one of the arguments is NAN, the other is returned.

Examples

let a = TwoFloat::new_add(35.2, 1e-84);
let b = TwoFloat::new_add(35.2, -1e-93);

assert_eq!(a.max(&b), a);

impl TwoFloat

pub fn exp(&self) -> TwoFloat

Returns e^(self), (the exponential function).

Note that this function returns an approximate value, in particular the low word of the core polynomial approximation is not guaranteed.

Examples

let a = TwoFloat::from(2.0);
let b = a.exp();
let e2 = twofloat::consts::E * twofloat::consts::E;

assert!((b - e2).abs() / e2 < 1e-16);

pub fn exp2(&self) -> TwoFloat

Returns 2^(self).

This is a convenience method that computes (self * LN_2).exp(), no additional accuracy is provided.

Examples

let a = TwoFloat::from(6.0).exp2();

assert!((a - 64.0).abs() < 1e-15);

pub fn ln(&self) -> TwoFloat

Returns the natural logarithm of the value.

Uses Newton–Raphson iteration which depends on the exp function, so may not be fully accurate to the full precision of a TwoFloat.

Example

let a = twofloat::consts::E.ln();
assert!((a - 1.0).abs() < 1e-11);

pub fn log(&self, base: &TwoFloat) -> TwoFloat

Returns the logarithm of the number with respect to an arbitrary base.

This is a convenience method that computes self.ln() / base.ln(), no additional accuracy is provided.

Examples

let a = TwoFloat::from(81.0); let b = TwoFloat::from(3.0); let c = a.log(&b);

assert!((c - 4.0).abs() < 1e-12);

pub fn log2(&self) -> TwoFloat

Returns the base 2 logarithm of the number.

This is a convenience method that computes self.ln() / LN_2, no additional accuracy is provided.

Examples

let a = TwoFloat::from(64.0).log2();

assert!((a - 6.0).abs() < 1e-12, "{}", a);

pub fn log10(&self) -> TwoFloat

Returns the base 10 logarithm of the number.

This is a convenience method that computes self.ln() / LN_10, no additional accuracy is provided.

Examples

let a = TwoFloat::from(100.0).log10();

assert!((a - 2.0).abs() < 1e-12);

impl TwoFloat

pub fn fract(&self) -> TwoFloat

Returns the fractional part of the number.

Examples

let a = TwoFloat::new_add(1.0, 1e-200).fract();
let b = TwoFloat::new_add(-1.0, 1e-200).fract();

assert_eq!(a, TwoFloat::from(1e-200));
assert_eq!(b, TwoFloat::new_add(-1.0, 1e-200));

pub fn trunc(&self) -> TwoFloat

Returns the integer part of the number.

Examples

let a = TwoFloat::new_add(1.0, 1e-200).trunc();
let b = TwoFloat::new_add(1.0, -1e-200).trunc();

assert_eq!(a, TwoFloat::from(1.0));
assert_eq!(b, TwoFloat::from(0.0));

pub fn ceil(&self) -> TwoFloat

Returns the smallest integer greater than or equal to the number.

Examples

let a = TwoFloat::new_add(1.0, 1e-200).ceil();
let b = TwoFloat::new_add(1.0, -1e-200).ceil();
let c = TwoFloat::new_add(-1.0, 1e-200).ceil();

assert_eq!(a, TwoFloat::from(2.0));
assert_eq!(b, TwoFloat::from(1.0));
assert_eq!(c, TwoFloat::from(0.0));

pub fn floor(&self) -> TwoFloat

Returns the smallest integer less than or equal to the number.

Examples

let a = TwoFloat::new_add(1.0, 1e-200).floor();
let b = TwoFloat::new_add(1.0, -1e-200).floor();
let c = TwoFloat::new_add(-1.0, 1e-200).floor();

assert_eq!(a, TwoFloat::from(1.0));
assert_eq!(b, TwoFloat::from(0.0));
assert_eq!(c, TwoFloat::from(-1.0));

impl TwoFloat

pub fn recip(&self) -> TwoFloat

Takes the reciprocal (inverse) of the number, 1/x.

Examples

let a = TwoFloat::new_add(67.2, 5.7e-53);
let b = a.recip();
let difference = b.recip() - a;

assert!(difference.abs() < 1e-16);

pub fn sqrt(&self) -> TwoFloat

Returns the square root of the number, using equation 4 from Karp & Markstein (1997).

Examples

let a = TwoFloat::from(2.0);
let b = a.sqrt();

assert!(b * b - a < 1e-16);

pub fn cbrt(&self) -> TwoFloat

Returns the cube root of the number, using Newton-Raphson iteration.

Examples

let a = TwoFloat::new_add(1.4e53, 0.21515);
let b = a.cbrt();

assert!(b.powi(3) - a < 1e-16);

pub fn powi(&self, n: i32) -> TwoFloat

Raises the number to an integer power. Returns a NAN value for 0^0.

Examples

let a = TwoFloat::from(2.0).powi(3);
let b = TwoFloat::from(0.0).powi(0);

assert!(a - TwoFloat::from(8.0) <= 1e-16);
assert!(!b.is_valid());

pub fn powf(&self, y: &TwoFloat) -> TwoFloat

Returns the value raised to the power y.

This method is quite inaccurate, where possible powi, sqrt or cbrt should be preferred.

Examples

let a = TwoFloat::from(-5.0);
let b = TwoFloat::from(3.0);
let c = a.powf(&b);

assert!((c + 125.0).abs() < 1e-9, "{}", c);

impl TwoFloat

pub fn abs(&self) -> TwoFloat

Returns the absolute value root of self.

Examples

let a = TwoFloat::new_add(1.0, 1.0e-300).abs();
let b = TwoFloat::new_add(-1.0, 1.0e-300).abs();

assert_eq!(a, TwoFloat::new_add(1.0, 1.0e-300));
assert_eq!(b, TwoFloat::new_add(1.0, -1.0e-300));

pub fn is_sign_positive(&self) -> bool

Returns true if self has a positive sign, including +0.0.

Examples

let a = TwoFloat::new_add(0.0, 0.0).is_sign_positive();
let b = TwoFloat::new_add(1.0, 1.0e-300).is_sign_positive();
let c = TwoFloat::new_add(-1.0, 1.0e-300).is_sign_positive();

assert!(a);
assert!(b);
assert!(!c);

pub fn is_sign_negative(&self) -> bool

Returns true if self has a negative sign, including -0.0.

Examples

let a = TwoFloat::new_add(-1.0, 1.0e-300).is_sign_negative();
let b = TwoFloat::new_add(0.0, 0.0).is_sign_negative();
let c = TwoFloat::new_add(1.0, 1.0e-300).is_sign_negative();

assert!(a);
assert!(!b);
assert!(!c);

Trait Implementations

impl<'a> Add<&'a TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the + operator.

fn add(self, lhs: &'a TwoFloat) -> Self::Output

Implements addition of TwoFloat and f64 using Joldes et al. (2017) Algorithm 4.

impl<'a> Add<&'a TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the + operator.

fn add(self, rhs: &'a TwoFloat) -> Self::Output

Implements addition of two TwoFloat values using Joldes et al. (2017) Algorithm 6.

impl<'a, 'b> Add<&'b TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the + operator.

fn add(self, rhs: &'b TwoFloat) -> Self::Output

Implements addition of two TwoFloat values using Joldes et al. (2017) Algorithm 6.

impl Add<TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the + operator.

fn add(self, lhs: TwoFloat) -> Self::Output

Implements addition of TwoFloat and f64 using Joldes et al. (2017) Algorithm 4.

impl Add<TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the + operator.

fn add(self, rhs: TwoFloat) -> Self::Output

Implements addition of two TwoFloat values using Joldes et al. (2017) Algorithm 6.

impl<'a> Add<TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the + operator.

fn add(self, rhs: TwoFloat) -> Self::Output

Implements addition of two TwoFloat values using Joldes et al. (2017) Algorithm 6.

impl Add<f64> for TwoFloat

type Output = TwoFloat

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Implements addition of TwoFloat and f64 using Joldes et al. (2017) Algorithm 4.

impl<'a> Add<f64> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Self::Output

Implements addition of TwoFloat and f64 using Joldes et al. (2017) Algorithm 4.

impl<'a> AddAssign<&'a TwoFloat> for TwoFloat

fn add_assign(&mut self, rhs: &'a TwoFloat)

Implements addition of two TwoFloat values using Joldes et al. (2017) Algorithm 6.

impl AddAssign<TwoFloat> for TwoFloat

fn add_assign(&mut self, rhs: TwoFloat)

Implements addition of two TwoFloat values using Joldes et al. (2017) Algorithm 6.

impl AddAssign<f64> for TwoFloat

fn add_assign(&mut self, rhs: f64)

Implements addition of TwoFloat and f64 using Joldes et al. (2017) Algorithm 4.

impl Clone for TwoFloat

fn clone(&self) -> TwoFloat

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for TwoFloat

impl Debug for TwoFloat

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

Formats the value using the given formatter.

impl Display for TwoFloat

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

Formats the value using the given formatter.

impl<'a> Div<&'a TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the / operator.

fn div(self, rhs: &'a TwoFloat) -> Self::Output

Implements division of f64 and TwoFloat using Joldes et al. (2017) Algorithm 18 modified for the left-hand side having a zero value in the low word.

impl<'a> Div<&'a TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the / operator.

fn div(self, rhs: &'a TwoFloat) -> Self::Output

Implements division of two TwoFloat values using Joldes et al. (2017) Algorithm 18.

impl<'a, 'b> Div<&'b TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the / operator.

fn div(self, rhs: &'b TwoFloat) -> Self::Output

Implements division of two TwoFloat values using Joldes et al. (2017) Algorithm 18.

impl Div<TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the / operator.

fn div(self, rhs: TwoFloat) -> Self::Output

Implements division of f64 and TwoFloat using Joldes et al. (2017) Algorithm 18 modified for the left-hand side having a zero value in the low word.

impl Div<TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the / operator.

fn div(self, rhs: TwoFloat) -> Self::Output

Implements division of two TwoFloat values using Joldes et al. (2017) Algorithm 18.

impl<'a> Div<TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the / operator.

fn div(self, rhs: TwoFloat) -> Self::Output

Implements division of two TwoFloat values using Joldes et al. (2017) Algorithm 18.

impl Div<f64> for TwoFloat

type Output = TwoFloat

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Implements division of TwoFloat and f64 using Joldes et al. (2017) Algorithm 15

impl<'a> Div<f64> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Self::Output

Implements division of TwoFloat and f64 using Joldes et al. (2017) Algorithm 15

impl<'a> DivAssign<&'a TwoFloat> for TwoFloat

fn div_assign(&mut self, rhs: &'a TwoFloat)

Implements division of two TwoFloat values using Joldes et al. (2017) Algorithm 18.

impl DivAssign<TwoFloat> for TwoFloat

fn div_assign(&mut self, rhs: TwoFloat)

Implements division of two TwoFloat values using Joldes et al. (2017) Algorithm 18.

impl DivAssign<f64> for TwoFloat

fn div_assign(&mut self, rhs: f64)

Implements division of TwoFloat and f64 using Joldes et al. (2017) Algorithm 15

impl<'a> From<&'a TwoFloat> for f64

fn from(value: &'a TwoFloat) -> Self

Performs the conversion.

impl<'a> From<&'a TwoFloat> for f32

fn from(value: &'a TwoFloat) -> Self

Performs the conversion.

impl From<TwoFloat> for f64

fn from(value: TwoFloat) -> Self

Performs the conversion.

impl From<TwoFloat> for f32

fn from(value: TwoFloat) -> Self

Performs the conversion.

impl From<f32> for TwoFloat

fn from(value: f32) -> Self

Performs the conversion.

impl From<f64> for TwoFloat

fn from(value: f64) -> Self

Performs the conversion.

impl From<i16> for TwoFloat

fn from(value: i16) -> Self

Performs the conversion.

impl From<i32> for TwoFloat

fn from(value: i32) -> Self

Performs the conversion.

impl From<i64> for TwoFloat

fn from(value: i64) -> Self

Performs the conversion.

impl From<i8> for TwoFloat

fn from(value: i8) -> Self

Performs the conversion.

impl From<u16> for TwoFloat

fn from(value: u16) -> Self

Performs the conversion.

impl From<u32> for TwoFloat

fn from(value: u32) -> Self

Performs the conversion.

impl From<u64> for TwoFloat

fn from(value: u64) -> Self

Performs the conversion.

impl From<u8> for TwoFloat

fn from(value: u8) -> Self

Performs the conversion.

impl<'a> Mul<&'a TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the * operator.

fn mul(self, lhs: &'a TwoFloat) -> Self::Output

Implements multiplication of TwoFloat and f64 using Joldes et al. (2017) Algorithm 9.

impl<'a> Mul<&'a TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the * operator.

fn mul(self, rhs: &'a TwoFloat) -> Self::Output

Implements multiplication of two TwoFloat values using Joldes et al. (2017) Algorithm 12.

impl<'a, 'b> Mul<&'b TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the * operator.

fn mul(self, rhs: &'b TwoFloat) -> Self::Output

Implements multiplication of two TwoFloat values using Joldes et al. (2017) Algorithm 12.

impl Mul<TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the * operator.

fn mul(self, lhs: TwoFloat) -> Self::Output

Implements multiplication of TwoFloat and f64 using Joldes et al. (2017) Algorithm 9.

impl Mul<TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the * operator.

fn mul(self, rhs: TwoFloat) -> Self::Output

Implements multiplication of two TwoFloat values using Joldes et al. (2017) Algorithm 12.

impl<'a> Mul<TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the * operator.

fn mul(self, rhs: TwoFloat) -> Self::Output

Implements multiplication of two TwoFloat values using Joldes et al. (2017) Algorithm 12.

impl Mul<f64> for TwoFloat

type Output = TwoFloat

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Implements multiplication of TwoFloat and f64 using Joldes et al. (2017) Algorithm 9.

impl<'a> Mul<f64> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Self::Output

Implements multiplication of TwoFloat and f64 using Joldes et al. (2017) Algorithm 9.

impl<'a> MulAssign<&'a TwoFloat> for TwoFloat

fn mul_assign(&mut self, rhs: &'a TwoFloat)

Implements multiplication of two TwoFloat values using Joldes et al. (2017) Algorithm 12.

impl MulAssign<TwoFloat> for TwoFloat

fn mul_assign(&mut self, rhs: TwoFloat)

Implements multiplication of two TwoFloat values using Joldes et al. (2017) Algorithm 12.

impl MulAssign<f64> for TwoFloat

fn mul_assign(&mut self, rhs: f64)

Implements multiplication of TwoFloat and f64 using Joldes et al. (2017) Algorithm 9.

impl Neg for TwoFloat

type Output = TwoFloat

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Returns a new TwoFloat with the negated value of self.

impl<'a> Neg for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Returns a new TwoFloat with the negated value of self.

impl PartialEq<TwoFloat> for TwoFloat

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

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

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

This method tests for !=.

impl PartialEq<TwoFloat> for f64

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialEq<f64> for TwoFloat

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

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

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl PartialOrd<TwoFloat> for TwoFloat

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

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

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

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

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

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

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

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

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

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

impl PartialOrd<TwoFloat> for f64

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

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

#[must_use]fn lt(&self, other: &Rhs) -> bool

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

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

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

#[must_use]fn ge(&self, other: &Rhs) -> bool

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

impl PartialOrd<f64> for TwoFloat

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

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

#[must_use]fn lt(&self, other: &Rhs) -> bool

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

#[must_use]fn le(&self, other: &Rhs) -> bool

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

#[must_use]fn gt(&self, other: &Rhs) -> bool

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

#[must_use]fn ge(&self, other: &Rhs) -> bool

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

impl<'a> Rem<&'a TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the % operator.

fn rem(self, rhs: &'a TwoFloat) -> Self::Output

Performs the % operation.

impl<'a> Rem<&'a TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the % operator.

fn rem(self, rhs: &'a TwoFloat) -> Self::Output

Performs the % operation.

impl<'a, 'b> Rem<&'b TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the % operator.

fn rem(self, rhs: &'b TwoFloat) -> Self::Output

Performs the % operation.

impl Rem<TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the % operator.

fn rem(self, rhs: TwoFloat) -> Self::Output

Performs the % operation.

impl Rem<TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the % operator.

fn rem(self, rhs: TwoFloat) -> Self::Output

Performs the % operation.

impl<'a> Rem<TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the % operator.

fn rem(self, rhs: TwoFloat) -> Self::Output

Performs the % operation.

impl Rem<f64> for TwoFloat

type Output = TwoFloat

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Self::Output

Performs the % operation.

impl<'a> Rem<f64> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Self::Output

Performs the % operation.

impl<'a> RemAssign<&'a TwoFloat> for TwoFloat

fn rem_assign(&mut self, rhs: &'a TwoFloat)

Performs the %= operation.

impl RemAssign<TwoFloat> for TwoFloat

fn rem_assign(&mut self, rhs: TwoFloat)

Performs the %= operation.

impl RemAssign<f64> for TwoFloat

fn rem_assign(&mut self, rhs: f64)

Performs the %= operation.

impl StructuralPartialEq for TwoFloat

impl<'a> Sub<&'a TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the - operator.

fn sub(self, rhs: &'a TwoFloat) -> Self::Output

Implements subtraction of f64 and TwoFloat using Joldes et al. (2017) Algorithm 4 modified for negative left-hand side.

impl<'a> Sub<&'a TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the - operator.

fn sub(self, rhs: &'a TwoFloat) -> Self::Output

Implements subtraction of two TwoFloat values using Joldes et al. (2017) Algorithm 6 modified for a negative right-hand side.

impl<'a, 'b> Sub<&'b TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the - operator.

fn sub(self, rhs: &'b TwoFloat) -> Self::Output

Implements subtraction of two TwoFloat values using Joldes et al. (2017) Algorithm 6 modified for a negative right-hand side.

impl Sub<TwoFloat> for f64

type Output = TwoFloat

The resulting type after applying the - operator.

fn sub(self, rhs: TwoFloat) -> Self::Output

Implements subtraction of f64 and TwoFloat using Joldes et al. (2017) Algorithm 4 modified for negative left-hand side.

impl Sub<TwoFloat> for TwoFloat

type Output = TwoFloat

The resulting type after applying the - operator.

fn sub(self, rhs: TwoFloat) -> Self::Output

Implements subtraction of two TwoFloat values using Joldes et al. (2017) Algorithm 6 modified for a negative right-hand side.

impl<'a> Sub<TwoFloat> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the - operator.

fn sub(self, rhs: TwoFloat) -> Self::Output

Implements subtraction of two TwoFloat values using Joldes et al. (2017) Algorithm 6 modified for a negative right-hand side.

impl Sub<f64> for TwoFloat

type Output = TwoFloat

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Implements subtraction of TwoFloat and f64 using Joldes et al. (2017) Algorithm 4 modified for negative right-hand side.

impl<'a> Sub<f64> for &'a TwoFloat

type Output = TwoFloat

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Self::Output

Implements subtraction of TwoFloat and f64 using Joldes et al. (2017) Algorithm 4 modified for negative right-hand side.

impl<'a> SubAssign<&'a TwoFloat> for TwoFloat

fn sub_assign(&mut self, rhs: &'a TwoFloat)

Implements subtraction of two TwoFloat values using Joldes et al. (2017) Algorithm 6 modified for a negative right-hand side.

impl SubAssign<TwoFloat> for TwoFloat

fn sub_assign(&mut self, rhs: TwoFloat)

Implements subtraction of two TwoFloat values using Joldes et al. (2017) Algorithm 6 modified for a negative right-hand side.

impl SubAssign<f64> for TwoFloat

fn sub_assign(&mut self, rhs: f64)

Implements subtraction of TwoFloat and f64 using Joldes et al. (2017) Algorithm 4 modified for negative right-hand side.

impl<'a> TryFrom<&'a TwoFloat> for i32

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'a TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a TwoFloat> for i16

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'a TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a TwoFloat> for i8

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'a TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a TwoFloat> for u32

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'a TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a TwoFloat> for u16

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'a TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a TwoFloat> for u8

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'a TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a TwoFloat> for i64

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'a TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl<'a> TryFrom<&'a TwoFloat> for u64

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'a TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TwoFloat> for i32

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TwoFloat> for i16

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TwoFloat> for i8

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TwoFloat> for u32

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TwoFloat> for u16

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TwoFloat> for u8

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TwoFloat> for i64

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<TwoFloat> for u64

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: TwoFloat) -> Result<Self, Self::Error>

Performs the conversion.