Struct ComplexValidated 

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

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

Trait Implementations

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

type Error = FunctionErrors<ACosComplexInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<ACosHInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<ASinComplexInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<ASinHInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<ATanComplexInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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> ATanH for ComplexValidated<K>

type Error = FunctionErrors<ATanHInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<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>::ComplexPolicy as ValidationPolicy>::Value>, <<<<K as NumKernel>::ComplexPolicy as ValidationPolicy>::Value as RawComplexTrait>::RawReal 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 ComplexValidated<K>> for ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the + operator.

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

Performs the + operation.

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<ComplexValidated<K>> for &'a ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the + operator.

fn add(self, rhs: ComplexValidated<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 ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = ComplexValidated<K>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

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<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 ComplexValidated<K>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<K: NumKernel> Arg for ComplexValidated<K>

type Output = RealValidated<K>

The return type of the principal value (or argument) function. It is always a real number.

type Error = FunctionErrors<ArgInputErrors<<K as RawKernel>::RawComplex>, <<<K as RawKernel>::RawComplex as RawComplexTrait>::RawReal as RawScalarTrait>::ValidationErrors>

The error type that can be returned by the Arg::try_arg() method.

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

Attempts to compute the argument of self, returning a Result.

fn arg(self) -> RealValidated<K>

Returns the argument of self.

impl<K: NumKernel> AsRef<<K as RawKernel>::RawComplex> for ComplexValidated<K>

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

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

impl<K: NumKernel> Clone for ComplexValidated<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> ComplexScalar for ComplexValidated<K>

fn into_parts(self) -> (Self::RealType, Self::RealType)

Consumes the complex number and returns its real and imaginary parts as a tuple.

fn scale(self, c: &Self::RealType) -> Self

Scale the complex number self by the real coefficient c.

fn scale_mut(&mut self, c: &Self::RealType)

Scale (in-place) the complex number self by the real coefficient c.

impl<K: NumKernel> ComplexScalarConstructors for ComplexValidated<K>

Implement the ComplexScalarConstructors trait for the ComplexValidated type.

type RawComplex = <K as RawKernel>::RawComplex

The raw underlying complex type (e.g., num::Complex<f64> or rug::Complex).

fn try_new_complex( real_part: K::RawReal, imag_part: K::RawReal, ) -> Result<Self, <Self::RawComplex as RawScalarTrait>::ValidationErrors>

Tries to create a new complex scalar from its raw real and imaginary parts.

fn new_complex(real: Self::RealType, imag: Self::RealType) -> Self

Creates a new complex scalar from its (validated) real and imaginary parts.

fn try_new_pure_real( real_part: <Self::RawComplex as RawComplexTrait>::RawReal, ) -> Result<Self, <Self::RawComplex as RawScalarTrait>::ValidationErrors>

Tries to create a new complex scalar from a raw real part, with a zero imaginary part.

fn try_new_pure_imaginary( imag_part: <Self::RawComplex as RawComplexTrait>::RawReal, ) -> Result<Self, <Self::RawComplex as RawScalarTrait>::ValidationErrors>

Tries to create a new complex scalar from a raw imaginary part, with a zero real part.

fn new_pure_real(real_part: Self::RealType) -> Self

fn new_pure_imaginary(imag_part: Self::RealType) -> Self

impl<K: NumKernel> ComplexScalarGetParts for ComplexValidated<K>

Implement the ComplexScalarGetParts trait for the ComplexValidated type.

fn real_part(&self) -> RealValidated<K>

Get the real part of the complex number.

fn imag_part(&self) -> RealValidated<K>

Get the imaginary part of the complex number.

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

Returns a reference to the raw real part of the complex number.

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

Returns a reference to the raw imaginary part of the complex number.

fn is_pure_real(&self) -> bool

Returns true if the complex number is purely real (i.e., has no imaginary part).

fn is_pure_imaginary(&self) -> bool

Returns true if the complex number is purely imaginary (i.e., has zero real part and non-zero imaginary part).

impl<K: NumKernel> ComplexScalarMutateParts for ComplexValidated<K>

Implement the ComplexScalarMutateParts trait for the ComplexValidated type.

fn add_to_real_part(&mut self, c: &RealValidated<K>)

Add the value of the the real coefficient c to real part of self.

fn add_to_imaginary_part(&mut self, c: &RealValidated<K>)

Add the value of the the real coefficient c to imaginary part of self.

fn multiply_real_part(&mut self, c: &RealValidated<K>)

Multiply the value of the real part by the real coefficient c.

fn multiply_imaginary_part(&mut self, c: &RealValidated<K>)

Multiply the value of the imaginary part by the real coefficient c.

impl<K: NumKernel> ComplexScalarSetParts for ComplexValidated<K>

Implement the ComplexScalarSetParts trait for the ComplexValidated type.

fn set_real_part(&mut self, real_part: RealValidated<K>)

Set the value of the real part.

fn set_imaginary_part(&mut self, imag_part: RealValidated<K>)

Set the value of the imaginary part.

fn with_real_part(self, real_part: Self::RealType) -> Self

Returns a new complex number with the real part set to the given value and the imaginary part from self.

fn with_imaginary_part(self, imag_part: Self::RealType) -> Self

Returns a new complex number with the imaginary part set to the given value and the real part from self.

impl<K: NumKernel> Conjugate for ComplexValidated<K>

fn conjugate(self) -> Self

Returns the complex conjugate of self.

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

type Error = FunctionErrors<CosInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<CosHInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

where K::RawComplex: 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 ComplexValidated<K>

where K::RawComplex: 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 ComplexValidated<K>

where K::RawComplex: Display,

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

Formats the value using the given formatter.

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

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

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> ComplexValidated<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 ComplexValidated<K>> for ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the / operator.

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

Performs the / operation.

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<ComplexValidated<K>> for &'a ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the / operator.

fn div(self, rhs: ComplexValidated<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 ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = ComplexValidated<K>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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

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<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 ComplexValidated<K>

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

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

type Error = FunctionErrors<ExpInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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> FpChecks for ComplexValidated<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 ComplexValidated<K>

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

Returns a reference to the underlying raw complex value.

type Kind = Complex

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 ComplexValidated<K>

where K::ComplexPolicy: GuaranteesFiniteComplexValues,

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

This implementation is only available when the kernel’s ComplexPolicy implements the GuaranteesFiniteComplexValues marker trait. This ensures that both the real and imaginary parts are 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 complex type (via RawComplexTrait). This method:

• For Complex<f64> types: Hashes real and imaginary parts sequentially using f64::to_bits()
• For rug::Complex types: Hashes real and imaginary components using their compute_hash() methods
• Handles signed zeros correctly in both real and imaginary parts
• Maintains the hash contract: a == b implies hash(a) == hash(b)

Safety and Correctness

This implementation is safe because:

• GuaranteesFiniteComplexValues ensures no NaN values can exist in either component
• The Eq implementation is well-defined for finite complex values
• Signed zeros are handled consistently in both equality and hashing
• Complex numbers with different component values produce different hashes

Usage Example

use num_valid::ComplexNative64StrictFinite;
use num::Complex;
use std::collections::HashMap;
use try_create::TryNew;

let mut map = HashMap::new();
let key = ComplexNative64StrictFinite::try_new(Complex::new(1.0, 2.0)).unwrap();
map.insert(key, "complex value");
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> IntoInner for ComplexValidated<K>

type InnerType = <K as RawKernel>::RawComplex

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 ComplexValidated<K>

type Error = FunctionErrors<LogarithmComplexInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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> Log10 for ComplexValidated<K>

type Error = FunctionErrors<LogarithmComplexInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<LogarithmComplexInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

where K::RawComplex: Display,

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

Formats the value using the given formatter.

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

type Output = ComplexValidated<K>

The resulting type after applying the * operator.

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

Performs the * operation.

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<ComplexValidated<K>> for &'a ComplexValidated<K>

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<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<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 ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = ComplexValidated<K>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<K: NumKernel> MulAddRef for ComplexValidated<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 ComplexValidated<K>> for ComplexValidated<K>

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

Performs the *= operation.

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<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 ComplexValidated<K>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

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

type Output = ComplexValidated<K>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

fn neg_assign(&mut self)

Performs the negation of self.

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

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

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

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

Creates a new instance of Self from value.

impl<K: NumKernel> One for ComplexValidated<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 for ComplexValidated<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> 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<i128> for ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i128>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i16>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i32>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i64>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, i8>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, isize>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u128>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u16>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u32>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u64>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, u8>, <<<ComplexValidated<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 ComplexValidated<K>

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

Raises th number self to the power exponent.

type Error = FunctionErrors<PowIntExponentInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value, usize>, <<<ComplexValidated<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 ComplexValidated<K>

type RawType = <K as RawKernel>::RawComplex

impl<K> RandomSampleFromF64 for ComplexValidated<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> Reciprocal for ComplexValidated<K>

type Error = FunctionErrors<ReciprocalInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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> Serialize for ComplexValidated<K>

where K::RawComplex: 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> Sin for ComplexValidated<K>

type Error = FunctionErrors<SinInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<SinHInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<SqrtComplexInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>> for ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the - operator.

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

Performs the - operation.

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<ComplexValidated<K>> for &'a ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the - operator.

fn sub(self, rhs: ComplexValidated<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 ComplexValidated<K>

type Output = ComplexValidated<K>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = ComplexValidated<K>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

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<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 ComplexValidated<K>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<K: NumKernel> Sum for ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<TanComplexInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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 ComplexValidated<K>

type Error = FunctionErrors<TanHComplexInputErrors<<<ComplexValidated<K> as TryNewValidated>::Policy as ValidationPolicy>::Value>, <<<ComplexValidated<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> TryNew for ComplexValidated<K>

type Error = <<K as NumKernel>::ComplexPolicy 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 ComplexValidated<K>

type Policy = <K as NumKernel>::ComplexPolicy

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 ComplexValidated<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 ComplexValidated<K>

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

where K::RawComplex: Copy,

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

where K::ComplexPolicy: GuaranteesFiniteComplexValues,

Implements total equality (Eq) for ComplexValidated types.

This implementation is only available when the kernel’s ComplexPolicy implements the GuaranteesFiniteComplexValues marker trait. This ensures that the underlying complex number components are never NaN, making the equality relation reflexive, symmetric, and transitive, as required by Eq.

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

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

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