Struct fi128 

pub struct fi128(pub i128);

Signed Fractional Integer of the unit range.

Note: in the future we want to make the inner type private, but not currently because we don’t have stable const traits.

Tuple Fields

0: i128

Trait Implementations

impl Add for fi128

type Output = fi128

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign for fi128

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl BitAnd for fi128

type Output = fi128

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self

Performs the & operation.

impl BitAndAssign for fi128

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr for fi128

type Output = fi128

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self

Performs the | operation.

impl BitOrAssign for fi128

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl BitXor for fi128

type Output = fi128

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Self) -> Self

Performs the ^ operation.

impl BitXorAssign for fi128

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

impl Clone for fi128

fn clone(&self) -> fi128

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for fi128

impl Debug for fi128

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

Converts to a base 10 string representation

fiN::ONE and fiN::NEG_ONE are special cased to “1.0” and “-1.0” respectively.

impl Default for fi128

fn default() -> fi128

Returns the “default value” for a type.

impl Display for fi128

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

Converts to a base 10 string representation

fiN::ONE and fiN::NEG_ONE are special cased to “1.0” and “-1.0” respectively.

impl Div for fi128

type Output = fi128

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<i128> for fi128

type Output = fi128

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivAssign for fi128

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl DivAssign<i128> for fi128

fn div_assign(&mut self, rhs: i128)

Performs the /= operation.

impl Eq for fi128

impl Fracint for fi128

const BITS: usize

The number of bits in this type

const MAX: Self

The maximum value representable by Self

const MIN: Self

The minimum value representable by Self

const NEG_ONE: Self

A numerical value of negative one.

const ONE: Self

For fiN, ONE and MAX are the same. Prefer to use MAX when wanting to emphasize the true numeric bounds or ordered maximum, and instead use ONE for numeric values.

const SIGNED: bool = true

If this type is signed

const ULP: Self

One positive Unit in the Last Place

const ZERO: Self

Zero.

type Int = i128

This is only for workarounds, to make this better we would need a refined trait for normal integers.

fn from_int(x: Self::Int) -> Self

Casts from the Self::Int type

fn as_int(self) -> Self::Int

Casts to the Self::Int type

fn overflowing_abs(self) -> (Self, bool)

Returns a tuple of self.wrapping_abs() along with a boolean indicating whether an overflow happened.

fn wrapping_neg(self) -> Self

Wrapping negation of self.

fn overflowing_neg(self) -> (Self, bool)

Returns a tuple of self.wrapping_neg() along with a boolean indicating whether an overflow happened.

fn saturating_neg(self) -> Self

Saturating negation of self. It behaves the same way as wrapping_neg except Self::MIN.saturating_neg() -> Self::ONE

fn saturating_inv(self) -> i128

Saturating inversion of self. It has the special cases

fn wrapping_add(self, rhs: Self) -> Self

Wrapping (modular) addition.

fn overflowing_add(self, rhs: Self) -> (Self, bool)

Returns a tuple of self.wrapping_add(rhs) along with a boolean indicating whether an overflow happened. Note that if self.wrapping_add(rhs) == fiN::MIN, it is counted as overflow.

fn saturating_add(self, rhs: Self) -> Self

Saturating addition. Saturates at the numeric bounds fiN::NEG_ONE and fiN::ONE instead of overflowing.

fn wrapping_sub(self, rhs: Self) -> Self

Wrapping (modular) subtraction.

fn overflowing_sub(self, rhs: Self) -> (Self, bool)

Returns a tuple of self.wrapping_sub(rhs) along with a boolean indicating whether an overflow happened. Note that if self.wrapping_sub(rhs) == fiN::MIN, it is counted as overflow.

fn saturating_sub(self, rhs: Self) -> Self

Saturating subtraction. Saturates at the numeric bounds fiN::NEG_ONE and fiN::ONE instead of overflowing.

fn wrapping_mul(self, rhs: Self) -> Self

Wrapping fracint multiplication.

fn overflowing_mul(self, rhs: Self) -> (Self, bool)

Returns a tuple of self.wrapping_mul(rhs) along with a boolean indicating whether an overflow happened.

fn saturating_mul(self, rhs: Self) -> Self

Saturating fracint multiplication. Saturates at the numeric bounds fiN::NEG_ONE and fiN::ONE instead of overflowing.

fn saturating_mul_int(self, rhs: i128) -> Self

Saturating fracint multiplication with an integer. Saturates at the numeric bounds fiN::NEG_ONE and fiN::ONE instead of overflowing.

fn saturating_div(self, rhs: Self) -> Self

Saturating fracint division. Saturates at the numeric bounds fiN::NEG_ONE and fiN::ONE instead of overflowing.

fn saturating_div_int(self, rhs: Self::Int) -> Self

