Struct dashu::rational::Relaxed

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

An arbitrary precision rational number without strict reduction.

This struct is almost the same as RBig, except for that the numerator and the denominator are allowed to have common divisors other than a power of 2. This allows faster computation because Gcd is not required for each operation.

Since the representation is not canonicalized, Hash is not implemented for Relaxed. Please use RBig if you want to store the rational number in a hash set, or use num_order::NumHash.

Conversion from/to RBig

To convert from RBig, use RBig::relax(). To convert to RBig, use Relaxed::canonicalize().

Implementations

impl Relaxed

pub fn to_f32_fast(&self) -> f32

Convert the rational number to a f32.

See RBig::to_f32_fast for details.

pub fn to_f64_fast(&self) -> f64

Convert the rational number to a f64.

See RBig::to_f64_fast for details.

pub fn to_f32(&self) -> Approximation<f32, Sign>

Convert the rational number to a f32 with guaranteed correct rounding.

See RBig::to_f32 for details.

pub fn to_f64(&self) -> Approximation<f64, Sign>

Convert the rational number to a f64 with guaranteed correct rounding.

See RBig::to_f64 for details.

pub fn to_int(&self) -> Approximation<IBig, Relaxed>

Convert the rational number to am IBig.

See RBig::to_int for details.

impl Relaxed

pub fn sqr(&self) -> Relaxed

Compute the square of the number (self * self).

See RBig::sqr for details.

pub fn cubic(&self) -> Relaxed

Compute the cubic of the number (self * self * self).

See RBig::cubic for details.

pub fn pow(&self, n: usize) -> Relaxed

Raise this number to a power of n.

See RBig::pow for details.

impl Relaxed

pub fn from_str_radix(src: &str, radix: u32) -> Result<Relaxed, ParseError>

Convert a string in a given base to Relaxed.

See RBig::from_str_radix for details.

pub fn from_str_with_radix_prefix( src: &str, ) -> Result<(Relaxed, u32), ParseError>

Convert a string with optional radix prefixes to RBig, return the parsed integer and radix.

See RBig::from_str_with_radix_prefix for details.

impl Relaxed

pub const ZERO: Relaxed = _

Relaxed with value 0

pub const ONE: Relaxed = _

Relaxed with value 1

pub const NEG_ONE: Relaxed = _

Relaxed with value -1

pub fn from_parts(numerator: IBig, denominator: UBig) -> Relaxed

Create a rational number from a signed numerator and a signed denominator

See RBig::from_parts for details.

pub fn into_parts(self) -> (IBig, UBig)

Convert the rational number into (numerator, denumerator) parts.

See RBig::into_parts for details.

pub fn from_parts_signed(numerator: IBig, denominator: IBig) -> Relaxed

Create a rational number from a signed numerator and a signed denominator

See RBig::from_parts_signed for details.

pub const fn from_parts_const( sign: Sign, numerator: u128, denominator: u128, ) -> Relaxed

Create a rational number in a const context

See RBig::from_parts_const for details.

pub fn numerator(&self) -> &IBig

Get the numerator of the rational number

See RBig::numerator for details.

pub fn denominator(&self) -> &UBig

Get the denominator of the rational number

See RBig::denominator for details.

pub fn canonicalize(self) -> RBig

Convert this rational number into an RBig version

Examples

assert_eq!(Relaxed::ONE.canonicalize(), RBig::ONE);

let r = Relaxed::from_parts(10.into(), 5u8.into());
assert_eq!(r.canonicalize().numerator(), &IBig::from(2));

pub const fn is_zero(&self) -> bool

Check whether the number is 0

See RBig::is_zero for details.

pub fn is_one(&self) -> bool

Check whether the number is 1

See RBig::is_one for details.

impl Relaxed

pub fn split_at_point(self) -> (IBig, Relaxed)

Split the rational number into integral and fractional parts (split at the radix point).

See RBig::split_at_point for details.

pub fn ceil(&self) -> IBig

Compute the smallest integer that is greater than this number.

See RBig::ceil for details.

pub fn floor(&self) -> IBig

Compute the largest integer that is less than or equal to this number.

See RBig::floor for details.

pub fn round(&self) -> IBig

Compute the integer that closest to this number.

See RBig::round for details.

pub fn trunc(&self) -> IBig

Returns the integral part of the rational number.

See RBig::trunc for details.

pub fn fract(&self) -> Relaxed

Returns the fractional part of the rational number

See RBig::fract for details.

impl Relaxed

pub const fn sign(&self) -> Sign

