Struct RealValidated 

pub struct RealValidated<K: NumKernel> { /* private fields */ }

A validated real number that is guaranteed to conform to a specific NumKernel.

Trait Implementations

impl<K: NumKernel> ACos for RealValidated<K>

type Error = FunctionErrors<ACosRealInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_acos method.

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

Computes the inverse cosine of self and returns a Result.

fn acos(self) -> Self

Computes and returns the inverse cosine of self.

impl<K: NumKernel> ACosH for RealValidated<K>

type Error = FunctionErrors<ACosHInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_acosh method.

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

Computes the inverse hyperbolic cosine of self and returns a Result.

fn acosh(self) -> Self

Computes and returns the inverse hyperbolic cosine of self.

impl<K: NumKernel> ASin for RealValidated<K>

type Error = FunctionErrors<ASinRealInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_asin method.

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

Computes the inverse sine of self and returns a Result.

fn asin(self) -> Self

Computes and returns the inverse sine of self.

impl<K: NumKernel> ASinH for RealValidated<K>

type Error = FunctionErrors<ASinHInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_asinh method.

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

Computes the inverse hyperbolic sine of self and returns a Result.

fn asinh(self) -> Self

Computes and returns the inverse hyperbolic sine of self.

impl<K: NumKernel> ATan for RealValidated<K>

type Error = FunctionErrors<ATanRealInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_atan method.

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

Computes the inverse tangent of self and returns a Result.

fn atan(self) -> Self

Computes and returns the inverse tangent of self.

impl<K: NumKernel> ATan2 for RealValidated<K>

type Error = FunctionErrors<ATan2InputErrors<<K as RawKernel>::RawReal>, <<K as RawKernel>::RawReal as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_atan2 method.

fn try_atan2(self, denominator: &Self) -> Result<Self, Self::Error>

Computes the arctangent of self (numerator y) and denominator (x), returning a Result.

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

Computes the arctangent of self (numerator y) and denominator (x), returning the result directly.

impl<K: NumKernel> ATanH for RealValidated<K>

type Error = FunctionErrors<ATanHInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_atanh method.

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

Computes the inverse hyperbolic tangent of self and returns a Result.

fn atanh(self) -> Self

Computes and returns the inverse hyperbolic tangent of self.

impl<K: NumKernel> Abs for RealValidated<K>

fn abs(self) -> Self::Output

Returns the absolute value of self.

type Output = RealValidated<K>

The output type of the absolute value function.

type Error = FunctionErrors<AbsInputErrors<<<K as NumKernel>::RealPolicy as ValidationPolicy>::Value>, <<<K as NumKernel>::RealPolicy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_abs method.

fn try_abs(self) -> Result<Self::Output, Self::Error>

Attempts to compute the absolute value of self.

impl<'a, K: NumKernel> Add<&'a RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: Add<&'a <K::RealPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the + operator.

