Struct Float 

pub struct Float {
    pub val: Float,
}

Fields

val: Float

Implementations

impl Float

pub fn with_val<T>(prec: u32, val: T) -> Self

where Float: Assign<T>,

pub fn to_integer(&self) -> Option<Integer>

impl Float

pub fn to_rational(&self) -> Option<Rational>

Trait Implementations

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

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, B> Add<B> for &'a Float

where Float: Add<B, Output = Float>,

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl<B> Add<B> for Float

where Float: Add<B, Output = Float>,

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a> Add for &'a Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add for Float

type Output = Float

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

impl<B> AddAssign<B> for Float

where Float: AddAssign<B>,

fn add_assign(&mut self, rhs: B)

Performs the += operation.

impl AddAssign for Float

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl ArchimedeanDiv for Float

fn embed_nat<N: Natural>(n: N) -> Self

Maps a natural number into this structure preserving addition and using the relevant canonical representation

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

the unique integer n such that n*rhs <= self and (n+1)*rhs > self

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

the remaining difference after dividing by rhs (ie. self - self.div_arch(rhs)*rhs)

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

Divides self by rhs with remainder using the archimdean property

impl CheckedAdd for Float

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

Adds two numbers, checking for overflow. If overflow happens, None is returned.

impl CheckedDiv for Float

fn checked_div(&self, v: &Self) -> Option<Self>

Divides two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedMul for Float

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

Multiplies two numbers, checking for underflow or overflow. If underflow or overflow happens, None is returned.

impl CheckedNeg for Float

fn checked_neg(&self) -> Option<Self>

Negates a number, returning None for results that can’t be represented, like signed MIN values that can’t be positive, or non-zero unsigned values that can’t be negative.

impl CheckedRem for Float

fn checked_rem(&self, v: &Self) -> Option<Self>

Finds the remainder of dividing two numbers, checking for underflow, overflow and division by zero. If any of that happens, None is returned.

impl CheckedSub for Float

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

Subtracts two numbers, checking for underflow. If underflow happens, None is returned.

impl Clone for Float

fn clone(&self) -> Float

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ComplexSubset for Float

type Real = Float

type Natural = Integer

type Integer = Integer

fn as_real(self) -> Self::Real

Converts self to a real number, discarding any imaginary component, if complex.

fn as_natural(self) -> Self::Natural

Converts self to a natural number, truncating when necessary.

fn as_integer(self) -> Self::Integer

Converts self to an integer, truncating when necessary.

fn floor(self) -> Self

Rounds the real and imaginary components of self to the closest integer downward

fn ceil(self) -> Self

Rounds the real and imaginary components of self to the closest integer upward

fn round(self) -> Self

Rounds the real and imaginary components of self to the closest integer

fn trunc(self) -> Self

Rounds the real and imaginary components of self by removing the factional parts

fn fract(self) -> Self

Removes the integral parts of the real and imaginary components of self

fn im(self) -> Self

Sets the real component of self to 0

fn re(self) -> Self

Sets the imaginary component of self to 0

fn conj(self) -> Self

The complex conjugate of self

fn modulus_sqrd(self) -> Self

The square of the complex absolute value of self

fn modulus(self) -> Self::Real

The complex absolute value of self

impl Debug for Float

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

Formats the value using the given formatter.

impl Display for Float

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

Formats the value using the given formatter.

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

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, B> Div<B> for &'a Float

where Float: Div<B, Output = Float>,

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl<B> Div<B> for Float

where Float: Div<B, Output = Float>,

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a> Div for &'a Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Float

type Output = Float

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

Performs the /= operation.

impl<B> DivAssign<B> for Float

where Float: DivAssign<B>,

fn div_assign(&mut self, rhs: B)

Performs the /= operation.

impl DivAssign for Float

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl Divisibility for Float

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

Determines if there exists an element x such that self*x = rhs

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

Finds an element x such that self*x = rhs if such an element exists

fn unit(&self) -> bool

Determines if this element has a multiplicative inverse

fn inverse(self) -> Option<Self>

Finds this element’s multiplicative inverse if it exists

impl EuclideanDiv for Float

type Naturals = Integer

The specific type used for the Euclidean Norm

fn euclid_norm(&self) -> Self::Naturals

A measure of the “degree” of a given element.

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

The quotient from Euclidean division

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

The remainder from the Euclidean division

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

Divides a pair of elements with remainder

impl Exponential for Float

fn exp(self) -> Self

The exponential of this ring element

fn try_ln(self) -> Option<Self>

An inverse of exp(x) where ln(1) = 0

impl From<Float> for Float

fn from(src: Float) -> Self

Converts to this type from the input type.

impl From<f32> for Float

fn from(src: f32) -> Self

Converts to this type from the input type.

impl From<f64> for Float

fn from(src: f64) -> Self