Get the sign of the number. Zero value has a positive sign.

See RBig::sign for details.

pub const fn signum(&self) -> Relaxed

A number representing the sign of self.

See RBig::signum for details.

impl Relaxed

pub fn to_float<R, const B: u64>( &self, precision: usize, ) -> Approximation<FBig<R, B>, Rounding>

where R: Round,

Convert the rational number to a FBig with guaranteed correct rounding.

See RBig::to_float for details.

Trait Implementations

impl Abs for Relaxed

type Output = Relaxed

fn abs(self) -> <Relaxed as Abs>::Output

impl AbsEq for Relaxed

fn abs_eq(&self, other: &Relaxed) -> bool

👎Deprecated since 0.5.0: AbsEq will be moved in AbsOrd in v0.5

impl<R, const B: u64> AbsOrd<FBig<R, B>> for Relaxed

where R: Round,

fn abs_cmp(&self, other: &FBig<R, B>) -> Ordering

impl AbsOrd<IBig> for Relaxed

fn abs_cmp(&self, other: &IBig) -> Ordering

impl AbsOrd<RBig> for Relaxed

fn abs_cmp(&self, other: &RBig) -> Ordering

impl<R, const B: u64> AbsOrd<Relaxed> for FBig<R, B>

where R: Round,

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl AbsOrd<Relaxed> for IBig

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl AbsOrd<Relaxed> for RBig

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl AbsOrd<Relaxed> for UBig

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl AbsOrd<UBig> for Relaxed

fn abs_cmp(&self, other: &UBig) -> Ordering

impl AbsOrd for Relaxed

fn abs_cmp(&self, other: &Relaxed) -> Ordering

impl<'l, 'r> Add<&'r IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> Relaxed

Performs the + operation.

impl<'r> Add<&'r IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &IBig) -> Relaxed

Performs the + operation.

impl<'l, 'r> Add<&'r Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &Relaxed) -> Relaxed

Performs the + operation.

impl<'l, 'r> Add<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &Relaxed) -> Relaxed

Performs the + operation.

impl<'l, 'r> Add<&'r Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &Relaxed) -> Relaxed

Performs the + operation.

impl<'r> Add<&'r Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &Relaxed) -> Relaxed

Performs the + operation.

impl<'r> Add<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &Relaxed) -> Relaxed

Performs the + operation.

impl<'r> Add<&'r Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &Relaxed) -> Relaxed

Performs the + operation.

impl<'l, 'r> Add<&'r UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> Relaxed

Performs the + operation.

impl<'r> Add<&'r UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: &UBig) -> Relaxed

Performs the + operation.

impl<'l> Add<IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: IBig) -> Relaxed

Performs the + operation.

impl Add<IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: IBig) -> Relaxed

Performs the + operation.

impl<'l> Add<Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'l> Add<UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> Relaxed

Performs the + operation.

impl Add<UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

fn add(self, rhs: UBig) -> Relaxed

Performs the + operation.

impl Add for Relaxed

type Output = Relaxed

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<&Relaxed> for Relaxed

fn add_assign(&mut self, rhs: &Relaxed)

Performs the += operation.

impl AddAssign for Relaxed

fn add_assign(&mut self, rhs: Relaxed)

Performs the += operation.

impl Clone for Relaxed

fn clone(&self) -> Relaxed

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Relaxed

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

Formats the value using the given formatter.

impl Default for Relaxed

fn default() -> Relaxed

Returns the “default value” for a type.

impl Display for Relaxed

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

Formats the value using the given formatter.

impl<'l, 'r> Div<&'r IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> Relaxed

Performs the / operation.

impl<'r> Div<&'r IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &IBig) -> Relaxed

Performs the / operation.

impl<'l, 'r> Div<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &Relaxed) -> Relaxed

Performs the / operation.

impl<'r> Div<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &Relaxed) -> Relaxed

Performs the / operation.

impl<'l, 'r> Div<&'r UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> Relaxed

Performs the / operation.

impl<'r> Div<&'r UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: &UBig) -> Relaxed

Performs the / operation.

impl<'l> Div<IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: IBig) -> Relaxed

Performs the / operation.

impl Div<IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: IBig) -> Relaxed

Performs the / operation.

impl<'l> Div<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: Relaxed) -> Relaxed

Performs the / operation.

impl<'l> Div<UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> Relaxed

Performs the / operation.

impl Div<UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: UBig) -> Relaxed

Performs the / operation.

impl Div for Relaxed

type Output = Relaxed

The resulting type after applying the / operator.