fn add(self, rhs: &'a RealValidated<K>) -> Self::Output

Performs the + operation.

impl<'a, K: NumKernel> Add<&'a RealValidated<K>> for RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, K: NumKernel> Add<RealValidated<K>> for &'a RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<K: NumKernel> Add<RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: Add<<K::RealPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, K: NumKernel> Add for &'a RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the + operator.

fn add(self, rhs: &'a RealValidated<K>) -> Self::Output

Performs the + operation.

impl<K: NumKernel> Add for RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'a, K: NumKernel> AddAssign<&'a RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: AddAssign<&'a <K::RealPolicy as ValidationPolicy>::Value>,

fn add_assign(&mut self, rhs: &'a RealValidated<K>)

Performs the += operation.

impl<'a, K: NumKernel> AddAssign<&'a RealValidated<K>> for RealValidated<K>

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

Performs the += operation.

impl<K: NumKernel> AddAssign<RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: AddAssign<<K::RealPolicy as ValidationPolicy>::Value>,

fn add_assign(&mut self, rhs: RealValidated<K>)

Performs the += operation.

impl<K: NumKernel> AddAssign for RealValidated<K>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<K: NumKernel> AsRef<<K as RawKernel>::RawReal> for RealValidated<K>

fn as_ref(&self) -> &K::RawReal

Converts this type into a shared reference of the (usually inferred) input type.

impl<K: NumKernel> Clamp for RealValidated<K>

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

Clamps the value within the specified bounds.

impl<K: NumKernel> Classify for RealValidated<K>

fn classify(&self) -> FpCategory

Returns the floating point category of the number. If only one property is going to be tested, it is generally faster to use the specific predicate instead.

use num_valid::{
    functions::Classify,
    kernels::native64_validated::RealNative64StrictFinite,
};
use std::num::FpCategory;
use try_create::TryNew;

let num = RealNative64StrictFinite::try_new(12.4).unwrap();

assert_eq!(num.classify(), FpCategory::Normal);

impl<K: NumKernel> Clone for RealValidated<K>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: NumKernel> Constants for RealValidated<K>

fn pi() -> Self

Build and return the (floating point) value π represented by the proper type.

fn two_pi() -> Self

Build and return the (floating point) value 2 π represented by the proper type.

fn pi_div_2() -> Self

Build and return the (floating point) value π/2 represented by the proper type.

fn one_div_2() -> Self

Build and return the (floating point) value 0.5 represented by the proper type.

fn two() -> Self

Build and return the (floating point) value 2. represented by the proper type.

fn max_finite() -> Self

Build and return the maximum finite value allowed by the current floating point representation.

fn min_finite() -> Self

Build and return the minimum finite (i.e., the most negative) value allowed by the current floating point representation.

fn epsilon() -> Self

Machine epsilon value for Self.

fn negative_one() -> Self

Build and return the (floating point) value -1. represented by the proper type.

fn ln_2() -> Self

Build and return the natural logarithm of 2, i.e. the (floating point) value ln(2), represented by the proper type.

fn ln_10() -> Self

Build and return the natural logarithm of 10, i.e. the (floating point) value ln(10), represented by the proper type.

fn log2_e() -> Self

Build and return the base-2 logarithm of e, i.e. the (floating point) value Log_2(e), represented by the proper type.

fn log10_e() -> Self

Build and return the base-10 logarithm of e, i.e. the (floating point) value Log_10(e), represented by the proper type.

fn e() -> Self

Build and return the (floating point) value e represented by the proper type.

fn log2_10() -> Self

Build and return the base-2 logarithm of 10, i.e. the (floating point) value Log_2(10), represented by the proper type.

fn log10_2() -> Self

Build and return the base-10 logarithm of 2, i.e. the (floating point) value Log_10(2), represented by the proper type.

impl<K: NumKernel> Cos for RealValidated<K>

type Error = FunctionErrors<CosInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_cos method.

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

Computes the cosine of self and returns a Result.

fn cos(self) -> Self

Computes and returns the cosine of self.

impl<K: NumKernel> CosH for RealValidated<K>

type Error = FunctionErrors<CosHInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_cosh method.

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

Computes the hyperbolic cosine of self and returns a Result.

fn cosh(self) -> Self

Computes and returns the hyperbolic cosine of self.

impl<K: NumKernel> Debug for RealValidated<K>

where K::RawReal: Debug, PhantomData<K>: Debug,

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

Formats the value using the given formatter.

impl<'de, K: NumKernel> Deserialize<'de> for RealValidated<K>

where K::RawReal: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K: NumKernel> Display for RealValidated<K>

where K::RawReal: Display,

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

Formats the value using the given formatter.

impl<K: NumKernel> Distribution<RealValidated<K>> for StandardUniform

Implement the Distribution trait for RealValidated type using the StandardUniform distribution.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> RealValidated<K>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<'a, K: NumKernel> Div<&'a RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: Div<&'a <K::RealPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the / operator.

fn div(self, rhs: &'a RealValidated<K>) -> Self::Output

Performs the / operation.

impl<'a, K: NumKernel> Div<&'a RealValidated<K>> for RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, K: NumKernel> Div<RealValidated<K>> for &'a RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<K: NumKernel> Div<RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: Div<<K::RealPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, K: NumKernel> Div for &'a RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the / operator.

fn div(self, rhs: &'a RealValidated<K>) -> Self::Output

Performs the / operation.

impl<K: NumKernel> Div for RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'a, K: NumKernel> DivAssign<&'a RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: DivAssign<&'a <K::RealPolicy as ValidationPolicy>::Value>,

fn div_assign(&mut self, rhs: &'a RealValidated<K>)

Performs the /= operation.

impl<'a, K: NumKernel> DivAssign<&'a RealValidated<K>> for RealValidated<K>

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

Performs the /= operation.

impl<K: NumKernel> DivAssign<RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: DivAssign<<K::RealPolicy as ValidationPolicy>::Value>,

fn div_assign(&mut self, rhs: RealValidated<K>)

Performs the /= operation.

impl<K: NumKernel> DivAssign for RealValidated<K>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<K: NumKernel> Exp for RealValidated<K>

type Error = FunctionErrors<ExpInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_exp method.

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

Attempts to compute the exponential of self (e^self), returning a Result.

fn exp(self) -> Self

Computes and returns the exponential of self.

impl<K: NumKernel> ExpM1 for RealValidated<K>

fn exp_m1(self) -> Self

Returns `e^(self) - 1`` in a way that is accurate even if the number is close to zero.

impl<K: NumKernel> FpChecks for RealValidated<K>

fn is_finite(&self) -> bool

Returns true if self is neither infinite nor NaN.

fn is_infinite(&self) -> bool

Returns true if self is positive infinity or negative infinity, and false otherwise.

fn is_nan(&self) -> bool

Returns true if self is NaN.

fn is_normal(&self) -> bool

Returns true if self is normal (i.e. neither zero, infinite, subnormal, or NaN).

impl<K: NumKernel> FpScalar for RealValidated<K>

fn as_raw_ref(&self) -> &Self::InnerType

Returns a reference to the underlying raw real value.

type Kind = Real

The kind of scalar this is, e.g., Real or Complex. This is a sealed trait to prevent external implementations.

type RealType = RealValidated<K>

The real number type corresponding to this scalar.

impl<K: NumKernel> Hash for RealValidated<K>

where K::RealPolicy: GuaranteesFiniteValues,

Implements Hash for validated real number types with finite value guarantees.

This implementation is only available when the kernel’s RealPolicy implements the GuaranteesFiniteValues marker trait. This ensures that the underlying value is never NaN, making hash values consistent and allowing these types to be used as keys in hash-based collections.

Hashing Strategy

The implementation delegates to the RawScalarTrait::compute_hash() method provided by the underlying raw scalar type (via RawScalarTrait). This method:

• For f64 types: Uses IEEE 754 bit representation via f64::to_bits()
• For rug::Float types: Uses integer representation via rug::Float::to_integer()
• Handles signed zeros correctly (both +0.0 and -0.0 produce the same hash)
• Maintains the hash contract: a == b implies hash(a) == hash(b)

Safety and Correctness

This implementation is safe because:

• GuaranteesFiniteValues ensures no NaN values can exist
• The Eq implementation is well-defined for finite values
• Signed zeros are handled consistently in both equality and hashing

Usage Example

use num_valid::RealNative64StrictFinite;
use std::collections::HashMap;
use try_create::TryNew;

let mut map = HashMap::new();
let key = RealNative64StrictFinite::try_new(3.14).unwrap();
map.insert(key, "pi approximation");
assert_eq!(map.len(), 1);

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<K: NumKernel> Hypot for RealValidated<K>

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

Compute the distance between the origin and a point (self, other) on the Euclidean plane. Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length self.abs() and other.abs().

impl<K: NumKernel> IntoInner for RealValidated<K>

type InnerType = <K as RawKernel>::RawReal

The type of the inner value that will be extracted.

fn into_inner(self) -> Self::InnerType

Consumes the wrapper and returns the inner value.

impl<K: NumKernel> Ln for RealValidated<K>

type Error = FunctionErrors<LogarithmRealInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_ln method.

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

Computes the natural logarithm of self and returns a Result.

fn ln(self) -> Self

Computes the natural logarithm of self and directly returns the computed value.

impl<K: NumKernel> Ln1p for RealValidated<K>

fn ln_1p(self) -> Self

Returns ln(1. + self) (natural logarithm) more accurately than if the operations were performed separately.

impl<K: NumKernel> Log10 for RealValidated<K>

type Error = FunctionErrors<LogarithmRealInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_log10 method.

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

Computes the base-10 logarithm of self and returns a Result.

fn log10(self) -> Self

Computes the base-10 logarithm of self and directly returns the computed value.

impl<K: NumKernel> Log2 for RealValidated<K>

type Error = FunctionErrors<LogarithmRealInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_log2 method.

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

Computes the base-2 logarithm of self and returns a Result.

fn log2(self) -> Self

Computes the base-2 logarithm of self and directly returns the computed value.

impl<K: NumKernel> LowerExp for RealValidated<K>

where K::RawReal: Display,

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

Formats the value using the given formatter.

impl<K: NumKernel> Max for RealValidated<K>

fn max<'a>(&'a self, other: &'a Self) -> &'a Self

Returns a reference to the maximum of self and other.

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

Returns the maximum of self and other, consuming both values.

impl<K: NumKernel> Min for RealValidated<K>

fn min<'a>(&'a self, other: &'a Self) -> &'a Self

Returns a reference to the minimum of self and other.

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

Returns the minimum of self and other, consuming both values.

impl<'a, K: NumKernel> Mul<&'a RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: Mul<&'a <K::RealPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a RealValidated<K>) -> Self::Output

Performs the * operation.

impl<'a, K: NumKernel> Mul<&'a RealValidated<K>> for RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, K: NumKernel> Mul<ComplexValidated<K>> for &'a RealValidated<K>

where <K::RealPolicy as ValidationPolicy>::Value: Mul<<K::ComplexPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<K: NumKernel> Mul<ComplexValidated<K>> for RealValidated<K>

where <K::RealPolicy as ValidationPolicy>::Value: Mul<<K::ComplexPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, K: NumKernel> Mul<RealValidated<K>> for &'a RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<K: NumKernel> Mul<RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: Mul<<K::RealPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'a, K: NumKernel> Mul for &'a RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a RealValidated<K>) -> Self::Output

Performs the * operation.

impl<K: NumKernel> Mul for RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<K: NumKernel> MulAddRef for RealValidated<K>

fn mul_add_ref(self, b: &Self, c: &Self) -> Self

Multiplies and adds in one fused operation, rounding to the nearest with only one rounding error.

a.mul_add(b, c) produces a result like a * &b + &c.

impl<'a, K: NumKernel> MulAssign<&'a RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: MulAssign<&'a <K::RealPolicy as ValidationPolicy>::Value>,

fn mul_assign(&mut self, rhs: &'a RealValidated<K>)

Performs the *= operation.

impl<'a, K: NumKernel> MulAssign<&'a RealValidated<K>> for RealValidated<K>

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

Performs the *= operation.

impl<K: NumKernel> MulAssign<RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: MulAssign<<K::RealPolicy as ValidationPolicy>::Value>,

fn mul_assign(&mut self, rhs: RealValidated<K>)

Performs the *= operation.

impl<K: NumKernel> MulAssign for RealValidated<K>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<K: NumKernel> Neg for RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<K: NumKernel> NegAssign for RealValidated<K>

fn neg_assign(&mut self)

Performs the negation of self.

impl<K: NumKernel> NeumaierAddable for RealValidated<K>

fn neumaier_compensated_sum( value: Self, sum: &mut Self, compensation: &mut Self, )

impl<K: NumKernel> New for RealValidated<K>

fn new(value: Self::InnerType) -> Self

Creates a new instance of Self from value.

impl<K: NumKernel> One for RealValidated<K>

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

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

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

impl<K: NumKernel> PartialEq<f64> for RealValidated<K>

fn eq(&self, other: &f64) -> 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<K: NumKernel> PartialEq for RealValidated<K>

fn eq(&self, other: &Self) -> 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<K: NumKernel> PartialOrd<f64> for RealValidated<K>

fn partial_cmp(&self, other: &f64) -> 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<K: NumKernel> PartialOrd for RealValidated<K>

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

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<K: NumKernel> Pow<&RealValidated<K>> for ComplexValidated<K>

fn pow(self, exponent: &RealValidated<K>) -> Self

Raises th number self to the power exponent.

type Error = PowComplexBaseRealExponentErrors<<K as RawKernel>::RawComplex>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

fn try_pow(self, exponent: &RealValidated<K>) -> Result<Self, Self::Error>

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<&RealValidated<K>> for RealValidated<K>

fn pow(self, exponent: &Self) -> Self

Raises th number self to the power exponent.

type Error = PowRealBaseRealExponentErrors<<K as RawKernel>::RawReal>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

fn try_pow(self, exponent: &Self) -> Result<Self, Self::Error>

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<i128> for RealValidated<K>

fn pow(self, exponent: i128) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i128>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

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

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<i16> for RealValidated<K>

fn pow(self, exponent: i16) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i16>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

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

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<i32> for RealValidated<K>

fn pow(self, exponent: i32) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i32>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

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

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<i64> for RealValidated<K>

fn pow(self, exponent: i64) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i64>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

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

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<i8> for RealValidated<K>

fn pow(self, exponent: i8) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i8>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

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

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<isize> for RealValidated<K>

fn pow(self, exponent: isize) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, isize>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

fn try_pow(self, exponent: isize) -> Result<Self, Self::Error>

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<u128> for RealValidated<K>

fn pow(self, exponent: u128) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u128>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

fn try_pow(self, exponent: u128) -> Result<Self, Self::Error>

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<u16> for RealValidated<K>

fn pow(self, exponent: u16) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u16>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

fn try_pow(self, exponent: u16) -> Result<Self, Self::Error>

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<u32> for RealValidated<K>

fn pow(self, exponent: u32) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u32>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

fn try_pow(self, exponent: u32) -> Result<Self, Self::Error>

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<u64> for RealValidated<K>

fn pow(self, exponent: u64) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u64>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

fn try_pow(self, exponent: u64) -> Result<Self, Self::Error>

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<u8> for RealValidated<K>

fn pow(self, exponent: u8) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u8>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

fn try_pow(self, exponent: u8) -> Result<Self, Self::Error>

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> Pow<usize> for RealValidated<K>

fn pow(self, exponent: usize) -> Self

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, usize>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_pow method. This type must implement std::error::Error for proper error handling.

fn try_pow(self, exponent: usize) -> Result<Self, Self::Error>

Attempts to compute self (the base) raised to the power of exponent.

impl<K: NumKernel> PowIntExponent for RealValidated<K>

type RawType = <K as RawKernel>::RawReal

impl<K> RandomSampleFromF64 for RealValidated<K>

where K: NumKernel,

fn sample_from<D, R>(dist: &D, rng: &mut R) -> Self

where D: Distribution<f64>, R: Rng + ?Sized,

Samples a single value of Self using the given f64 distribution.

fn sample_iter_from<D, R>( dist: &D, rng: &mut R, n: usize, ) -> impl Iterator<Item = Self>

where D: Distribution<f64>, R: Rng + ?Sized,

impl<K: NumKernel> RealScalar for RealValidated<K>

fn kernel_mul_add_mul_mut( &mut self, mul: &Self, add_mul1: &Self, add_mul2: &Self, )

Multiplies two products and adds them in one fused operation, rounding to the nearest with only one rounding error. a.kernel_mul_add_mul_mut(&b, &c, &d) produces a result like &a * &b + &c * &d, but stores the result in a using its precision.

fn kernel_mul_sub_mul_mut( &mut self, mul: &Self, sub_mul1: &Self, sub_mul2: &Self, )

Multiplies two products and subtracts them in one fused operation, rounding to the nearest with only one rounding error. a.kernel_mul_sub_mul_mut(&b, &c, &d) produces a result like &a * &b - &c * &d, but stores the result in a using its precision.

fn try_from_f64(value: f64) -> Result<Self, ErrorsTryFromf64<K::RawReal>>

Try to build a RealValidated instance from a f64. The returned value is Ok if the input value is valid w.r.t. the ValidationPolicy V, otherwise the returned value is ErrorsTryFromf64.

Examples

use num_valid::{RealNative64StrictFinite, RealScalar};

// Valid value
let x = RealNative64StrictFinite::try_from_f64(3.14).unwrap();
assert_eq!(x.as_ref(), &3.14);

// Invalid value (NaN)
assert!(RealNative64StrictFinite::try_from_f64(f64::NAN).is_err());

fn from_f64(value: f64) -> Self

Build a RealValidated instance from a f64.

This is a convenience method that panics if the value is invalid. Use try_from_f64 for error handling without panics.

Panics

Panics if the input value fails validation (e.g., NaN, infinity, or subnormal for strict policies).

Examples

use num_valid::{RealNative64StrictFinite, RealScalar};

// Valid constant - no need for unwrap()
let pi = RealNative64StrictFinite::from_f64(std::f64::consts::PI);
assert_eq!(pi.as_ref(), &std::f64::consts::PI);

let e = RealNative64StrictFinite::from_f64(std::f64::consts::E);
assert_eq!(e.as_ref(), &std::f64::consts::E);

use num_valid::{RealNative64StrictFinite, RealScalar};

// This will panic because NaN is invalid
let invalid = RealNative64StrictFinite::from_f64(f64::NAN);

type RawReal = <K as RawKernel>::RawReal

The most fundamental, “raw” representation of this real number.

fn truncate_to_usize( self, ) -> Result<usize, ErrorsRawRealToInteger<Self::RawReal, usize>>

Safely converts the truncated value to usize.

impl<K: NumKernel> Reciprocal for RealValidated<K>

type Error = FunctionErrors<ReciprocalInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_reciprocal method.

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

Attempts to compute the reciprocal of self (1/self), returning a Result.

fn reciprocal(self) -> Self

Returns the reciprocal of self (1/self).

impl<K: NumKernel> Rounding for RealValidated<K>

fn kernel_ceil(self) -> Self

Returns the smallest integer greater than or equal to self.

fn kernel_floor(self) -> Self

Returns the largest integer smaller than or equal to self.

fn kernel_fract(self) -> Self

Returns the fractional part of self.

fn kernel_round(self) -> Self

Rounds self to the nearest integer, rounding half-way cases away from zero.

fn kernel_round_ties_even(self) -> Self

Returns the nearest integer to a number. Rounds half-way cases to the number with an even least significant digit.

This function always returns the precise result.

Examples

use num_valid::{
    functions::Rounding,
    RealNative64StrictFinite,
};
use try_create::TryNew;

let f = RealNative64StrictFinite::try_new(3.3).unwrap();
let g = RealNative64StrictFinite::try_new(-3.3).unwrap();
let h = RealNative64StrictFinite::try_new(3.5).unwrap();
let i = RealNative64StrictFinite::try_new(-4.5).unwrap();

assert_eq!(f.kernel_round_ties_even(), RealNative64StrictFinite::try_new(3.).unwrap());
assert_eq!(g.kernel_round_ties_even(), RealNative64StrictFinite::try_new(-3.).unwrap());
assert_eq!(h.kernel_round_ties_even(), RealNative64StrictFinite::try_new(4.).unwrap());
assert_eq!(i.kernel_round_ties_even(), RealNative64StrictFinite::try_new(-4.).unwrap());

fn kernel_trunc(self) -> Self

Returns the integer part of self. This means that non-integer numbers are always truncated towards zero.

Examples

use num_valid::{
    functions::Rounding,
    RealNative64StrictFinite,
};
use try_create::TryNew;

let f = RealNative64StrictFinite::try_new(3.7).unwrap();
let g = RealNative64StrictFinite::try_new(3.).unwrap();
let h = RealNative64StrictFinite::try_new(-3.7).unwrap();

assert_eq!(f.kernel_trunc(), RealNative64StrictFinite::try_new(3.).unwrap());
assert_eq!(g.kernel_trunc(), RealNative64StrictFinite::try_new(3.).unwrap());
assert_eq!(h.kernel_trunc(), RealNative64StrictFinite::try_new(-3.).unwrap());

impl<K: NumKernel> Serialize for RealValidated<K>

where K::RawReal: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K: NumKernel> Sign for RealValidated<K>

fn kernel_is_sign_negative(&self) -> bool

Returns true if the value is negative, −0 or NaN with a negative sign.

fn kernel_is_sign_positive(&self) -> bool

Returns true if the value is positive, +0 or NaN with a positive sign.

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

Returns a number with the magnitude of self and the sign of sign.

fn kernel_signum(self) -> Self

Returns the signum of the number.

impl<K: NumKernel> Sin for RealValidated<K>

type Error = FunctionErrors<SinInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_sin method.

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

Computes the sine of self and returns a Result.

fn sin(self) -> Self

Computes and returns the sine of self.

impl<K: NumKernel> SinH for RealValidated<K>

type Error = FunctionErrors<SinHInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_sinh method.

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

Computes the hyperbolic sine of self and returns a Result.

fn sinh(self) -> Self

Computes and returns the hyperbolic sine of self.

impl<K: NumKernel> Sqrt for RealValidated<K>

type Error = FunctionErrors<SqrtRealInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the try_sqrt method.

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

Attempts to compute the principal square root of self, returning a Result.

fn sqrt(self) -> Self

Computes the square principal square root of self.

impl<'a, K: NumKernel> Sub<&'a RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: Sub<&'a <K::RealPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a RealValidated<K>) -> Self::Output

Performs the - operation.

impl<'a, K: NumKernel> Sub<&'a RealValidated<K>> for RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, K: NumKernel> Sub<RealValidated<K>> for &'a RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<K: NumKernel> Sub<RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: Sub<<K::RealPolicy as ValidationPolicy>::Value, Output = <K::ComplexPolicy as ValidationPolicy>::Value>,

type Output = ComplexValidated<K>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, K: NumKernel> Sub for &'a RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a RealValidated<K>) -> Self::Output

Performs the - operation.

impl<K: NumKernel> Sub for RealValidated<K>

type Output = RealValidated<K>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'a, K: NumKernel> SubAssign<&'a RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: SubAssign<&'a <K::RealPolicy as ValidationPolicy>::Value>,

fn sub_assign(&mut self, rhs: &'a RealValidated<K>)

Performs the -= operation.

impl<'a, K: NumKernel> SubAssign<&'a RealValidated<K>> for RealValidated<K>

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

Performs the -= operation.

impl<K: NumKernel> SubAssign<RealValidated<K>> for ComplexValidated<K>

where <K::ComplexPolicy as ValidationPolicy>::Value: SubAssign<<K::RealPolicy as ValidationPolicy>::Value>,

fn sub_assign(&mut self, rhs: RealValidated<K>)

Performs the -= operation.

impl<K: NumKernel> SubAssign for RealValidated<K>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<K: NumKernel> Sum for RealValidated<K>

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<K: NumKernel> Tan for RealValidated<K>

type Error = FunctionErrors<TanRealInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_tan method.

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

Computes the tangent of self and returns a Result.

fn tan(self) -> Self

Computes and returns the tangent of self.

impl<K: NumKernel> TanH for RealValidated<K>

type Error = FunctionErrors<TanHRealInputErrors<<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<RealValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value as RawScalarTrait>::ValidationErrors>

The error type that is returned by the try_tanh method.

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

Computes the hyperbolic tangent of self and returns a Result.

fn tanh(self) -> Self

Computes and returns the hyperbolic tangent of self.

impl<K: NumKernel> TotalCmp for RealValidated<K>

fn total_cmp(&self, other: &Self) -> Ordering

impl<K: NumKernel> TryNew for RealValidated<K>

type Error = <<K as NumKernel>::RealPolicy as ValidationPolicy>::Error

The error type that can be returned by the try_new method.

fn try_new(value: Self::InnerType) -> Result<Self, Self::Error>

Attempts to create a new instance of Self from value.

impl<K: NumKernel> TryNewValidated for RealValidated<K>

type Policy = <K as NumKernel>::RealPolicy

An implementor of ValidationPolicy.

fn try_new_validated(value: Self::InnerType) -> Result<Self, Self::Error>

Attempts to create a new instance of Self from value. This method should first validate value using Self::Policy::validate_ref(&value) (or Self::Policy::validate(value) if consuming the value is intended by the policy). If validation is successful, it proceeds to construct the Self instance, typically by calling Self::try_new(value). If validation fails, the error from the policy is converted into Self::Error and returned. If construction after successful validation fails, the error from Self::try_new is returned.

impl<K: NumKernel> Zero for RealValidated<K>

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<K: NumKernel> Arithmetic for RealValidated<K>

impl<K: NumKernel> Copy for RealValidated<K>

where K::RawReal: Copy,

impl<K: NumKernel> Eq for RealValidated<K>

where K::RealPolicy: GuaranteesFiniteValues,

Implements total equality (Eq) for RealValidated types.

This implementation is only available when the kernel’s RealPolicy implements the GuaranteesFiniteValues marker trait. This ensures that the underlying value is never NaN, making the equality relation reflexive, symmetric, and transitive, as required by Eq.

impl<K: NumKernel> HyperbolicFunctions for RealValidated<K>

impl<K: NumKernel> LogarithmFunctions for RealValidated<K>

impl<K: NumKernel> TrigonometricFunctions for RealValidated<K>