Converts to this type from the input type.

impl From<i128> for Float

fn from(src: i128) -> Self

Converts to this type from the input type.

impl From<i16> for Float

fn from(src: i16) -> Self

Converts to this type from the input type.

impl From<i32> for Float

fn from(src: i32) -> Self

Converts to this type from the input type.

impl From<i64> for Float

fn from(src: i64) -> Self

Converts to this type from the input type.

impl From<i8> for Float

fn from(src: i8) -> Self

Converts to this type from the input type.

impl From<isize> for Float

fn from(src: isize) -> Self

Converts to this type from the input type.

impl From<u128> for Float

fn from(src: u128) -> Self

Converts to this type from the input type.

impl From<u16> for Float

fn from(src: u16) -> Self

Converts to this type from the input type.

impl From<u32> for Float

fn from(src: u32) -> Self

Converts to this type from the input type.

impl From<u64> for Float

fn from(src: u64) -> Self

Converts to this type from the input type.

impl From<u8> for Float

fn from(src: u8) -> Self

Converts to this type from the input type.

impl From<usize> for Float

fn from(src: usize) -> Self

Converts to this type from the input type.

impl FromPrimitive for Float

fn from_i64(n: i64) -> Option<Self>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u64(n: u64) -> Option<Self>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_isize(n: isize) -> Option<Self>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i8(n: i8) -> Option<Self>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i16(n: i16) -> Option<Self>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i32(n: i32) -> Option<Self>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_i128(n: i128) -> Option<Self>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_usize(n: usize) -> Option<Self>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u8(n: u8) -> Option<Self>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u16(n: u16) -> Option<Self>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u32(n: u32) -> Option<Self>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

fn from_u128(n: u128) -> Option<Self>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

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

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

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

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl Inv for Float

type Output = Float

The result after applying the operator.

fn inv(self) -> Self::Output

Returns the multiplicative inverse of self.

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

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, B> Mul<B> for &'a Float

where Float: Mul<B, Output = Float>,

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl<B> Mul<B> for Float

where Float: Mul<B, Output = Float>,

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a> Mul for &'a Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Float

type Output = Float

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

impl<B> MulAssign<B> for Float

where Float: MulAssign<B>,

fn mul_assign(&mut self, rhs: B)

Performs the *= operation.

impl MulAssign for Float

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl Neg for Float

type Output = Float

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl One for Float

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl PartialEq for Float

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

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

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

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

impl PartialOrd for Float

fn partial_cmp(&self, other: &Float) -> 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 Real for Float

fn approx(self) -> f64

Approximates this real number as a 64-bit floating point

fn repr(f: f64) -> Self

Constructs a real number from a 64-bit floating point

impl RealExponential for Float

fn try_pow(self, power: Self) -> Option<Self>

This element raised to the given power as defined by x^y = exp(ln(x)*y), if ln(x) exists

fn try_root(self, index: Self) -> Option<Self>

This element taken to the given root as defined as root(x, y) = x^(1/y), if ln(x) and 1/y exist

fn try_log(self, base: Self) -> Option<Self>

The inverse of pow(), if it exists

fn ln(self) -> Self

The natural logarithm of self

fn log(self, base: Self) -> Self

The logarithm of self over a specific base

fn pow(self, p: Self) -> Self

The power of self over a specific exponent

fn root(self, r: Self) -> Self

The root of self over a specific index

fn exp2(self) -> Self

Raises 2 to the power of self

fn exp10(self) -> Self

Raises 10 to the power of self

fn log2(self) -> Self

The logarithm of base 2

fn log10(self) -> Self

The logarithm of base 10

fn sqrt(self) -> Self

fn cbrt(self) -> Self

fn ln_1p(self) -> Self

The natural logarithm of self plus 1.

fn exp_m1(self) -> Self

The exponential of self minus 1.

fn e() -> Self

The exponential of 1. Mirrors ::core::f32::consts::E

fn ln_2() -> Self

The natural logarithm of 2. Mirrors ::core::f32::consts::LN_2

fn ln_10() -> Self

The natural logarithm of 10. Mirrors ::core::f32::consts::LN_10

fn log2_e() -> Self

The logarithm base 2 of e. Mirrors ::core::f32::consts::LOG2_E

fn log10_e() -> Self

The logarithm base 10 of e. Mirrors ::core::f32::consts::LOG10_E

fn log2_10() -> Self

The logarithm base 2 of 10. Mirrors ::core::f32::consts::LOG2_10

fn log10_2() -> Self

The logarithm base 10 of 2. Mirrors ::core::f32::consts::LOG10_2

fn sqrt_2() -> Self

The square root of 2. Mirrors ::core::f32::consts::SQRT_2

fn frac_1_sqrt_2() -> Self

One over the square root of 2. Mirrors ::core::f32::consts::FRAC_1_SQRT_2

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