fn div(self, rhs: Relaxed) -> Relaxed

Performs the / operation.

impl DivAssign<&Relaxed> for Relaxed

fn div_assign(&mut self, rhs: &Relaxed)

Performs the /= operation.

impl DivAssign for Relaxed

fn div_assign(&mut self, rhs: Relaxed)

Performs the /= operation.

impl<'l, 'r> DivEuclid<&'r Relaxed> for &'l Relaxed

type Output = IBig

fn div_euclid(self, rhs: &Relaxed) -> IBig

impl<'r> DivEuclid<&'r Relaxed> for Relaxed

type Output = IBig

fn div_euclid(self, rhs: &Relaxed) -> IBig

impl<'l> DivEuclid<Relaxed> for &'l Relaxed

type Output = IBig

fn div_euclid(self, rhs: Relaxed) -> IBig

impl DivEuclid for Relaxed

type Output = IBig

fn div_euclid(self, rhs: Relaxed) -> IBig

impl<'l, 'r> DivRemEuclid<&'r Relaxed> for &'l Relaxed

type OutputDiv = IBig

type OutputRem = Relaxed

fn div_rem_euclid(self, rhs: &Relaxed) -> (IBig, Relaxed)

impl<'r> DivRemEuclid<&'r Relaxed> for Relaxed

type OutputDiv = IBig

type OutputRem = Relaxed

fn div_rem_euclid(self, rhs: &Relaxed) -> (IBig, Relaxed)

impl<'l> DivRemEuclid<Relaxed> for &'l Relaxed

type OutputDiv = IBig

type OutputRem = Relaxed

fn div_rem_euclid(self, rhs: Relaxed) -> (IBig, Relaxed)

impl DivRemEuclid for Relaxed

type OutputDiv = IBig

type OutputRem = Relaxed

fn div_rem_euclid(self, rhs: Relaxed) -> (IBig, Relaxed)

impl EstimatedLog2 for Relaxed

fn log2_bounds(&self) -> (f32, f32)

Estimate the bounds of the binary logarithm.

fn log2_est(&self) -> f32

Estimate the value of the binary logarithm. It’s calculated as the average of log2_bounds by default.

impl From<IBig> for Relaxed

fn from(v: IBig) -> Relaxed

Converts to this type from the input type.

impl<R, const B: u64> From<Relaxed> for FBig<R, B>

where R: Round,

fn from(v: Relaxed) -> FBig<R, B>

Converts to this type from the input type.

impl From<UBig> for Relaxed

fn from(v: UBig) -> Relaxed

Converts to this type from the input type.

impl From<i128> for Relaxed

fn from(v: i128) -> Relaxed

Converts to this type from the input type.

impl From<i16> for Relaxed

fn from(v: i16) -> Relaxed

Converts to this type from the input type.

impl From<i32> for Relaxed

fn from(v: i32) -> Relaxed

Converts to this type from the input type.

impl From<i64> for Relaxed

fn from(v: i64) -> Relaxed

Converts to this type from the input type.

impl From<i8> for Relaxed

fn from(v: i8) -> Relaxed

Converts to this type from the input type.

impl From<isize> for Relaxed

fn from(v: isize) -> Relaxed

Converts to this type from the input type.

impl From<u128> for Relaxed

fn from(v: u128) -> Relaxed

Converts to this type from the input type.

impl From<u16> for Relaxed

fn from(v: u16) -> Relaxed

Converts to this type from the input type.

impl From<u32> for Relaxed

fn from(v: u32) -> Relaxed

Converts to this type from the input type.

impl From<u64> for Relaxed

fn from(v: u64) -> Relaxed

Converts to this type from the input type.

impl From<u8> for Relaxed

fn from(v: u8) -> Relaxed

Converts to this type from the input type.

impl From<usize> for Relaxed

fn from(v: usize) -> Relaxed

Converts to this type from the input type.

impl FromStr for Relaxed

type Err = ParseError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Relaxed, ParseError>

Parses a string s to return a value of this type.

impl Inverse for &Relaxed

type Output = Relaxed

fn inv(self) -> Relaxed

impl Inverse for Relaxed

type Output = Relaxed

fn inv(self) -> Relaxed

impl<'l, 'r> Mul<&'r IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Relaxed

Performs the * operation.

impl<'r> Mul<&'r IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &IBig) -> Relaxed

Performs the * operation.

impl<'l, 'r> Mul<&'r Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &Relaxed) -> Relaxed

Performs the * operation.

impl<'l, 'r> Mul<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &Relaxed) -> Relaxed

