Struct VarFloat 

pub struct VarFloat<const N: u32> { /* private fields */ }

Trait Implementations

impl<const N: u32> Add for VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const N: u32> Add<&VarFloat<N>> for VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const N: u32> Add<&VarFloat<N>> for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const N: u32> Add<VarFloat<N>> for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const N: u32> AddAssign for VarFloat<N>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const N: u32> AddAssign<&VarFloat<N>> for VarFloat<N>

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

Performs the += operation.

impl<'__de, const N: u32, __Context> BorrowDecode<'__de, __Context> for VarFloat<N>

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl<const N: u32> Clone for VarFloat<N>

fn clone(&self) -> VarFloat<N>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const N: u32> Debug for VarFloat<N>

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

Formats the value using the given formatter.

impl<const N: u32, __Context> Decode<__Context> for VarFloat<N>

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<const N: u32> Default for VarFloat<N>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, const N: u32> Deserialize<'de> for VarFloat<N>

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<const N: u32> Display for VarFloat<N>

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

Formats the value using the given formatter.

impl<const N: u32> Div for VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const N: u32> Div<&VarFloat<N>> for VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const N: u32> Div<&VarFloat<N>> for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const N: u32> Div<VarFloat<N>> for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the / operator.

fn div(self, rhs: VarFloat<N>) -> Self::Output

Performs the / operation.

impl<const N: u32> DivAssign for VarFloat<N>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<const N: u32> DivAssign<&VarFloat<N>> for VarFloat<N>

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

Performs the /= operation.

impl<const N: u32> Encode for VarFloat<N>

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl<const N: u32> EvaluationDomain for VarFloat<N>

const FIXED_PRECISION: Option<u32>

The single supported binary precision for fixed-precision domains.

