Struct F 

pub struct F<T: FloatLike>(pub T);

Tuple Fields

0: T

Implementations

impl<T: FloatLike> F<T>

pub fn negate(&mut self)

pub fn from_f64(x: f64) -> Self

pub fn E(&self) -> Self

pub fn TAU(&self) -> Self

pub fn PIHALF(&self) -> Self

pub fn SQRT_2(&self) -> Self

pub fn SQRT_2_HALF(&self) -> Self

pub fn floor(&self) -> Self

Trait Implementations

impl<T: FloatLike> Add for F<T>

type Output = F<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: FloatLike> Add<&F<T>> for F<T>

type Output = F<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: FloatLike> Add<&F<T>> for &F<T>

type Output = F<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: FloatLike> Add<F<T>> for &F<T>

type Output = F<T>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T: FloatLike> AddAssign for F<T>

fn add_assign(&mut self, rhs: F<T>)

Performs the += operation.

impl<T: FloatLike> AddAssign<&F<T>> for F<T>

fn add_assign(&mut self, rhs: &F<T>)

Performs the += operation.

impl<T: FloatLike> ApproxEq<Complex<F<T>>, F<T>> for Complex<F<T>>

fn approx_eq(&self, other: &Complex<F<T>>, tolerance: &F<T>) -> bool

fn approx_eq_res(&self, other: &Complex<F<T>>, tolerance: &F<T>) -> Result<()>

fn approx_eq_slice(lhs: &[Self], rhs: &[U], tolerance: &T) -> bool

where Self: Sized,

fn approx_eq_iterator<'a, I, J>(lhs: I, rhs: J, tolerance: &'a T) -> bool

where Self: Sized + 'a, U: 'a, I: IntoIterator<Item = &'a Self>, J: IntoIterator<Item = &'a U>,

fn assert_approx_eq(&self, other: &U, tolerance: &T)

impl<T: FloatLike> ApproxEq<Complex<F<T>>, F<T>> for F<T>

fn approx_eq(&self, other: &Complex<F<T>>, tolerance: &F<T>) -> bool

fn approx_eq_res(&self, other: &Complex<F<T>>, tolerance: &F<T>) -> Result<()>

fn approx_eq_slice(lhs: &[Self], rhs: &[U], tolerance: &T) -> bool

where Self: Sized,

fn approx_eq_iterator<'a, I, J>(lhs: I, rhs: J, tolerance: &'a T) -> bool

where Self: Sized + 'a, U: 'a, I: IntoIterator<Item = &'a Self>, J: IntoIterator<Item = &'a U>,

fn assert_approx_eq(&self, other: &U, tolerance: &T)

impl<T: FloatLike> ApproxEq<Energy<F<T>>, F<T>> for Energy<F<T>>

fn approx_eq(&self, other: &Energy<F<T>>, threshold: &F<T>) -> bool

fn approx_eq_slice(lhs: &[Self], rhs: &[U], tolerance: &T) -> bool

where Self: Sized,

fn approx_eq_iterator<'a, I, J>(lhs: I, rhs: J, tolerance: &'a T) -> bool

where Self: Sized + 'a, U: 'a, I: IntoIterator<Item = &'a Self>, J: IntoIterator<Item = &'a U>,

fn assert_approx_eq(&self, other: &U, tolerance: &T)

fn approx_eq_res(&self, other: &U, tolerance: &T) -> Result<()>

impl<T: FloatLike> ApproxEq<F<T>, F<T>> for F<T>

fn approx_eq(&self, other: &F<T>, tolerance: &F<T>) -> bool

fn approx_eq_slice(lhs: &[Self], rhs: &[U], tolerance: &T) -> bool

where Self: Sized,

fn approx_eq_iterator<'a, I, J>(lhs: I, rhs: J, tolerance: &'a T) -> bool

where Self: Sized + 'a, U: 'a, I: IntoIterator<Item = &'a Self>, J: IntoIterator<Item = &'a U>,

fn assert_approx_eq(&self, other: &U, tolerance: &T)

fn approx_eq_res(&self, other: &U, tolerance: &T) -> Result<()>

impl<T: FloatLike> ApproxEq<F<T>, F<T>> for Complex<F<T>>

fn approx_eq(&self, other: &F<T>, tolerance: &F<T>) -> bool

fn approx_eq_res(&self, other: &F<T>, tolerance: &F<T>) -> Result<()>