Performs the * operation.

impl<'l, 'r> Mul<&'r Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &Relaxed) -> Relaxed

Performs the * operation.

impl<'r> Mul<&'r Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &Relaxed) -> Relaxed

Performs the * operation.

impl<'r> Mul<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &Relaxed) -> Relaxed

Performs the * operation.

impl<'r> Mul<&'r Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &Relaxed) -> Relaxed

Performs the * operation.

impl<'l, 'r> Mul<&'r UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> Relaxed

Performs the * operation.

impl<'r> Mul<&'r UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: &UBig) -> Relaxed

Performs the * operation.

impl<'l> Mul<IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Relaxed

Performs the * operation.

impl Mul<IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: IBig) -> Relaxed

Performs the * operation.

impl<'l> Mul<Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'l> Mul<Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Sign> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: Sign) -> <Relaxed as Mul<Sign>>::Output

Performs the * operation.

impl<'l> Mul<UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> Relaxed

Performs the * operation.

impl Mul<UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

fn mul(self, rhs: UBig) -> Relaxed

Performs the * operation.

impl Mul for Relaxed

type Output = Relaxed

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign<&Relaxed> for Relaxed

fn mul_assign(&mut self, rhs: &Relaxed)

Performs the *= operation.

impl MulAssign for Relaxed

fn mul_assign(&mut self, rhs: Relaxed)

Performs the *= operation.

impl Neg for &Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn neg(self) -> <&Relaxed as Neg>::Output

Performs the unary - operation.

impl Neg for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn neg(self) -> <Relaxed as Neg>::Output

Performs the unary - operation.

impl NumHash for Relaxed

fn num_hash<H>(&self, state: &mut H)

where H: Hasher,

Consistent Hash::hash on different numeric types.

impl<R, const B: u64> NumOrd<FBig<R, B>> for Relaxed

where R: Round,

fn num_cmp(&self, other: &FBig<R, B>) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &FBig<R, B>) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<IBig> for Relaxed

fn num_cmp(&self, other: &IBig) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &IBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<RBig> for Relaxed

fn num_eq(&self, other: &RBig) -> bool

PartialEq::eq on different numeric types

fn num_partial_cmp(&self, other: &RBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_cmp(&self, other: &RBig) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl<R, const B: u64> NumOrd<Relaxed> for FBig<R, B>

where R: Round,

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for IBig

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for RBig

fn num_eq(&self, other: &Relaxed) -> bool

PartialEq::eq on different numeric types

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<Relaxed> for UBig

fn num_cmp(&self, other: &Relaxed) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &Relaxed) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<UBig> for Relaxed

fn num_cmp(&self, other: &UBig) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &UBig) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<f32> for Relaxed

fn num_cmp(&self, other: &f32) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &f32) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<f64> for Relaxed

fn num_cmp(&self, other: &f64) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

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

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i128> for Relaxed

fn num_cmp(&self, other: &i128) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i128) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i16> for Relaxed

fn num_cmp(&self, other: &i16) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i16) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i32> for Relaxed

fn num_cmp(&self, other: &i32) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i32) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i64> for Relaxed

fn num_cmp(&self, other: &i64) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i64) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<i8> for Relaxed

fn num_cmp(&self, other: &i8) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &i8) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<isize> for Relaxed

fn num_cmp(&self, other: &isize) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &isize) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u128> for Relaxed

fn num_cmp(&self, other: &u128) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u128) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u16> for Relaxed

fn num_cmp(&self, other: &u16) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u16) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u32> for Relaxed

fn num_cmp(&self, other: &u32) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u32) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u64> for Relaxed

fn num_cmp(&self, other: &u64) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u64) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<u8> for Relaxed

fn num_cmp(&self, other: &u8) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &u8) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl NumOrd<usize> for Relaxed

fn num_cmp(&self, other: &usize) -> Ordering

Ord::cmp on different numeric types. It panics if either of the numeric values contains NaN.

fn num_partial_cmp(&self, other: &usize) -> Option<Ordering>

PartialOrd::partial_cmp on different numeric types

fn num_eq(&self, other: &Other) -> bool

PartialEq::eq on different numeric types

fn num_ne(&self, other: &Other) -> bool

PartialEq::ne on different numeric types

fn num_lt(&self, other: &Other) -> bool

PartialOrd::lt on different numeric types

fn num_le(&self, other: &Other) -> bool

PartialOrd::le on different numeric types

fn num_gt(&self, other: &Other) -> bool

PartialOrd::gt on different numeric types

fn num_ge(&self, other: &Other) -> bool