fn resolve_function( tags: &[AtomView<'_>], info: &EvaluationInfo, ) -> Option<Box<dyn ExternalFunction<Self>>>

Resolve a function implementation for the given tags, if available for the type. If no implementation exists for the type, a conversion from a ‘larger’ type may be used instead.

fn try_from_complex_float(f: Complex<Float>) -> Result<Self, String>

Try to convert a Complex<Float> to the type.

impl<const N: u32> ExportNumber for VarFloat<N>

fn export(&self) -> String

Export the number as a string.

fn is_real(&self) -> bool

Check if the number is real.

fn to_complex_double(&self) -> Complex<f64>

Convert the number to a complex double.

fn export_wrapped(&self) -> String

Export the number wrapped in a C++ type T.

fn export_wrapped_with(&self, wrapper: &str) -> String

Export the number wrapped in a C++ type wrapper.

impl<const N: u32> FixedPrecision for VarFloat<N>

const BINARY_PRECISION: usize

The number of binary digits in the mantissa.

const DECIMAL_PRECISION: usize = _

The (rounded) number of decimal digits in the mantissa.

impl<const N: u32> FloatLike for VarFloat<N>

fn set_from(&mut self, other: &Self)

Set this value from another value. May reuse memory.

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

Perform (self * a) + b.

fn is_fully_zero(&self) -> bool

Return true if the number is exactly equal to zero (in all components).

fn from_i64(&self, a: i64) -> Self

fn from_usize(&self, a: usize) -> Self

fn get_precision(&self) -> u32

Get the number of precise binary digits.

fn set_precision(&mut self, _precision: u32)

Set the working precision to precision binary digits. Types that loosely track their precision discard the tracked loss, whereas certified enclosures stay valid. The value is rounded when the precision is lowered. Types with a fixed precision ignore this call.

fn zero(&self) -> Self

fn one(&self) -> Self

fn new_zero() -> Self

Create a zero that should only be used as a temporary value, as for some types it may have wrong precision information.

fn inv(&self) -> Self

fn pow(&self, e: u64) -> Self

fn sample_unit<R: Rng + ?Sized>(&self, rng: &mut R) -> Self

Sample a point on the interval [0, 1].

fn neg(&self) -> Self

fn get_epsilon(&self) -> f64

fn fixed_precision(&self) -> bool

Return true iff the precision is fixed, or false if the precision is changed dynamically.

fn real_cmp(&self, _other: &Self) -> Option<Ordering>

Compare ordered scalar values. Non-scalar types may return None.

fn real_classify(&self) -> Option<FpCategory>

Classify a scalar float for exceptional-value handling. Return None for domains without a scalar floating-point classification, such as complex numbers, SIMD vectors, or exact types.

fn needs_rescaling(&self) -> bool

Request scaled arithmetic for zero, subnormal or non-finite intermediates. The default opts out of scalar range guards (for example for exact types or types with multiple independently scaled components).

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

Construct a NaN, preserving this value’s precision and component shape. Returns None for exact types, such as rationals, that cannot represent NaN.

impl<const N: u32> From<&Fraction<IntegerRing>> for VarFloat<N>

fn from(x: &Rational) -> Self

Converts to this type from the input type.

impl<const N: u32> From<&VarFloat<N>> for Float

fn from(value: &VarFloat<N>) -> Self

Converts to this type from the input type.

impl<const N: u32> From<Float> for VarFloat<N>

fn from(x: Float) -> Self

Converts to this type from the input type.

impl<const N: u32> From<Float> for VarFloat<N>

fn from(value: SymbolicaFloat) -> Self

Converts to this type from the input type.

impl<const N: u32> From<VarFloat<N>> for Float

fn from(value: VarFloat<N>) -> Self

Converts to this type from the input type.

impl<const N: u32> FromStr for VarFloat<N>

type Err = ParseFloatError

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<const N: u32> LowerExp for VarFloat<N>

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

Formats the value using the given formatter.

impl<const N: u32> Mul for VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: u32> Mul<&VarFloat<N>> for VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: u32> Mul<&VarFloat<N>> for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: u32> Mul<VarFloat<N>> for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: u32> MulAssign for VarFloat<N>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const N: u32> MulAssign<&VarFloat<N>> for VarFloat<N>

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

Performs the *= operation.

impl<const N: u32> Neg for VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const N: u32> Neg for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const N: u32> PartialEq for VarFloat<N>

fn eq(&self, other: &VarFloat<N>) -> 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<const N: u32> PartialOrd for VarFloat<N>

fn partial_cmp(&self, other: &VarFloat<N>) -> 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<const N: u32> R for VarFloat<N>

impl<const N: u32> Real for VarFloat<N>

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

The imaginary unit, if it exists.

fn conj(&self) -> Self

fn pi(&self) -> Self

The constant π, 3.1415926535…

fn e(&self) -> Self

Euler’s number, 2.7182818…

fn euler(&self) -> Self

The Euler-Mascheroni constant, 0.5772156649…

fn phi(&self) -> Self

The golden ratio, 1.6180339887…

fn atan2(&self, x: &Self) -> Self

fn powf(&self, e: &Self) -> Self

fn log(&self) -> Self

fn norm(&self) -> Self

fn sqrt(&self) -> Self

fn exp(&self) -> Self

fn sin(&self) -> Self

fn cos(&self) -> Self

fn tan(&self) -> Self

fn asin(&self) -> Self

fn acos(&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 hypot(&self, other: &Self) -> Self

Magnitude of a pair, avoiding unnecessary overflow and underflow.

fn copy_sign(&self, sign: &Self) -> Self

Absolute value with the sign of sign, including signed zero where supported.

fn log1p(&self) -> Self

Compute log(1 + self), retaining small increments lost when adding one.

fn sech(&self) -> Self

Reciprocal hyperbolic cosine, without overflowing an intermediate cosh.

fn csch(&self) -> Self

Reciprocal hyperbolic sine, retaining accuracy near zero and at infinity.

impl<const N: u32> RealLike for VarFloat<N>

fn to_f64(&self) -> f64

fn round_to_nearest_integer(&self) -> Integer

fn to_usize_clamped(&self) -> usize

impl<const N: u32> RefOne for VarFloat<N>

fn ref_one(&self) -> Self

impl<const N: u32> RefZero for VarFloat<N>

fn ref_zero(&self) -> Self

impl<const N: u32> Rem<&VarFloat<N>> for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const N: u32> Serialize for VarFloat<N>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<const N: u32> SingleFloat for VarFloat<N>

fn is_finite(&self) -> bool

fn is_one(&self) -> bool

fn is_zero(&self) -> bool

fn from_rational(&self, rat: &Rational) -> Self

Convert a rational to a float with the same precision as the current float.

impl<const N: u32> StructuralPartialEq for VarFloat<N>

impl<const N: u32> Sub for VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const N: u32> Sub<&VarFloat<N>> for VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const N: u32> Sub<&VarFloat<N>> for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const N: u32> Sub<VarFloat<N>> for &VarFloat<N>

type Output = VarFloat<N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const N: u32> SubAssign for VarFloat<N>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<const N: u32> SubAssign<&VarFloat<N>> for VarFloat<N>

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

Performs the -= operation.

impl<const N: u32> UpdateAndGetParams<VarFloat<N>> for ParamBuilder<f64>

where VarFloat<N>: FloatLike,

fn update_emr_and_get_params<'a>( &'a mut self, _cache: (bool, bool), sample: &MomentumSample<VarFloat<N>>, graph: &Graph, helicities: &[Helicity], additional_params: &[F<VarFloat<N>>], left_threshold_params: Option<&ThresholdParams<VarFloat<N>>>, right_threshold_params: Option<&ThresholdParams<VarFloat<N>>>, lu_params: Option<&LUParams<VarFloat<N>>>, ) -> InputParams<'a, VarFloat<N>>