Struct astro_nalgebra::BigFloat

pub struct BigFloat<CTX: BigFloatCtx> { /* private fields */ }

Arbitrary precision float type that is a wrapper around [astro_float::BigFloat]. Has trait implementations to be used with nalgebra and num_traits.

BigFloat has a type parameter (CTX) that can be either ConstCtx if the precision and rounding mode is known at compile-time. Or one can be created with make_dyn_ctx if the precision or rounding mode are not known at compile time.

One limitation with this library is that only BigFloats with the same CTX parameter are allowed to interop. This means that the precision of a computation system cannot be changed without explicitly casting all variables.

NOTE: It is recommended to make a type alias such as the one below.

Example

use astro_nalgebra::{BigFloat, ConstCtx};

type BF128 = BigFloat<ConstCtx<128>>;

let ten: BF128 = "10".parse().unwrap();
let seven: BF128 = "7".parse().unwrap();
println!("{}", ten / seven);

Implementations

impl<CTX: BigFloatCtx> BigFloat<CTX>

pub fn as_f64(&self) -> f64

Returns the closest f64 to this BigFloat.

If self is NaN, returns f64::NAN

If self is Inf, returns f64::INFINITY or f64::NEG_INFINITY

Otherwise, returns the closest f64 value to this BigFloat.

NOTE: If the value is above f64::MAX, this function will overflow into f64::INFINITY.

NOTE: This is function is defined within this package because astro_float‘s implementation is private, so it is not an officially supported function.’

pub fn as_int(&self) -> Option<(Sign, u128)>

Returns sign and integer as u128. If the absolute value is greater than u128::MAX, returns None.

NOTE: it is much more idiomatic to use the BigFloat::try_into method.

NOTE: This will truncate anything below 1 without giving a warning or error You can check if a number is an integer by ensuring that it is equivalent to its truncated form by using this snippet: float.clone().trunc() - float

Example

use astro_nalgebra::{BigFloat,ConstCtx,Sign};
let int: BigFloat<ConstCtx<128>> = "1234512345".parse().unwrap();
if let Some((sign, integer)) = int.as_int() {
    assert_eq!(integer,1234512345u128);
    assert_eq!(sign, Sign::Pos);
}
else {
    // Value greater than u128::MAX
}

Trait Implementations

impl<CTX: BigFloatCtx> AbsDiffEq for BigFloat<CTX>

type Epsilon = BigFloat<CTX>

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

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

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

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<CTX: BigFloatCtx> Add for BigFloat<CTX>

type Output = BigFloat<CTX>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<CTX: BigFloatCtx> AddAssign for BigFloat<CTX>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<CTX: BigFloatCtx> Clone for BigFloat<CTX>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<CTX: BigFloatCtx + 'static> ComplexField for BigFloat<CTX>

type RealField = BigFloat<CTX>

fn is_finite(&self) -> bool

fn scale(self, factor: Self::RealField) -> Self

Multiplies this complex number by factor.

fn unscale(self, factor: Self::RealField) -> Self

Divides this complex number by factor.

fn mul_add(self, a: Self, b: Self) -> Self

fn hypot(self, other: Self) -> Self::RealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()

fn recip(self) -> Self

fn real(self) -> Self

The real part of this complex number.

fn from_real(re: Self::RealField) -> Self

Builds a pure-real complex number from the given value.

fn imaginary(self) -> Self

The imaginary part of this complex number.

fn modulus_squared(self) -> Self::RealField

The squared modulus of this complex number.

fn modulus(self) -> Self

The modulus of this complex number.

fn argument(self) -> Self::RealField

The argument of this complex number.

fn norm1(self) -> Self

The sum of the absolute value of this complex number’s real and imaginary part.

fn conjugate(self) -> Self

fn ln(self) -> Self

fn log2(self) -> Self

fn log10(self) -> Self

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

fn ln_1p(self) -> Self

fn exp(self) -> Self

fn exp2(self) -> Self

fn exp_m1(self) -> Self

