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 kernel_clamp(self, min: &Self, max: &Self) -> Self

Clamps the value within the specified bounds.

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

fn kernel_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.kernel_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<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 kernel_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>

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

fn kernel_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 kernel_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.

type RawReal = <K as RawKernel>::RawReal

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

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> HyperbolicFunctions for RealValidated<K>

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

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