fn approx_eq_slice(lhs: &[Self], rhs: &[U], tolerance: &T) -> bool

where Self: Sized,

fn approx_eq_iterator<'a, I, J>(lhs: I, rhs: J, tolerance: &'a T) -> bool

where Self: Sized + 'a, U: 'a, I: IntoIterator<Item = &'a Self>, J: IntoIterator<Item = &'a U>,

fn assert_approx_eq(&self, other: &U, tolerance: &T)

impl<T: FloatLike> ApproxEq<FourMomentum<F<T>>, F<T>> for FourMomentum<F<T>>

fn approx_eq(&self, other: &FourMomentum<F<T>>, threshold: &F<T>) -> bool

fn approx_eq_slice(lhs: &[Self], rhs: &[U], tolerance: &T) -> bool

where Self: Sized,

fn approx_eq_iterator<'a, I, J>(lhs: I, rhs: J, tolerance: &'a T) -> bool

where Self: Sized + 'a, U: 'a, I: IntoIterator<Item = &'a Self>, J: IntoIterator<Item = &'a U>,

fn assert_approx_eq(&self, other: &U, tolerance: &T)

fn approx_eq_res(&self, other: &U, tolerance: &T) -> Result<()>

impl<T: FloatLike> ApproxEq<Polarization<Complex<F<T>>>, F<T>> for FourMomentum<F<T>>

fn approx_eq( &self, other: &Polarization<Complex<F<T>>>, tolerance: &F<T>, ) -> bool

fn approx_eq_res( &self, other: &Polarization<Complex<F<T>>>, tolerance: &F<T>, ) -> Result<()>

fn approx_eq_slice(lhs: &[Self], rhs: &[U], tolerance: &T) -> bool

where Self: Sized,

fn approx_eq_iterator<'a, I, J>(lhs: I, rhs: J, tolerance: &'a T) -> bool

where Self: Sized + 'a, U: 'a, I: IntoIterator<Item = &'a Self>, J: IntoIterator<Item = &'a U>,

fn assert_approx_eq(&self, other: &U, tolerance: &T)

impl<T: FloatLike> ApproxEq<Polarization<Complex<F<T>>>, F<T>> for Polarization<Complex<F<T>>>

fn approx_eq( &self, other: &Polarization<Complex<F<T>>>, tolerance: &F<T>, ) -> bool

fn approx_eq_res( &self, other: &Polarization<Complex<F<T>>>, tolerance: &F<T>, ) -> Result<()>

fn approx_eq_slice(lhs: &[Self], rhs: &[U], tolerance: &T) -> bool

where Self: Sized,

fn approx_eq_iterator<'a, I, J>(lhs: I, rhs: J, tolerance: &'a T) -> bool

where Self: Sized + 'a, U: 'a, I: IntoIterator<Item = &'a Self>, J: IntoIterator<Item = &'a U>,

fn assert_approx_eq(&self, other: &U, tolerance: &T)

impl<T: FloatLike> ApproxEq<ThreeMomentum<F<T>>, F<T>> for ThreeMomentum<F<T>>

fn approx_eq(&self, other: &ThreeMomentum<F<T>>, threshold: &F<T>) -> bool

fn approx_eq_slice(lhs: &[Self], rhs: &[U], tolerance: &T) -> bool

where Self: Sized,

fn approx_eq_iterator<'a, I, J>(lhs: I, rhs: J, tolerance: &'a T) -> bool

where Self: Sized + 'a, U: 'a, I: IntoIterator<Item = &'a Self>, J: IntoIterator<Item = &'a U>,

fn assert_approx_eq(&self, other: &U, tolerance: &T)

fn approx_eq_res(&self, other: &U, tolerance: &T) -> Result<()>

impl<'__de, T, __Context> BorrowDecode<'__de, __Context> for F<T>

where T: BorrowDecode<'__de, __Context> + FloatLike,

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

Attempt to decode this type with the given BorrowDecode.

impl<T: Clone + FloatLike> Clone for F<T>

fn clone(&self) -> F<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: FloatLike + Constructible> Constructible for F<T>

fn new_from_i64(a: i64) -> Self

fn new_from_usize(a: usize) -> Self

fn new_one() -> Self

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

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

impl<T: Copy + FloatLike> Copy for F<T>

impl<T: Debug + FloatLike> Debug for F<T>

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