fn powi(self, n: i32) -> Self

fn powf(self, n: Self::RealField) -> Self

fn sqrt(self) -> Self

fn cbrt(self) -> Self

fn try_sqrt(self) -> Option<Self>

fn powc(self, n: Self) -> Self

fn round(self) -> Self

fn floor(self) -> Self

fn ceil(self) -> Self

fn abs(self) -> Self

The absolute value of this complex number: self / self.signum().

fn fract(self) -> Self

fn trunc(self) -> Self

fn signum(self) -> Self

The exponential part of this complex number: self / self.modulus()

fn sin(self) -> Self

fn cos(self) -> Self

fn tan(self) -> Self

fn asin(self) -> Self

fn acos(self) -> Self

fn atan(self) -> Self

fn sinh(self) -> Self

fn cosh(self) -> Self

fn tanh(self) -> Self

fn asinh(self) -> Self

fn acosh(self) -> Self

fn atanh(self) -> Self

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

fn to_polar(self) -> (Self::RealField, Self::RealField)

The polar form of this complex number: (modulus, arg)

fn to_exp(self) -> (Self::RealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})

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

fn sinc(self) -> Self

Cardinal sine

fn sinhc(self) -> Self

fn cosc(self) -> Self

Cardinal cos

fn coshc(self) -> Self

impl<'de, CTX: BigFloatCtx> Deserialize<'de> for BigFloat<CTX>

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<CTX: BigFloatCtx> Div for BigFloat<CTX>

type Output = BigFloat<CTX>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<CTX: BigFloatCtx> DivAssign for BigFloat<CTX>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<CTX: BigFloatCtx> From<BigFloat<CTX>> for f32

fn from(x: BigFloat<CTX>) -> Self

Converts to this type from the input type.

impl<CTX: BigFloatCtx> From<BigFloat<CTX>> for f64

fn from(x: BigFloat<CTX>) -> Self

Converts to this type from the input type.

impl<CTX: BigFloatCtx> From<BigFloat> for BigFloat<CTX>

fn from(value: BigFloat) -> Self

Converts to this type from the input type.

impl<CTX: BigFloatCtx> FromPrimitive for BigFloat<CTX>