type Output = Float

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'a, B> Rem<B> for &'a Float

where Float: Rem<B, Output = Float>,

type Output = Float

The resulting type after applying the % operator.

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

Performs the % operation.

impl<B> Rem<B> for Float

where Float: Rem<B, Output = Float>,

type Output = Float

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Float

The resulting type after applying the % operator.

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

Performs the % operation.

impl<'a> Rem for &'a Float

type Output = Float

The resulting type after applying the % operator.

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

Performs the % operation.

impl Rem for Float

type Output = Float

The resulting type after applying the % operator.

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

Performs the % operation.

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

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

Performs the %= operation.

impl<B> RemAssign<B> for Float

where Float: RemAssign<B>,

fn rem_assign(&mut self, rhs: B)

Performs the %= operation.

impl RemAssign for Float

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl Sign for Float

fn signum(self) -> Self

Returns 1 if positive, -1 if negative, or itself (ie. 0 or NaN) if neither

fn abs(self) -> Self

Returns this element’s negative if less than 0 or itself otherwise

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

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, B> Sub<B> for &'a Float

where Float: Sub<B, Output = Float>,

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl<B> Sub<B> for Float

where Float: Sub<B, Output = Float>,

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a> Sub for &'a Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub for Float

type Output = Float

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

impl<B> SubAssign<B> for Float

where Float: SubAssign<B>,

fn sub_assign(&mut self, rhs: B)

Performs the -= operation.

impl SubAssign for Float

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl ToPrimitive for Float

fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl Trig for Float

fn sin(self) -> Self

Finds the Sine of the given value

fn cos(self) -> Self

Finds the Cosine of the given value

fn tan(self) -> Self

Finds the Tangent of the given value

fn sinh(self) -> Self

Finds the Hyperbolic Sine of the given value

fn cosh(self) -> Self

Finds the Hyperbolic Cosine of the given value

fn tanh(self) -> Self

Finds the Hyperbolic Tangent of the given value

fn asin(self) -> Self

A continuous inverse function of Sine such that asin(1) = π/2 and asin(-1) = -π/2

fn acos(self) -> Self

A continuous inverse function of Cosine such that acos(1) = 0 and asin(-1) = π

fn atan(self) -> Self

A continuous inverse function of Tangent such that atan(0) = 0 and atan(1) = π/4

fn asinh(self) -> Self

A continuous inverse function of Hyperbolic Sine such that asinh(0)=0

fn acosh(self) -> Self

A continuous inverse function of Hyperbolic Cosine such that acosh(0)=1

fn atanh(self) -> Self

A continuous inverse function of Hyperbolic Tangent such that atanh(0)=0

fn try_asin(self) -> Option<Self>

A continuous inverse function of Sine such that asin(1) = π/2 and asin(-1) = -π/2

fn try_acos(self) -> Option<Self>

A continuous inverse function of Cosine such that acos(1) = 0 and asin(-1) = π

fn try_asinh(self) -> Option<Self>

A continuous inverse function of Hyperbolic Sine such that asinh(0)=0

fn try_acosh(self) -> Option<Self>

A continuous inverse function of Hyperbolic Cosine such that acosh(0)=1

fn try_atanh(self) -> Option<Self>

A continuous inverse function of Hyperbolic Tangent such that atanh(0)=0

fn atan2(y: Self, x: Self) -> Self

A continuous function of two variables where tan(atan2(y,x)) = y/x for y!=0 and atan2(0,1) = 0

fn pi() -> Self

The classic cicle constant

fn sin_cos(self) -> (Self, Self)

Finds both the Sine and Cosine as a tuple

fn frac_2_pi() -> Self

2/π. Mirrors FRAC_2_PI

fn frac_pi_2() -> Self

π/2. Mirrors FRAC_PI_2

fn frac_pi_3() -> Self

π/3. Mirrors FRAC_PI_3

fn frac_pi_4() -> Self

π/4. Mirrors FRAC_PI_4

fn frac_pi_6() -> Self

π/6. Mirrors FRAC_PI_6

fn frac_pi_8() -> Self

π/8. Mirrors FRAC_PI_8

fn pythag_const() -> Self

The length of the hypotenuse of a unit right-triangle. Mirrors SQRT_2

fn pythag_const_inv() -> Self

The sine of π/4. Mirrors FRAC_1_SQRT_2

fn to_degrees(self) -> Self

fn to_radians(self) -> Self

impl Zero for Float

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl AddAssociative for Float

impl AddCommutative for Float

impl AddOrdered for Float

impl ArchimedeanProperty for Float

impl Distributive for Float

impl MulAssociative for Float

impl MulCommutative for Float

impl MulOrdered for Float

impl NoZeroDivisors for Float

impl StructuralPartialEq for Float