Formats the value using the given formatter.

impl<T, __Context> Decode<__Context> for F<T>

where T: Decode<__Context> + FloatLike,

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

Attempt to decode this type with the given Decode.

impl<T: Default + FloatLike> Default for F<T>

fn default() -> F<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for F<T>

where T: Deserialize<'de> + FloatLike,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: FloatLike> Display for F<T>

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

Formats the value using the given formatter.

impl<T: FloatLike> Div for F<T>

type Output = F<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: FloatLike> Div<&F<T>> for F<T>

type Output = F<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: FloatLike> Div<&F<T>> for &F<T>

type Output = F<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: FloatLike> Div<F<T>> for &F<T>

type Output = F<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: FloatLike> DivAssign for F<T>

fn div_assign(&mut self, rhs: F<T>)

Performs the /= operation.

impl<T: FloatLike> DivAssign<&F<T>> for F<T>

fn div_assign(&mut self, rhs: &F<T>)

Performs the /= operation.

impl<T> Encode for F<T>

where T: Encode + FloatLike,

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

Encode a given type.

impl<T: FloatLike + EvaluationDomain> EvaluationDomain for F<T>

const FIXED_PRECISION: Option<u32> = T::FIXED_PRECISION

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<T: FloatLike + ExportNumber> ExportNumber for F<T>

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<T: FloatLike + FixedPrecision> FixedPrecision for F<T>

const BINARY_PRECISION: usize = T::BINARY_PRECISION

The number of binary digits in the mantissa.

const DECIMAL_PRECISION: usize = _

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

impl<T: FloatLike> FloatLike for F<T>

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 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 sample_unit<R: Rng + ?Sized>(&self, rng: &mut R) -> Self

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

fn neg(&self) -> Self

fn zero(&self) -> Self

fn one(&self) -> Self

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

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

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

fn inv(&self) -> 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 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<'a> From<&'a F<f64>> for Coefficient

