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

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

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