fn from_f64(prim: 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.

fn from_f32(prim: 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_u8(prim: 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_i8(prim: 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_u16(prim: 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_i16(prim: 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_u32(prim: 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_i32(prim: 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_i64(prim: 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(prim: 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_i128(prim: 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_u128(prim: 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_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_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.

impl<CTX: BigFloatCtx> FromStr for BigFloat<CTX>

type Err = ParseBigFloatError

The associated error which can be returned from parsing.

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

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

impl<CTX: BigFloatCtx> Mul for BigFloat<CTX>

type Output = BigFloat<CTX>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<CTX: BigFloatCtx> MulAssign for BigFloat<CTX>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<CTX: BigFloatCtx> Neg for BigFloat<CTX>

type Output = BigFloat<CTX>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<CTX: BigFloatCtx> Num for BigFloat<CTX>

type FromStrRadixErr = ParseBigFloatError

fn from_str_radix(str: &str, radix: u32) -> Result<Self, Self::FromStrRadixErr>

Convert from a string and radix (typically 2..=36).

impl<CTX: BigFloatCtx> One for BigFloat<CTX>

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<CTX: BigFloatCtx> PartialEq for BigFloat<CTX>

fn eq(&self, other: &Self) -> 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<CTX: BigFloatCtx> PartialOrd for BigFloat<CTX>

fn partial_cmp(&self, other: &Self) -> 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<CTX: BigFloatCtx + 'static> RealField for BigFloat<CTX>

fn is_sign_positive(&self) -> bool

Is the sign of this real number positive?

fn is_sign_negative(&self) -> bool

Is the sign of this real number negative?

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

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

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

fn copysign(self, sign: Self) -> Self

Copies the sign of sign to self.

fn frac_pi_2() -> Self

fn frac_pi_3() -> Self

fn frac_pi_4() -> Self

fn frac_pi_6() -> Self

fn frac_pi_8() -> Self

fn two_pi() -> Self

fn pi() -> Self

fn e() -> Self

fn ln_2() -> Self

fn ln_10() -> Self

fn log2_e() -> Self

fn log10_e() -> Self

fn min_value() -> Option<Self>

The smallest finite positive value representable using this type.

fn max_value() -> Option<Self>

The largest finite positive value representable using this type.

fn frac_1_pi() -> Self

fn frac_2_pi() -> Self

fn frac_2_sqrt_pi() -> Self

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

impl<CTX: BigFloatCtx + 'static> RelativeEq for BigFloat<CTX>

fn default_max_relative() -> Self::Epsilon

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

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, _max_relative: Self::Epsilon ) -> bool

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

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

The inverse of RelativeEq::relative_eq.

impl<CTX: BigFloatCtx> Rem for BigFloat<CTX>

type Output = BigFloat<CTX>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<CTX: BigFloatCtx> RemAssign for BigFloat<CTX>

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<CTX: BigFloatCtx> Serialize for BigFloat<CTX>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<CTX: BigFloatCtx + 'static> Signed for BigFloat<CTX>

fn signum(&self) -> Self

Returns the sign of the number.

fn abs(&self) -> Self

Computes the absolute value.

fn is_positive(&self) -> bool

Returns true if the number is positive and false if the number is zero or negative.

fn is_negative(&self) -> bool

Returns true if the number is negative and false if the number is zero or positive.

fn abs_sub(&self, other: &Self) -> Self

The positive difference of two numbers.

impl<CTX: BigFloatCtx> Sub for BigFloat<CTX>

type Output = BigFloat<CTX>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<CTX: BigFloatCtx> SubAssign for BigFloat<CTX>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<CTX: BigFloatCtx> TryFrom<BigFloat<CTX>> for u128

type Error = ()

The type returned in the event of a conversion error.

fn try_from(x: BigFloat<CTX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> TryFrom<BigFloat<CTX>> for u16

type Error = ()

The type returned in the event of a conversion error.

fn try_from(x: BigFloat<CTX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> TryFrom<BigFloat<CTX>> for u32

type Error = ()

The type returned in the event of a conversion error.

fn try_from(x: BigFloat<CTX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> TryFrom<BigFloat<CTX>> for u64

type Error = ()

The type returned in the event of a conversion error.

fn try_from(x: BigFloat<CTX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> TryFrom<BigFloat<CTX>> for u8

type Error = ()

The type returned in the event of a conversion error.

fn try_from(x: BigFloat<CTX>) -> Result<Self, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> TryInto<i128> for BigFloat<CTX>

type Error = ()

The type returned in the event of a conversion error.

fn try_into(self) -> Result<i128, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> TryInto<i16> for BigFloat<CTX>

type Error = ()

The type returned in the event of a conversion error.

fn try_into(self) -> Result<i16, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> TryInto<i32> for BigFloat<CTX>

type Error = ()

The type returned in the event of a conversion error.

fn try_into(self) -> Result<i32, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> TryInto<i64> for BigFloat<CTX>

type Error = ()

The type returned in the event of a conversion error.

fn try_into(self) -> Result<i64, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> TryInto<i8> for BigFloat<CTX>

type Error = ()

The type returned in the event of a conversion error.

fn try_into(self) -> Result<i8, Self::Error>

Performs the conversion.

impl<CTX: BigFloatCtx> UlpsEq for BigFloat<CTX>

fn default_max_ulps() -> u32

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

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, _max_ulps: u32) -> bool

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

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

The inverse of UlpsEq::ulps_eq.

impl<CTX: BigFloatCtx> Zero for BigFloat<CTX>

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<CTX: Eq + BigFloatCtx> Eq for BigFloat<CTX>

impl<CTX: BigFloatCtx> Field for BigFloat<CTX>

impl<CTX: BigFloatCtx> StructuralEq for BigFloat<CTX>