Saturating fracint division with an integer. Saturates at the numeric bounds fiN::NEG_ONE and fiN::ONE instead of overflowing.

fn sqrt_fast(self) -> Self

Fast way of calculating the square root to within a few ULPs of the true value.

fn from_f32(f: f32) -> Option<Self>

Converts from an f32 to Self. Returns None if the absolute value is greater than 1.0.

fn from_f64(f: f64) -> Option<Self>

Converts from an f64 to Self. Returns None if the absolute value is greater than 1.0.

fn to_f32(self) -> f32

Converts to an f32

fn to_f64(self) -> f64

Converts to an f64

fn is_zero(self) -> bool

fn is_negative(self) -> bool

fn is_positive(self) -> bool

fn signum(self) -> Self

Returns a value representing the sign of self.

fn wrapping_abs(self) -> Self

Wrapping absolute value of self.

fn checked_abs(self) -> Option<Self>

Same as overflowing_abs except it returns None on overflow

fn saturating_abs(self) -> Self

Saturating absolute value of self. It behaves the same way as wrapping_abs except Self::MIN.saturating_abs() -> Self::ONE

fn checked_neg(self) -> Option<Self>

Same as overflowing_neg except it returns None on overflow

fn checked_add(self, rhs: Self) -> Option<Self>

Same as overflowing_add except it returns None on overflow

fn checked_sub(self, rhs: Self) -> Option<Self>

Same as overflowing_sub except it returns None on overflow

fn checked_mul(self, rhs: Self) -> Option<Self>

Same as overflowing_mul except it returns None on overflow

fn sqrt_simple_bisection(self) -> Self

Slow way of calculating the truncated square root using bisection. This will always underestimate the square root, with about as much bit error as the number of leading zero bits.

impl FracintHalf for fi128

type Half = fi64

The half-sized version of Self

fn split(self) -> (fi64, fi64)

Returns half sized low and high parts. The high part is effectively a truncated version of self, and the low part is the remainder.

fn truncate(self) -> fi64

Truncates self down to a half sized type with the same value except with less than 1 ULP of error.

impl From<fi64> for fi128

fn from(x: fi64) -> Self

Lossless conversion

impl FromStr for fi128

fn from_str(s: &str) -> Result<Self, Self::Err>

Conversion from a string representation.

The input can start with a ‘-’ to make the output negative. Then it can optionally start with a “0b”, “0o”, or a “0x” prefix to use radix 2, 8, or 16 respectively, otherwise it is parsed as radix 10. There must be an integer part with digits in the correct radix. If including the fraction, a ‘.’ followed by one more digits in the correct radix should be added. Finally, an exponent can be added by ‘e’ or ‘p’ (except radix 16 which must use ‘p’) and then a number in the same radix is used. The exponent is applied as * radix^exponent before round-to-even. ’_’s can be used throughout the integer, fraction, and exponent parts as long as one term is not all underspaces.

s can be arbitrarily long but significance changes stops after a number of chars.

The number must be in the range (-1.0,1.0) or else an overflow error is returned. 1.0 is special cased to map to fiN::ONE' even though it is not exactly representable, and -1.0 is special cased to map to fiN::NEG_ONEto avoid introducingfiN::MIN`.

See the [FracintParseError] documentation for parsing errors and examples.

type Err = FracintSerdeError

The associated error which can be returned from parsing.

impl Hash for fi128

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Mul for fi128

type Output = fi128

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<i128> for fi128

type Output = fi128

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulAssign for fi128

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl MulAssign<i128> for fi128

fn mul_assign(&mut self, rhs: i128)

Performs the *= operation.

impl Neg for fi128

type Output = fi128

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl Not for fi128

type Output = fi128

The resulting type after applying the ! operator.

fn not(self) -> Self

Performs the unary ! operation.

impl Ord for fi128

fn cmp(&self, other: &fi128) -> 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,

Restrict a value to a certain interval.

impl PartialEq for fi128

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for fi128

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl Product for fi128

fn product<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a> Product<&'a fi128> for fi128

fn product<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl Shl<usize> for fi128

type Output = fi128

The resulting type after applying the << operator.

fn shl(self, rhs: usize) -> Self

Performs the << operation.

impl ShlAssign<usize> for fi128

fn shl_assign(&mut self, rhs: usize)

Performs the <<= operation.

impl Shr<usize> for fi128

type Output = fi128

The resulting type after applying the >> operator.

fn shr(self, rhs: usize) -> Self

Performs the >> operation.

impl ShrAssign<usize> for fi128

fn shr_assign(&mut self, rhs: usize)

Performs the >>= operation.

impl StructuralPartialEq for fi128

impl Sub for fi128

type Output = fi128

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubAssign for fi128

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl Sum for fi128

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.

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

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = &'a Self>,

Takes an iterator and generates Self from the elements by “summing up” the items.