fn from(x: &'a F<f64>) -> Self

Converts to this type from the input type.

impl<'a, T: FloatLike> From<&'a Fraction<IntegerRing>> for F<T>

fn from(x: &'a Rational) -> Self

Converts to this type from the input type.

impl<T: FloatLike> From<F<T>> for Float

fn from(value: F<T>) -> Self

Converts to this type from the input type.

impl From<F<f64>> for Coefficient

fn from(value: F<f64>) -> Self

Converts to this type from the input type.

impl From<F<f64>> for f64

fn from(value: F<f64>) -> Self

Converts to this type from the input type.

impl From<F<f64>> for Rational

fn from(value: F<f64>) -> Self

Converts to this type from the input type.

impl<T: FloatLike> From<T> for F<T>

fn from(x: T) -> Self

Converts to this type from the input type.

impl<T: Hash + FloatLike> Hash for F<T>

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<T> JsonSchema for F<T>

where T: JsonSchema + FloatLike,

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl<T: FloatLike> LowerExp for F<T>

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

Formats the value using the given formatter.

impl<T: FloatLike> MomTropFloat for F<T>

fn PI(&self) -> Self

Return pi.

fn abs(&self) -> Self

Return absolute value of self.

fn cos(&self) -> Self

Return cosine of self.

fn exp(&self) -> Self

Return exponential of self.

fn one(&self) -> Self

Returns 1.

fn from_f64(&self, value: f64) -> Self

Create a new value from a `f64``.

fn from_isize(&self, value: isize) -> Self

Create a new value from an isize.

fn inv(&self) -> Self

Return inverse of self.

fn ln(&self) -> Self

Return natural logarithm of self.

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

Raise self to power.

fn sin(&self) -> Self

Return sine of self.

fn sqrt(&self) -> Self

Return sqrt of self.

fn zero(&self) -> Self

Returns 0.

fn to_f64(&self) -> f64

Convert self to f64.

impl<T: FloatLike> Mul for F<T>

type Output = F<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: FloatLike> Mul<&F<T>> for F<T>

type Output = F<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: FloatLike> Mul<&F<T>> for &F<T>

type Output = F<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: FloatLike> Mul<F<T>> for &F<T>

type Output = F<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: FloatLike> MulAssign for F<T>

fn mul_assign(&mut self, rhs: F<T>)

Performs the *= operation.

impl<T: FloatLike> MulAssign<&F<T>> for F<T>

fn mul_assign(&mut self, rhs: &F<T>)

Performs the *= operation.

impl<T: FloatLike> Neg for F<T>

type Output = F<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: FloatLike> Neg for &F<T>

type Output = F<T>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: PartialEq + FloatLike> PartialEq for F<T>

fn eq(&self, other: &F<T>) -> 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<T: PartialOrd + FloatLike> PartialOrd for F<T>

fn partial_cmp(&self, other: &F<T>) -> 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<T: FloatLike> PrecisionUpgradable for F<T>

where T::Higher: FloatLike, T::Lower: FloatLike,

type Higher = F<<T as PrecisionUpgradable>::Higher>

type Lower = F<<T as PrecisionUpgradable>::Lower>

fn higher(&self) -> Self::Higher

fn lower(&self) -> Self::Lower

impl<T: FloatLike> R for F<T>

impl<T: FloatLike> Real for F<T>

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

fn conj(&self) -> Self

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

The imaginary unit, if it exists.

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

fn norm(&self) -> Self

fn e(&self) -> Self

Euler’s number, 2.7182818…

fn phi(&self) -> Self

The golden ratio, 1.6180339887…

fn euler(&self) -> Self

The Euler-Mascheroni constant, 0.5772156649…

fn pi(&self) -> Self

The constant π, 3.1415926535…

fn sqrt(&self) -> Self

fn log(&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<T: FloatLike> RealLike for F<T>

fn to_usize_clamped(&self) -> usize

fn to_f64(&self) -> f64

fn round_to_nearest_integer(&self) -> Integer

impl<T: FloatLike> RefDefault for F<T>

fn default(&self) -> Self

impl<T: FloatLike> RefOne for F<T>

fn ref_one(&self) -> Self

impl<T: FloatLike> RefZero for F<T>

fn ref_zero(&self) -> Self

impl<T: FloatLike> RefZero<F<T>> for &F<T>

fn ref_zero(&self) -> F<T>

impl<T: FloatLike> Rem<&F<T>> for &F<T>

type Output = F<T>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T> Serialize for F<T>

where T: Serialize + FloatLike,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: FloatLike> SingleFloat for F<T>

fn is_zero(&self) -> bool

fn is_one(&self) -> bool

fn is_finite(&self) -> bool

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

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

impl<T: PartialEq + FloatLike> StructuralPartialEq for F<T>

impl<T: FloatLike> Sub for F<T>

type Output = F<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: FloatLike> Sub<&F<T>> for F<T>

type Output = F<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: FloatLike> Sub<&F<T>> for &F<T>

type Output = F<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: FloatLike> Sub<F<T>> for &F<T>

type Output = F<T>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T: FloatLike> SubAssign for F<T>

fn sub_assign(&mut self, rhs: F<T>)

Performs the -= operation.

impl<T: FloatLike> SubAssign<&F<T>> for F<T>

fn sub_assign(&mut self, rhs: &F<T>)

Performs the -= operation.

impl<T: TensorLibraryData + FloatLike> TensorLibraryData for F<T>

fn one() -> Self

fn minus_one() -> Self

fn zero() -> Self

impl ToAtom for F<f64>

fn to_atom(self) -> Atom

impl<T: FloatLike> ToCoefficient for F<T>

fn to_coefficient(self) -> Coefficient

impl ToFloat for F<f64>

fn to_float(&self) -> Float

impl TrySmallestUpgrade<Atom> for F<f64>

type LCM = Atom

fn try_upgrade(&self) -> Option<Cow<'_, Self::LCM>>

impl<T: FloatLike> TrySmallestUpgrade<Complex<F<T>>> for F<T>

type LCM = Complex<F<T>>

fn try_upgrade(&self) -> Option<Cow<'_, Self::LCM>>

impl<T: FloatLike> TrySmallestUpgrade<F<T>> for F<T>

type LCM = F<T>

fn try_upgrade(&self) -> Option<Cow<'_, Self::LCM>>

impl<T: FloatLike> TrySmallestUpgrade<F<T>> for Complex<F<T>>

type LCM = Complex<F<T>>

fn try_upgrade(&self) -> Option<Cow<'_, Self::LCM>>

impl TrySmallestUpgrade<F<f64>> for Atom

type LCM = Atom

fn try_upgrade(&self) -> Option<Cow<'_, Self::LCM>>