PartialOrd::ge on different numeric types

impl Ord for Relaxed

fn cmp(&self, other: &Relaxed) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for Relaxed

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

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

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

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

impl PartialOrd for Relaxed

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

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

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

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

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

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

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

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

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<'l, 'r> Rem<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the % operator.

fn rem(self, rhs: &Relaxed) -> Relaxed

Performs the % operation.

impl<'r> Rem<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the % operator.

fn rem(self, rhs: &Relaxed) -> Relaxed

Performs the % operation.

impl<'l> Rem<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the % operator.

fn rem(self, rhs: Relaxed) -> Relaxed

Performs the % operation.

impl Rem for Relaxed

type Output = Relaxed

The resulting type after applying the % operator.

fn rem(self, rhs: Relaxed) -> Relaxed

Performs the % operation.

impl RemAssign<&Relaxed> for Relaxed

fn rem_assign(&mut self, rhs: &Relaxed)

Performs the %= operation.

impl RemAssign for Relaxed

fn rem_assign(&mut self, rhs: Relaxed)

Performs the %= operation.

impl<'l, 'r> RemEuclid<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

fn rem_euclid(self, rhs: &Relaxed) -> Relaxed

impl<'r> RemEuclid<&'r Relaxed> for Relaxed

type Output = Relaxed

fn rem_euclid(self, rhs: &Relaxed) -> Relaxed

impl<'l> RemEuclid<Relaxed> for &'l Relaxed

type Output = Relaxed

fn rem_euclid(self, rhs: Relaxed) -> Relaxed

impl RemEuclid for Relaxed

type Output = Relaxed

fn rem_euclid(self, rhs: Relaxed) -> Relaxed

impl Signed for Relaxed

fn sign(&self) -> Sign

fn is_positive(&self) -> bool

fn is_negative(&self) -> bool

impl<'l, 'r> Sub<&'r IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &IBig) -> Relaxed

Performs the - operation.

impl<'l, 'r> Sub<&'r Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'l, 'r> Sub<&'r Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'l, 'r> Sub<&'r Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r Relaxed> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &Relaxed) -> Relaxed

Performs the - operation.

impl<'l, 'r> Sub<&'r UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> Relaxed

Performs the - operation.

impl<'r> Sub<&'r UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: &UBig) -> Relaxed

Performs the - operation.

impl<'l> Sub<IBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Relaxed

Performs the - operation.

impl Sub<IBig> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: IBig) -> Relaxed

Performs the - operation.

impl<'l> Sub<Relaxed> for &'l IBig

type Output = Relaxed

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<Relaxed> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<Relaxed> for &'l UBig

type Output = Relaxed

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Relaxed> for IBig

type Output = Relaxed

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Relaxed> for UBig

type Output = Relaxed

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'l> Sub<UBig> for &'l Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> Relaxed

Performs the - operation.

impl Sub<UBig> for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

fn sub(self, rhs: UBig) -> Relaxed

Performs the - operation.

impl Sub for Relaxed

type Output = Relaxed

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign<&Relaxed> for Relaxed

fn sub_assign(&mut self, rhs: &Relaxed)

Performs the -= operation.

impl SubAssign for Relaxed

fn sub_assign(&mut self, rhs: Relaxed)

Performs the -= operation.

impl<R, const B: u64> TryFrom<FBig<R, B>> for Relaxed

where R: Round,

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from( value: FBig<R, B>, ) -> Result<Relaxed, <Relaxed as TryFrom<FBig<R, B>>>::Error>

Performs the conversion.

impl TryFrom<Relaxed> for IBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<IBig, <IBig as TryFrom<Relaxed>>::Error>

Performs the conversion.

impl TryFrom<Relaxed> for UBig

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: Relaxed) -> Result<UBig, <UBig as TryFrom<Relaxed>>::Error>

Performs the conversion.

impl<const B: u64> TryFrom<Repr<B>> for Relaxed

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from( value: Repr<B>, ) -> Result<Relaxed, <Relaxed as TryFrom<Repr<B>>>::Error>

Performs the conversion.

impl TryFrom<f32> for Relaxed

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: f32) -> Result<Relaxed, <Relaxed as TryFrom<f32>>::Error>

Performs the conversion.

impl TryFrom<f64> for Relaxed

type Error = ConversionError

The type returned in the event of a conversion error.

fn try_from(value: f64) -> Result<Relaxed, <Relaxed as TryFrom<f64>>::Error>

Performs the conversion.

impl Eq for Relaxed

impl StructuralPartialEq for Relaxed