Struct rin::math::Complex

#[repr(C)]
pub struct Complex<T> {
    pub re: T,
    pub im: T,
}

A complex number in Cartesian form.

Representation and Foreign Function Interface Compatibility

Complex<T> is memory layout compatible with an array [T; 2].

Note that Complex<F> where F is a floating point type is only memory layout compatible with C’s complex types, not necessarily calling convention compatible. This means that for FFI you can only pass Complex<F> behind a pointer, not as a value.

Examples

Example of extern function declaration.

use num_complex::Complex;
use std::os::raw::c_int;

extern "C" {
    fn zaxpy_(n: *const c_int, alpha: *const Complex<f64>,
              x: *const Complex<f64>, incx: *const c_int,
              y: *mut Complex<f64>, incy: *const c_int);
}

Fields

re: T

Real portion of the complex number

im: T

Imaginary portion of the complex number

Implementations

impl<T> Complex<T>

pub const fn new(re: T, im: T) -> Complex<T>

Create a new Complex

impl<T> Complex<T> where
    T: Clone + Num, 

pub fn i() -> Complex<T>

Returns imaginary unit

pub fn norm_sqr(&self) -> T

Returns the square of the norm (since T doesn’t necessarily have a sqrt function), i.e. re^2 + im^2.

pub fn scale(&self, t: T) -> Complex<T>

Multiplies self by the scalar t.

pub fn unscale(&self, t: T) -> Complex<T>

Divides self by the scalar t.

pub fn powu(&self, exp: u32) -> Complex<T>

Raises self to an unsigned integer power.

impl<T> Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

pub fn conj(&self) -> Complex<T>

Returns the complex conjugate. i.e. re - i im

pub fn inv(&self) -> Complex<T>

Returns 1/self

pub fn powi(&self, exp: i32) -> Complex<T>

Raises self to a signed integer power.

impl<T> Complex<T> where
    T: Clone + Signed, 

pub fn l1_norm(&self) -> T

Returns the L1 norm |re| + |im| – the Manhattan distance from the origin.

impl<T> Complex<T> where
    T: FloatCore, 

pub fn is_nan(self) -> bool

Checks if the given complex number is NaN

pub fn is_infinite(self) -> bool

Checks if the given complex number is infinite

pub fn is_finite(self) -> bool

Checks if the given complex number is finite

pub fn is_normal(self) -> bool

Checks if the given complex number is normal

Trait Implementations

impl<'a, T> Add<&'a Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the + operator.

pub fn add(
    self,
    other: &Complex<T>
) -> <Complex<T> as Add<&'a Complex<T>>>::Output

Performs the + operation.

impl<'a> Add<&'a Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the + operator.

pub fn add(self, other: &Complex<f32>) -> Complex<f32>

Performs the + operation.

impl<'a, 'b> Add<&'a Complex<f32>> for &'b f32

type Output = Complex<f32>

The resulting type after applying the + operator.

pub fn add(self, other: &Complex<f32>) -> Complex<f32>

Performs the + operation.

impl<'a, T> Add<&'a T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the + operator.

pub fn add(self, other: &T) -> <Complex<T> as Add<&'a T>>::Output

Performs the + operation.

impl<'a, 'b, T> Add<&'a T> for &'b Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the + operator.

pub fn add(self, other: &T) -> <&'b Complex<T> as Add<&'a T>>::Output

Performs the + operation.

impl<'a, 'b, T> Add<&'b Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the + operator.

pub fn add(
    self,
    other: &Complex<T>
) -> <&'a Complex<T> as Add<&'b Complex<T>>>::Output

Performs the + operation.

impl<'a, T> Add<Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the + operator.

pub fn add(
    self,
    other: Complex<T>
) -> <&'a Complex<T> as Add<Complex<T>>>::Output

Performs the + operation.

impl<T> Add<Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the + operator.

pub fn add(self, other: Complex<T>) -> <Complex<T> as Add<Complex<T>>>::Output

Performs the + operation.

impl<'a> Add<Complex<f32>> for &'a f32

type Output = Complex<f32>

The resulting type after applying the + operator.

pub fn add(self, other: Complex<f32>) -> Complex<f32>

Performs the + operation.

impl Add<Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the + operator.

pub fn add(self, other: Complex<f32>) -> <f32 as Add<Complex<f32>>>::Output

Performs the + operation.

impl<'a, T> Add<T> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the + operator.

pub fn add(self, other: T) -> <&'a Complex<T> as Add<T>>::Output

Performs the + operation.

impl<T> Add<T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the + operator.

pub fn add(self, other: T) -> <Complex<T> as Add<T>>::Output

Performs the + operation.

impl<'a, T> AddAssign<&'a Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn add_assign(&mut self, other: &Complex<T>)

Performs the += operation.

impl<'a, T> AddAssign<&'a T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn add_assign(&mut self, other: &T)

Performs the += operation.

impl<T> AddAssign<Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn add_assign(&mut self, other: Complex<T>)

Performs the += operation.

impl<T> AddAssign<T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn add_assign(&mut self, other: T)

Performs the += operation.

impl<T, U> AsPrimitive<U> for Complex<T> where
    T: AsPrimitive<U>,
    U: 'static + Copy, 

pub fn as_(self) -> U

Convert a value to another, using the as operator.

impl<T> Binary for Complex<T> where
    T: Binary + Num + PartialOrd<T> + Clone, 

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

Formats the value using the given formatter.

impl<T> Clone for Complex<T> where
    T: Clone, 

pub fn clone(&self) -> Complex<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<N> ComplexField for Complex<N> where
    N: RealField + PartialOrd<N>, 

type RealField = N

pub fn from_real(re: <Complex<N> as ComplexField>::RealField) -> Complex<N>

Builds a pure-real complex number from the given value.

pub fn real(self) -> <Complex<N> as ComplexField>::RealField

The real part of this complex number.

pub fn imaginary(self) -> <Complex<N> as ComplexField>::RealField

The imaginary part of this complex number.

pub fn argument(self) -> <Complex<N> as ComplexField>::RealField

The argument of this complex number.

pub fn modulus(self) -> <Complex<N> as ComplexField>::RealField

The modulus of this complex number.

pub fn modulus_squared(self) -> <Complex<N> as ComplexField>::RealField

The squared modulus of this complex number.

pub fn norm1(self) -> <Complex<N> as ComplexField>::RealField

The sum of the absolute value of this complex number’s real and imaginary part.

pub fn recip(self) -> Complex<N>

pub fn conjugate(self) -> Complex<N>

pub fn scale(
    self,
    factor: <Complex<N> as ComplexField>::RealField
) -> Complex<N>

Multiplies this complex number by factor.

pub fn unscale(
    self,
    factor: <Complex<N> as ComplexField>::RealField
) -> Complex<N>

Divides this complex number by factor.

pub fn floor(self) -> Complex<N>

pub fn ceil(self) -> Complex<N>

pub fn round(self) -> Complex<N>

pub fn trunc(self) -> Complex<N>

pub fn fract(self) -> Complex<N>

pub fn mul_add(self, a: Complex<N>, b: Complex<N>) -> Complex<N>

pub fn abs(self) -> <Complex<N> as ComplexField>::RealField

The absolute value of this complex number: self / self.signum().

pub fn exp2(self) -> Complex<N>

pub fn exp_m1(self) -> Complex<N>

pub fn ln_1p(self) -> Complex<N>

pub fn log2(self) -> Complex<N>

pub fn log10(self) -> Complex<N>

pub fn cbrt(self) -> Complex<N>

pub fn powi(self, n: i32) -> Complex<N>

pub fn is_finite(&self) -> bool

pub fn exp(self) -> Complex<N>

Computes e^(self), where e is the base of the natural logarithm.

pub fn ln(self) -> Complex<N>

Computes the principal value of natural logarithm of self.

This function has one branch cut:

• (-∞, 0], continuous from above.

The branch satisfies -π ≤ arg(ln(z)) ≤ π.

pub fn sqrt(self) -> Complex<N>

Computes the principal value of the square root of self.

This function has one branch cut:

• (-∞, 0), continuous from above.

The branch satisfies -π/2 ≤ arg(sqrt(z)) ≤ π/2.

pub fn try_sqrt(self) -> Option<Complex<N>>

pub fn hypot(self, b: Complex<N>) -> <Complex<N> as ComplexField>::RealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()

pub fn powf(self, exp: <Complex<N> as ComplexField>::RealField) -> Complex<N>

Raises self to a floating point power.

pub fn log(self, base: N) -> Complex<N>

Returns the logarithm of self with respect to an arbitrary base.

pub fn powc(self, exp: Complex<N>) -> Complex<N>

Raises self to a complex power.

pub fn sin(self) -> Complex<N>

Computes the sine of self.

pub fn cos(self) -> Complex<N>

Computes the cosine of self.

pub fn sin_cos(self) -> (Complex<N>, Complex<N>)

pub fn tan(self) -> Complex<N>

Computes the tangent of self.

pub fn asin(self) -> Complex<N>

Computes the principal value of the inverse sine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Re(asin(z)) ≤ π/2.

pub fn acos(self) -> Complex<N>

Computes the principal value of the inverse cosine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies 0 ≤ Re(acos(z)) ≤ π.

pub fn atan(self) -> Complex<N>

Computes the principal value of the inverse tangent of self.

This function has two branch cuts:

• (-∞i, -i], continuous from the left.
• [i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Re(atan(z)) ≤ π/2.

pub fn sinh(self) -> Complex<N>

Computes the hyperbolic sine of self.

pub fn cosh(self) -> Complex<N>

Computes the hyperbolic cosine of self.

pub fn sinh_cosh(self) -> (Complex<N>, Complex<N>)

pub fn tanh(self) -> Complex<N>

Computes the hyperbolic tangent of self.

pub fn asinh(self) -> Complex<N>

Computes the principal value of inverse hyperbolic sine of self.

This function has two branch cuts:

• (-∞i, -i), continuous from the left.
• (i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Im(asinh(z)) ≤ π/2.

pub fn acosh(self) -> Complex<N>

Computes the principal value of inverse hyperbolic cosine of self.

This function has one branch cut:

• (-∞, 1), continuous from above.

The branch satisfies -π ≤ Im(acosh(z)) ≤ π and 0 ≤ Re(acosh(z)) < ∞.

pub fn atanh(self) -> Complex<N>

Computes the principal value of inverse hyperbolic tangent of self.

This function has two branch cuts:

• (-∞, -1], continuous from above.
• [1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Im(atanh(z)) ≤ π/2.

pub fn to_polar(self) -> (Self::RealField, Self::RealField)

The polar form of this complex number: (modulus, arg)

pub fn to_exp(self) -> (Self::RealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})

pub fn signum(self) -> Self

The exponential part of this complex number: self / self.modulus()

pub fn sinc(self) -> Self

Cardinal sine

pub fn sinhc(self) -> Self

pub fn cosc(self) -> Self

Cardinal cos

pub fn coshc(self) -> Self

impl<T> Debug for Complex<T> where
    T: Debug, 

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

Formats the value using the given formatter.

impl<T> Default for Complex<T> where
    T: Default, 

pub fn default() -> Complex<T>

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Complex<T> where
    T: Deserialize<'de> + Num + Clone, 

pub fn deserialize<D>(
    deserializer: D
) -> Result<Complex<T>, <D as Deserializer<'de>>::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T> Display for Complex<T> where
    T: Display + Num + PartialOrd<T> + Clone, 

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

Formats the value using the given formatter.

impl<'a, T> Div<&'a Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the / operator.

pub fn div(
    self,
    other: &Complex<T>
) -> <Complex<T> as Div<&'a Complex<T>>>::Output

Performs the / operation.

impl<'a> Div<&'a Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the / operator.

pub fn div(self, other: &Complex<f32>) -> Complex<f32>

Performs the / operation.

impl<'a, 'b> Div<&'a Complex<f32>> for &'b f32

type Output = Complex<f32>

The resulting type after applying the / operator.

pub fn div(self, other: &Complex<f32>) -> Complex<f32>

Performs the / operation.

impl<'a, T> Div<&'a T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the / operator.

pub fn div(self, other: &T) -> <Complex<T> as Div<&'a T>>::Output

Performs the / operation.

impl<'a, 'b, T> Div<&'a T> for &'b Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the / operator.

pub fn div(self, other: &T) -> <&'b Complex<T> as Div<&'a T>>::Output

Performs the / operation.

impl<'a, 'b, T> Div<&'b Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the / operator.

pub fn div(
    self,
    other: &Complex<T>
) -> <&'a Complex<T> as Div<&'b Complex<T>>>::Output

Performs the / operation.

impl<'a, T> Div<Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the / operator.

pub fn div(
    self,
    other: Complex<T>
) -> <&'a Complex<T> as Div<Complex<T>>>::Output

Performs the / operation.

impl<T> Div<Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the / operator.

pub fn div(self, other: Complex<T>) -> <Complex<T> as Div<Complex<T>>>::Output

Performs the / operation.

impl<'a> Div<Complex<f32>> for &'a f32

type Output = Complex<f32>

The resulting type after applying the / operator.

pub fn div(self, other: Complex<f32>) -> Complex<f32>

Performs the / operation.

impl Div<Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the / operator.

pub fn div(self, other: Complex<f32>) -> <f32 as Div<Complex<f32>>>::Output

Performs the / operation.

impl<'a, T> Div<T> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the / operator.

pub fn div(self, other: T) -> <&'a Complex<T> as Div<T>>::Output

Performs the / operation.

impl<T> Div<T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the / operator.

pub fn div(self, other: T) -> <Complex<T> as Div<T>>::Output

Performs the / operation.

impl<'a, T> DivAssign<&'a Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn div_assign(&mut self, other: &Complex<T>)

Performs the /= operation.

impl<'a, T> DivAssign<&'a T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn div_assign(&mut self, other: &T)

Performs the /= operation.

impl<T> DivAssign<Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn div_assign(&mut self, other: Complex<T>)

Performs the /= operation.

impl<T> DivAssign<T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn div_assign(&mut self, other: T)

Performs the /= operation.

impl<'a, T> From<&'a T> for Complex<T> where
    T: Clone + Num, 

pub fn from(re: &T) -> Complex<T>

Performs the conversion.

impl<T> From<T> for Complex<T> where
    T: Clone + Num, 

pub fn from(re: T) -> Complex<T>

Performs the conversion.

impl<T> FromPrimitive for Complex<T> where
    T: FromPrimitive + Num, 

pub fn from_usize(n: usize) -> Option<Complex<T>>

Converts a usize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_isize(n: isize) -> Option<Complex<T>>

Converts an isize to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_u8(n: u8) -> Option<Complex<T>>

Converts an u8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_u16(n: u16) -> Option<Complex<T>>

Converts an u16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_u32(n: u32) -> Option<Complex<T>>

Converts an u32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_u64(n: u64) -> Option<Complex<T>>

Converts an u64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_i8(n: i8) -> Option<Complex<T>>

Converts an i8 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_i16(n: i16) -> Option<Complex<T>>

Converts an i16 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_i32(n: i32) -> Option<Complex<T>>

Converts an i32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_i64(n: i64) -> Option<Complex<T>>

Converts an i64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_u128(n: u128) -> Option<Complex<T>>

Converts an u128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_i128(n: i128) -> Option<Complex<T>>

Converts an i128 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_f32(n: f32) -> Option<Complex<T>>

Converts a f32 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

pub fn from_f64(n: f64) -> Option<Complex<T>>

Converts a f64 to return an optional value of this type. If the value cannot be represented by this type, then None is returned.

impl<T> FromStr for Complex<T> where
    T: FromStr + Num + Clone, 

type Err = ParseComplexError<<T as FromStr>::Err>

The associated error which can be returned from parsing.

pub fn from_str(s: &str) -> Result<Complex<T>, <Complex<T> as FromStr>::Err>

Parses a +/- bi; ai +/- b; a; or bi where a and b are of type T

impl<T> Hash for Complex<T> where
    T: Hash, 

pub fn hash<__H>(&self, state: &mut __H) where
    __H: Hasher, 

Feeds this value into the given Hasher.

pub fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given Hasher.

impl<T> Inv for Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn inv(self) -> <Complex<T> as Inv>::Output

Returns the multiplicative inverse of self.

impl<'a, T> Inv for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn inv(self) -> <&'a Complex<T> as Inv>::Output

Returns the multiplicative inverse of self.

impl<T> LowerExp for Complex<T> where
    T: LowerExp + Num + PartialOrd<T> + Clone, 

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

Formats the value using the given formatter.

impl<T> LowerHex for Complex<T> where
    T: LowerHex + Num + PartialOrd<T> + Clone, 

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

Formats the value using the given formatter.

impl<'a, T> Mul<&'a Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the * operator.

pub fn mul(
    self,
    other: &Complex<T>
) -> <Complex<T> as Mul<&'a Complex<T>>>::Output

Performs the * operation.

impl<'a, 'b> Mul<&'a Complex<f32>> for &'b f32

type Output = Complex<f32>

The resulting type after applying the * operator.

pub fn mul(self, other: &Complex<f32>) -> Complex<f32>

Performs the * operation.

impl<'a> Mul<&'a Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the * operator.

pub fn mul(self, other: &Complex<f32>) -> Complex<f32>

Performs the * operation.

impl<'a, T> Mul<&'a T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the * operator.

pub fn mul(self, other: &T) -> <Complex<T> as Mul<&'a T>>::Output

Performs the * operation.

impl<'a, 'b, T> Mul<&'a T> for &'b Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the * operator.

pub fn mul(self, other: &T) -> <&'b Complex<T> as Mul<&'a T>>::Output

Performs the * operation.

impl<'a, 'b, T> Mul<&'b Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the * operator.

pub fn mul(
    self,
    other: &Complex<T>
) -> <&'a Complex<T> as Mul<&'b Complex<T>>>::Output

Performs the * operation.

impl<T> Mul<Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the * operator.

pub fn mul(self, other: Complex<T>) -> <Complex<T> as Mul<Complex<T>>>::Output

Performs the * operation.

impl<'a, T> Mul<Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the * operator.

pub fn mul(
    self,
    other: Complex<T>
) -> <&'a Complex<T> as Mul<Complex<T>>>::Output

Performs the * operation.

impl<'a> Mul<Complex<f32>> for &'a f32

type Output = Complex<f32>

The resulting type after applying the * operator.

pub fn mul(self, other: Complex<f32>) -> Complex<f32>

Performs the * operation.

impl Mul<Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the * operator.

pub fn mul(self, other: Complex<f32>) -> <f32 as Mul<Complex<f32>>>::Output

Performs the * operation.

impl<T> Mul<T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the * operator.

pub fn mul(self, other: T) -> <Complex<T> as Mul<T>>::Output

Performs the * operation.

impl<'a, T> Mul<T> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the * operator.

pub fn mul(self, other: T) -> <&'a Complex<T> as Mul<T>>::Output

Performs the * operation.

impl<'a, 'b, T> MulAdd<&'b Complex<T>, &'a Complex<T>> for &'a Complex<T> where
    T: Clone + Num + MulAdd<T, T, Output = T>, 

type Output = Complex<T>

The resulting type after applying the fused multiply-add.

pub fn mul_add(self, other: &Complex<T>, add: &Complex<T>) -> Complex<T>

Performs the fused multiply-add operation.

impl<T> MulAdd<Complex<T>, Complex<T>> for Complex<T> where
    T: Clone + Num + MulAdd<T, T, Output = T>, 

type Output = Complex<T>

The resulting type after applying the fused multiply-add.

pub fn mul_add(self, other: Complex<T>, add: Complex<T>) -> Complex<T>

Performs the fused multiply-add operation.

impl<'a, 'b, T> MulAddAssign<&'a Complex<T>, &'b Complex<T>> for Complex<T> where
    T: Clone + NumAssign + MulAddAssign<T, T>, 

pub fn mul_add_assign(&mut self, other: &Complex<T>, add: &Complex<T>)

Performs the fused multiply-add operation.

impl<T> MulAddAssign<Complex<T>, Complex<T>> for Complex<T> where
    T: Clone + NumAssign + MulAddAssign<T, T>, 

pub fn mul_add_assign(&mut self, other: Complex<T>, add: Complex<T>)

Performs the fused multiply-add operation.

impl<'a, T> MulAssign<&'a Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn mul_assign(&mut self, other: &Complex<T>)

Performs the *= operation.

impl<'a, T> MulAssign<&'a T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn mul_assign(&mut self, other: &T)

Performs the *= operation.

impl<T> MulAssign<Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn mul_assign(&mut self, other: Complex<T>)

Performs the *= operation.

impl<T> MulAssign<T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn mul_assign(&mut self, other: T)

Performs the *= operation.

impl<T> Neg for Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn neg(self) -> <Complex<T> as Neg>::Output

Performs the unary - operation.

impl<'a, T> Neg for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn neg(self) -> <&'a Complex<T> as Neg>::Output

Performs the unary - operation.

impl<N> Normed for Complex<N> where
    N: SimdRealField, 

type Norm = <N as SimdComplexField>::SimdRealField

The type of the norm.

pub fn norm(&self) -> <N as SimdComplexField>::SimdRealField

Computes the norm.

pub fn norm_squared(&self) -> <N as SimdComplexField>::SimdRealField

Computes the squared norm.

pub fn scale_mut(&mut self, n: <Complex<N> as Normed>::Norm)

Multiply self by n.

pub fn unscale_mut(&mut self, n: <Complex<N> as Normed>::Norm)

Divides self by n.

impl<T> Num for Complex<T> where
    T: Num + Clone, 

type FromStrRadixErr = ParseComplexError<<T as Num>::FromStrRadixErr>

pub fn from_str_radix(
    s: &str,
    radix: u32
) -> Result<Complex<T>, <Complex<T> as Num>::FromStrRadixErr>

Parses a +/- bi; ai +/- b; a; or bi where a and b are of type T

impl<T> NumCast for Complex<T> where
    T: NumCast + Num, 

pub fn from<U>(n: U) -> Option<Complex<T>> where
    U: ToPrimitive, 

Creates a number from another value that can be converted into a primitive via the ToPrimitive trait. If the source value cannot be represented by the target type, then None is returned.

impl<T> Octal for Complex<T> where
    T: Octal + Num + PartialOrd<T> + Clone, 

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

Formats the value using the given formatter.

impl<T> One for Complex<T> where
    T: Clone + Num, 

pub fn one() -> Complex<T>

Returns the multiplicative identity element of Self, 1.

pub fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

pub fn set_one(&mut self)

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

impl<T> PartialEq<Complex<T>> for Complex<T> where
    T: PartialEq<T>, 

pub fn eq(&self, other: &Complex<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Complex<T>) -> bool

This method tests for !=.

impl<'a, 'b, T> Pow<&'b i128> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &i128) -> <&'a Complex<T> as Pow<&'b i128>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b i16> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &i16) -> <&'a Complex<T> as Pow<&'b i16>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b i32> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &i32) -> <&'a Complex<T> as Pow<&'b i32>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b i64> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &i64) -> <&'a Complex<T> as Pow<&'b i64>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b i8> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &i8) -> <&'a Complex<T> as Pow<&'b i8>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b isize> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &isize) -> <&'a Complex<T> as Pow<&'b isize>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b u128> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &u128) -> <&'a Complex<T> as Pow<&'b u128>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b u16> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &u16) -> <&'a Complex<T> as Pow<&'b u16>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b u32> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &u32) -> <&'a Complex<T> as Pow<&'b u32>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b u64> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &u64) -> <&'a Complex<T> as Pow<&'b u64>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b u8> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &u8) -> <&'a Complex<T> as Pow<&'b u8>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b usize> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: &usize) -> <&'a Complex<T> as Pow<&'b usize>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<i128> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: i128) -> <&'a Complex<T> as Pow<i128>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<i16> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: i16) -> <&'a Complex<T> as Pow<i16>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<i32> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: i32) -> <&'a Complex<T> as Pow<i32>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<i64> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: i64) -> <&'a Complex<T> as Pow<i64>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<i8> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: i8) -> <&'a Complex<T> as Pow<i8>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<isize> for &'a Complex<T> where
    T: Clone + Num + Neg<Output = T>, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: isize) -> <&'a Complex<T> as Pow<isize>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<u128> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: u128) -> <&'a Complex<T> as Pow<u128>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<u16> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: u16) -> <&'a Complex<T> as Pow<u16>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<u32> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: u32) -> <&'a Complex<T> as Pow<u32>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<u64> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: u64) -> <&'a Complex<T> as Pow<u64>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<u8> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: u8) -> <&'a Complex<T> as Pow<u8>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<usize> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The result after applying the operator.

pub fn pow(self, exp: usize) -> <&'a Complex<T> as Pow<usize>>::Output

Returns self to the power rhs.

impl<'a, T> Product<&'a Complex<T>> for Complex<T> where
    T: 'a + Num + Clone, 

pub fn product<I>(iter: I) -> Complex<T> where
    I: Iterator<Item = &'a Complex<T>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T> Product<Complex<T>> for Complex<T> where
    T: Num + Clone, 

pub fn product<I>(iter: I) -> Complex<T> where
    I: Iterator<Item = Complex<T>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, T> Rem<&'a Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the % operator.

pub fn rem(
    self,
    other: &Complex<T>
) -> <Complex<T> as Rem<&'a Complex<T>>>::Output

Performs the % operation.

impl<'a> Rem<&'a Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the % operator.

pub fn rem(self, other: &Complex<f32>) -> Complex<f32>

Performs the % operation.

impl<'a, 'b> Rem<&'a Complex<f32>> for &'b f32

type Output = Complex<f32>

The resulting type after applying the % operator.

pub fn rem(self, other: &Complex<f32>) -> Complex<f32>

Performs the % operation.

impl<'a, T> Rem<&'a T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the % operator.

pub fn rem(self, other: &T) -> <Complex<T> as Rem<&'a T>>::Output

Performs the % operation.

impl<'a, 'b, T> Rem<&'a T> for &'b Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the % operator.

pub fn rem(self, other: &T) -> <&'b Complex<T> as Rem<&'a T>>::Output

Performs the % operation.

impl<'a, 'b, T> Rem<&'b Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the % operator.

pub fn rem(
    self,
    other: &Complex<T>
) -> <&'a Complex<T> as Rem<&'b Complex<T>>>::Output

Performs the % operation.

impl<'a, T> Rem<Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the % operator.

pub fn rem(
    self,
    other: Complex<T>
) -> <&'a Complex<T> as Rem<Complex<T>>>::Output

Performs the % operation.

impl<T> Rem<Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the % operator.

pub fn rem(self, modulus: Complex<T>) -> <Complex<T> as Rem<Complex<T>>>::Output

Performs the % operation.

impl Rem<Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the % operator.

pub fn rem(self, other: Complex<f32>) -> <f32 as Rem<Complex<f32>>>::Output

Performs the % operation.

impl<'a> Rem<Complex<f32>> for &'a f32

type Output = Complex<f32>

The resulting type after applying the % operator.

pub fn rem(self, other: Complex<f32>) -> Complex<f32>

Performs the % operation.

impl<'a, T> Rem<T> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the % operator.

pub fn rem(self, other: T) -> <&'a Complex<T> as Rem<T>>::Output

Performs the % operation.

impl<T> Rem<T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the % operator.

pub fn rem(self, other: T) -> <Complex<T> as Rem<T>>::Output

Performs the % operation.

impl<'a, T> RemAssign<&'a Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn rem_assign(&mut self, other: &Complex<T>)

Performs the %= operation.

impl<'a, T> RemAssign<&'a T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn rem_assign(&mut self, other: &T)

Performs the %= operation.

impl<T> RemAssign<Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn rem_assign(&mut self, modulus: Complex<T>)

Performs the %= operation.

impl<T> RemAssign<T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn rem_assign(&mut self, other: T)

Performs the %= operation.

impl<T> Serialize for Complex<T> where
    T: Serialize, 

pub fn serialize<S>(
    &self,
    serializer: S
) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl SimdComplexField for Complex<AutoSimd<[f32; 2]>>

type SimdRealField = AutoSimd<[f32; 2]>

Type of the coefficients of a complex number.

pub fn from_simd_real(
    re: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 2]>>

Builds a pure-real complex number from the given value.

pub fn simd_real(
    self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

The real part of this complex number.

pub fn simd_imaginary(
    self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

The imaginary part of this complex number.

pub fn simd_argument(
    self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

The argument of this complex number.

pub fn simd_modulus(
    self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

The modulus of this complex number.

pub fn simd_modulus_squared(
    self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

The squared modulus of this complex number.

pub fn simd_norm1(
    self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

The sum of the absolute value of this complex number’s real and imaginary part.

pub fn simd_recip(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_conjugate(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_scale(
    self,
    factor: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 2]>>

Multiplies this complex number by factor.

pub fn simd_unscale(
    self,
    factor: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 2]>>

Divides this complex number by factor.

pub fn simd_floor(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_ceil(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_round(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_trunc(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_fract(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_mul_add(
    self,
    a: Complex<AutoSimd<[f32; 2]>>,
    b: Complex<AutoSimd<[f32; 2]>>
) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_abs(
    self
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

The absolute value of this complex number: self / self.signum().

pub fn simd_exp2(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_exp_m1(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_ln_1p(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_log2(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_log10(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_cbrt(self) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f32; 2]>>

pub fn simd_exp(self) -> Complex<AutoSimd<[f32; 2]>>

Computes e^(self), where e is the base of the natural logarithm.

pub fn simd_ln(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of natural logarithm of self.

This function has one branch cut:

• (-∞, 0], continuous from above.

The branch satisfies -π ≤ arg(ln(z)) ≤ π.

pub fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of the square root of self.

This function has one branch cut:

• (-∞, 0), continuous from above.

The branch satisfies -π/2 ≤ arg(sqrt(z)) ≤ π/2.

pub fn simd_hypot(
    self,
    b: Complex<AutoSimd<[f32; 2]>>
) -> <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()

pub fn simd_powf(
    self,
    exp: <Complex<AutoSimd<[f32; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 2]>>

Raises self to a floating point power.

pub fn simd_log(self, base: AutoSimd<[f32; 2]>) -> Complex<AutoSimd<[f32; 2]>>

Returns the logarithm of self with respect to an arbitrary base.

pub fn simd_powc(
    self,
    exp: Complex<AutoSimd<[f32; 2]>>
) -> Complex<AutoSimd<[f32; 2]>>

Raises self to a complex power.

pub fn simd_sin(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the sine of self.

pub fn simd_cos(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the cosine of self.

pub fn simd_sin_cos(
    self
) -> (Complex<AutoSimd<[f32; 2]>>, Complex<AutoSimd<[f32; 2]>>)

pub fn simd_tan(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the tangent of self.

pub fn simd_asin(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of the inverse sine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Re(asin(z)) ≤ π/2.

pub fn simd_acos(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of the inverse cosine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies 0 ≤ Re(acos(z)) ≤ π.

pub fn simd_atan(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of the inverse tangent of self.

This function has two branch cuts:

• (-∞i, -i], continuous from the left.
• [i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Re(atan(z)) ≤ π/2.

pub fn simd_sinh(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the hyperbolic sine of self.

pub fn simd_cosh(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the hyperbolic cosine of self.

pub fn simd_sinh_cosh(
    self
) -> (Complex<AutoSimd<[f32; 2]>>, Complex<AutoSimd<[f32; 2]>>)

pub fn simd_tanh(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the hyperbolic tangent of self.

pub fn simd_asinh(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of inverse hyperbolic sine of self.

This function has two branch cuts:

• (-∞i, -i), continuous from the left.
• (i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Im(asinh(z)) ≤ π/2.

pub fn simd_acosh(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of inverse hyperbolic cosine of self.

This function has one branch cut:

• (-∞, 1), continuous from above.

The branch satisfies -π ≤ Im(acosh(z)) ≤ π and 0 ≤ Re(acosh(z)) < ∞.

pub fn simd_atanh(self) -> Complex<AutoSimd<[f32; 2]>>

Computes the principal value of inverse hyperbolic tangent of self.

This function has two branch cuts:

• (-∞, -1], continuous from above.
• [1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Im(atanh(z)) ≤ π/2.

pub fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

The polar form of this complex number: (modulus, arg)

pub fn simd_to_exp(self) -> (Self::SimdRealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})

pub fn simd_signum(self) -> Self

The exponential part of this complex number: self / self.modulus()

pub fn simd_sinc(self) -> Self

Cardinal sine

pub fn simd_sinhc(self) -> Self

pub fn simd_cosc(self) -> Self

Cardinal cos

pub fn simd_coshc(self) -> Self

impl SimdComplexField for Complex<AutoSimd<[f64; 2]>>

type SimdRealField = AutoSimd<[f64; 2]>

Type of the coefficients of a complex number.

pub fn from_simd_real(
    re: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 2]>>

Builds a pure-real complex number from the given value.

pub fn simd_real(
    self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

The real part of this complex number.

pub fn simd_imaginary(
    self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

The imaginary part of this complex number.

pub fn simd_argument(
    self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

The argument of this complex number.

pub fn simd_modulus(
    self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

The modulus of this complex number.

pub fn simd_modulus_squared(
    self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

The squared modulus of this complex number.

pub fn simd_norm1(
    self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

The sum of the absolute value of this complex number’s real and imaginary part.

pub fn simd_recip(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_conjugate(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_scale(
    self,
    factor: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 2]>>

Multiplies this complex number by factor.

pub fn simd_unscale(
    self,
    factor: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 2]>>

Divides this complex number by factor.

pub fn simd_floor(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_ceil(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_round(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_trunc(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_fract(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_mul_add(
    self,
    a: Complex<AutoSimd<[f64; 2]>>,
    b: Complex<AutoSimd<[f64; 2]>>
) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_abs(
    self
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

The absolute value of this complex number: self / self.signum().

pub fn simd_exp2(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_exp_m1(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_ln_1p(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_log2(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_log10(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_cbrt(self) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f64; 2]>>

pub fn simd_exp(self) -> Complex<AutoSimd<[f64; 2]>>

Computes e^(self), where e is the base of the natural logarithm.

pub fn simd_ln(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of natural logarithm of self.

This function has one branch cut:

• (-∞, 0], continuous from above.

The branch satisfies -π ≤ arg(ln(z)) ≤ π.

pub fn simd_sqrt(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of the square root of self.

This function has one branch cut:

• (-∞, 0), continuous from above.

The branch satisfies -π/2 ≤ arg(sqrt(z)) ≤ π/2.

pub fn simd_hypot(
    self,
    b: Complex<AutoSimd<[f64; 2]>>
) -> <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()

pub fn simd_powf(
    self,
    exp: <Complex<AutoSimd<[f64; 2]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 2]>>

Raises self to a floating point power.

pub fn simd_log(self, base: AutoSimd<[f64; 2]>) -> Complex<AutoSimd<[f64; 2]>>

Returns the logarithm of self with respect to an arbitrary base.

pub fn simd_powc(
    self,
    exp: Complex<AutoSimd<[f64; 2]>>
) -> Complex<AutoSimd<[f64; 2]>>

Raises self to a complex power.

pub fn simd_sin(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the sine of self.

pub fn simd_cos(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the cosine of self.

pub fn simd_sin_cos(
    self
) -> (Complex<AutoSimd<[f64; 2]>>, Complex<AutoSimd<[f64; 2]>>)

pub fn simd_tan(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the tangent of self.

pub fn simd_asin(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of the inverse sine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Re(asin(z)) ≤ π/2.

pub fn simd_acos(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of the inverse cosine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies 0 ≤ Re(acos(z)) ≤ π.

pub fn simd_atan(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of the inverse tangent of self.

This function has two branch cuts:

• (-∞i, -i], continuous from the left.
• [i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Re(atan(z)) ≤ π/2.

pub fn simd_sinh(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the hyperbolic sine of self.

pub fn simd_cosh(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the hyperbolic cosine of self.

pub fn simd_sinh_cosh(
    self
) -> (Complex<AutoSimd<[f64; 2]>>, Complex<AutoSimd<[f64; 2]>>)

pub fn simd_tanh(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the hyperbolic tangent of self.

pub fn simd_asinh(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of inverse hyperbolic sine of self.

This function has two branch cuts:

• (-∞i, -i), continuous from the left.
• (i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Im(asinh(z)) ≤ π/2.

pub fn simd_acosh(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of inverse hyperbolic cosine of self.

This function has one branch cut:

• (-∞, 1), continuous from above.

The branch satisfies -π ≤ Im(acosh(z)) ≤ π and 0 ≤ Re(acosh(z)) < ∞.

pub fn simd_atanh(self) -> Complex<AutoSimd<[f64; 2]>>

Computes the principal value of inverse hyperbolic tangent of self.

This function has two branch cuts:

• (-∞, -1], continuous from above.
• [1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Im(atanh(z)) ≤ π/2.

pub fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

The polar form of this complex number: (modulus, arg)

pub fn simd_to_exp(self) -> (Self::SimdRealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})

pub fn simd_signum(self) -> Self

The exponential part of this complex number: self / self.modulus()

pub fn simd_sinc(self) -> Self

Cardinal sine

pub fn simd_sinhc(self) -> Self

pub fn simd_cosc(self) -> Self

Cardinal cos

pub fn simd_coshc(self) -> Self

impl SimdComplexField for Complex<AutoSimd<[f32; 8]>>

type SimdRealField = AutoSimd<[f32; 8]>

Type of the coefficients of a complex number.

pub fn from_simd_real(
    re: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 8]>>

Builds a pure-real complex number from the given value.

pub fn simd_real(
    self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

The real part of this complex number.

pub fn simd_imaginary(
    self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

The imaginary part of this complex number.

pub fn simd_argument(
    self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

The argument of this complex number.

pub fn simd_modulus(
    self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

The modulus of this complex number.

pub fn simd_modulus_squared(
    self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

The squared modulus of this complex number.

pub fn simd_norm1(
    self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

The sum of the absolute value of this complex number’s real and imaginary part.

pub fn simd_recip(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_conjugate(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_scale(
    self,
    factor: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 8]>>

Multiplies this complex number by factor.

pub fn simd_unscale(
    self,
    factor: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 8]>>

Divides this complex number by factor.

pub fn simd_floor(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_ceil(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_round(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_trunc(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_fract(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_mul_add(
    self,
    a: Complex<AutoSimd<[f32; 8]>>,
    b: Complex<AutoSimd<[f32; 8]>>
) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_abs(
    self
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

The absolute value of this complex number: self / self.signum().

pub fn simd_exp2(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_exp_m1(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_ln_1p(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_log2(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_log10(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_cbrt(self) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f32; 8]>>

pub fn simd_exp(self) -> Complex<AutoSimd<[f32; 8]>>

Computes e^(self), where e is the base of the natural logarithm.

pub fn simd_ln(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of natural logarithm of self.

This function has one branch cut:

• (-∞, 0], continuous from above.

The branch satisfies -π ≤ arg(ln(z)) ≤ π.

pub fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of the square root of self.

This function has one branch cut:

• (-∞, 0), continuous from above.

The branch satisfies -π/2 ≤ arg(sqrt(z)) ≤ π/2.

pub fn simd_hypot(
    self,
    b: Complex<AutoSimd<[f32; 8]>>
) -> <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()

pub fn simd_powf(
    self,
    exp: <Complex<AutoSimd<[f32; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 8]>>

Raises self to a floating point power.

pub fn simd_log(self, base: AutoSimd<[f32; 8]>) -> Complex<AutoSimd<[f32; 8]>>

Returns the logarithm of self with respect to an arbitrary base.

pub fn simd_powc(
    self,
    exp: Complex<AutoSimd<[f32; 8]>>
) -> Complex<AutoSimd<[f32; 8]>>

Raises self to a complex power.

pub fn simd_sin(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the sine of self.

pub fn simd_cos(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the cosine of self.

pub fn simd_sin_cos(
    self
) -> (Complex<AutoSimd<[f32; 8]>>, Complex<AutoSimd<[f32; 8]>>)

pub fn simd_tan(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the tangent of self.

pub fn simd_asin(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of the inverse sine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Re(asin(z)) ≤ π/2.

pub fn simd_acos(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of the inverse cosine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies 0 ≤ Re(acos(z)) ≤ π.

pub fn simd_atan(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of the inverse tangent of self.

This function has two branch cuts:

• (-∞i, -i], continuous from the left.
• [i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Re(atan(z)) ≤ π/2.

pub fn simd_sinh(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the hyperbolic sine of self.

pub fn simd_cosh(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the hyperbolic cosine of self.

pub fn simd_sinh_cosh(
    self
) -> (Complex<AutoSimd<[f32; 8]>>, Complex<AutoSimd<[f32; 8]>>)

pub fn simd_tanh(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the hyperbolic tangent of self.

pub fn simd_asinh(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of inverse hyperbolic sine of self.

This function has two branch cuts:

• (-∞i, -i), continuous from the left.
• (i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Im(asinh(z)) ≤ π/2.

pub fn simd_acosh(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of inverse hyperbolic cosine of self.

This function has one branch cut:

• (-∞, 1), continuous from above.

The branch satisfies -π ≤ Im(acosh(z)) ≤ π and 0 ≤ Re(acosh(z)) < ∞.

pub fn simd_atanh(self) -> Complex<AutoSimd<[f32; 8]>>

Computes the principal value of inverse hyperbolic tangent of self.

This function has two branch cuts:

• (-∞, -1], continuous from above.
• [1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Im(atanh(z)) ≤ π/2.

pub fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

The polar form of this complex number: (modulus, arg)

pub fn simd_to_exp(self) -> (Self::SimdRealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})

pub fn simd_signum(self) -> Self

The exponential part of this complex number: self / self.modulus()

pub fn simd_sinc(self) -> Self

Cardinal sine

pub fn simd_sinhc(self) -> Self

pub fn simd_cosc(self) -> Self

Cardinal cos

pub fn simd_coshc(self) -> Self

impl SimdComplexField for Complex<AutoSimd<[f32; 4]>>

type SimdRealField = AutoSimd<[f32; 4]>

Type of the coefficients of a complex number.

pub fn from_simd_real(
    re: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 4]>>

Builds a pure-real complex number from the given value.

pub fn simd_real(
    self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

The real part of this complex number.

pub fn simd_imaginary(
    self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

The imaginary part of this complex number.

pub fn simd_argument(
    self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

The argument of this complex number.

pub fn simd_modulus(
    self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

The modulus of this complex number.

pub fn simd_modulus_squared(
    self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

The squared modulus of this complex number.

pub fn simd_norm1(
    self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

The sum of the absolute value of this complex number’s real and imaginary part.

pub fn simd_recip(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_conjugate(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_scale(
    self,
    factor: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 4]>>

Multiplies this complex number by factor.

pub fn simd_unscale(
    self,
    factor: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 4]>>

Divides this complex number by factor.

pub fn simd_floor(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_ceil(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_round(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_trunc(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_fract(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_mul_add(
    self,
    a: Complex<AutoSimd<[f32; 4]>>,
    b: Complex<AutoSimd<[f32; 4]>>
) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_abs(
    self
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

The absolute value of this complex number: self / self.signum().

pub fn simd_exp2(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_exp_m1(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_ln_1p(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_log2(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_log10(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_cbrt(self) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f32; 4]>>

pub fn simd_exp(self) -> Complex<AutoSimd<[f32; 4]>>

Computes e^(self), where e is the base of the natural logarithm.

pub fn simd_ln(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of natural logarithm of self.

This function has one branch cut:

• (-∞, 0], continuous from above.

The branch satisfies -π ≤ arg(ln(z)) ≤ π.

pub fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of the square root of self.

This function has one branch cut:

• (-∞, 0), continuous from above.

The branch satisfies -π/2 ≤ arg(sqrt(z)) ≤ π/2.

pub fn simd_hypot(
    self,
    b: Complex<AutoSimd<[f32; 4]>>
) -> <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()

pub fn simd_powf(
    self,
    exp: <Complex<AutoSimd<[f32; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 4]>>

Raises self to a floating point power.

pub fn simd_log(self, base: AutoSimd<[f32; 4]>) -> Complex<AutoSimd<[f32; 4]>>

Returns the logarithm of self with respect to an arbitrary base.

pub fn simd_powc(
    self,
    exp: Complex<AutoSimd<[f32; 4]>>
) -> Complex<AutoSimd<[f32; 4]>>

Raises self to a complex power.

pub fn simd_sin(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the sine of self.

pub fn simd_cos(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the cosine of self.

pub fn simd_sin_cos(
    self
) -> (Complex<AutoSimd<[f32; 4]>>, Complex<AutoSimd<[f32; 4]>>)

pub fn simd_tan(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the tangent of self.

pub fn simd_asin(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of the inverse sine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Re(asin(z)) ≤ π/2.

pub fn simd_acos(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of the inverse cosine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies 0 ≤ Re(acos(z)) ≤ π.

pub fn simd_atan(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of the inverse tangent of self.

This function has two branch cuts:

• (-∞i, -i], continuous from the left.
• [i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Re(atan(z)) ≤ π/2.

pub fn simd_sinh(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the hyperbolic sine of self.

pub fn simd_cosh(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the hyperbolic cosine of self.

pub fn simd_sinh_cosh(
    self
) -> (Complex<AutoSimd<[f32; 4]>>, Complex<AutoSimd<[f32; 4]>>)

pub fn simd_tanh(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the hyperbolic tangent of self.

pub fn simd_asinh(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of inverse hyperbolic sine of self.

This function has two branch cuts:

• (-∞i, -i), continuous from the left.
• (i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Im(asinh(z)) ≤ π/2.

pub fn simd_acosh(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of inverse hyperbolic cosine of self.

This function has one branch cut:

• (-∞, 1), continuous from above.

The branch satisfies -π ≤ Im(acosh(z)) ≤ π and 0 ≤ Re(acosh(z)) < ∞.

pub fn simd_atanh(self) -> Complex<AutoSimd<[f32; 4]>>

Computes the principal value of inverse hyperbolic tangent of self.

This function has two branch cuts:

• (-∞, -1], continuous from above.
• [1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Im(atanh(z)) ≤ π/2.

pub fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

The polar form of this complex number: (modulus, arg)

pub fn simd_to_exp(self) -> (Self::SimdRealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})

pub fn simd_signum(self) -> Self

The exponential part of this complex number: self / self.modulus()

pub fn simd_sinc(self) -> Self

Cardinal sine

pub fn simd_sinhc(self) -> Self

pub fn simd_cosc(self) -> Self

Cardinal cos

pub fn simd_coshc(self) -> Self

impl SimdComplexField for Complex<AutoSimd<[f64; 8]>>

type SimdRealField = AutoSimd<[f64; 8]>

Type of the coefficients of a complex number.

pub fn from_simd_real(
    re: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 8]>>

Builds a pure-real complex number from the given value.

pub fn simd_real(
    self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

The real part of this complex number.

pub fn simd_imaginary(
    self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

The imaginary part of this complex number.

pub fn simd_argument(
    self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

The argument of this complex number.

pub fn simd_modulus(
    self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

The modulus of this complex number.

pub fn simd_modulus_squared(
    self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

The squared modulus of this complex number.

pub fn simd_norm1(
    self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

The sum of the absolute value of this complex number’s real and imaginary part.

pub fn simd_recip(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_conjugate(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_scale(
    self,
    factor: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 8]>>

Multiplies this complex number by factor.

pub fn simd_unscale(
    self,
    factor: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 8]>>

Divides this complex number by factor.

pub fn simd_floor(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_ceil(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_round(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_trunc(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_fract(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_mul_add(
    self,
    a: Complex<AutoSimd<[f64; 8]>>,
    b: Complex<AutoSimd<[f64; 8]>>
) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_abs(
    self
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

The absolute value of this complex number: self / self.signum().

pub fn simd_exp2(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_exp_m1(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_ln_1p(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_log2(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_log10(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_cbrt(self) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f64; 8]>>

pub fn simd_exp(self) -> Complex<AutoSimd<[f64; 8]>>

Computes e^(self), where e is the base of the natural logarithm.

pub fn simd_ln(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of natural logarithm of self.

This function has one branch cut:

• (-∞, 0], continuous from above.

The branch satisfies -π ≤ arg(ln(z)) ≤ π.

pub fn simd_sqrt(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of the square root of self.

This function has one branch cut:

• (-∞, 0), continuous from above.

The branch satisfies -π/2 ≤ arg(sqrt(z)) ≤ π/2.

pub fn simd_hypot(
    self,
    b: Complex<AutoSimd<[f64; 8]>>
) -> <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()

pub fn simd_powf(
    self,
    exp: <Complex<AutoSimd<[f64; 8]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 8]>>

Raises self to a floating point power.

pub fn simd_log(self, base: AutoSimd<[f64; 8]>) -> Complex<AutoSimd<[f64; 8]>>

Returns the logarithm of self with respect to an arbitrary base.

pub fn simd_powc(
    self,
    exp: Complex<AutoSimd<[f64; 8]>>
) -> Complex<AutoSimd<[f64; 8]>>

Raises self to a complex power.

pub fn simd_sin(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the sine of self.

pub fn simd_cos(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the cosine of self.

pub fn simd_sin_cos(
    self
) -> (Complex<AutoSimd<[f64; 8]>>, Complex<AutoSimd<[f64; 8]>>)

pub fn simd_tan(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the tangent of self.

pub fn simd_asin(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of the inverse sine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Re(asin(z)) ≤ π/2.

pub fn simd_acos(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of the inverse cosine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies 0 ≤ Re(acos(z)) ≤ π.

pub fn simd_atan(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of the inverse tangent of self.

This function has two branch cuts:

• (-∞i, -i], continuous from the left.
• [i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Re(atan(z)) ≤ π/2.

pub fn simd_sinh(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the hyperbolic sine of self.

pub fn simd_cosh(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the hyperbolic cosine of self.

pub fn simd_sinh_cosh(
    self
) -> (Complex<AutoSimd<[f64; 8]>>, Complex<AutoSimd<[f64; 8]>>)

pub fn simd_tanh(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the hyperbolic tangent of self.

pub fn simd_asinh(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of inverse hyperbolic sine of self.

This function has two branch cuts:

• (-∞i, -i), continuous from the left.
• (i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Im(asinh(z)) ≤ π/2.

pub fn simd_acosh(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of inverse hyperbolic cosine of self.

This function has one branch cut:

• (-∞, 1), continuous from above.

The branch satisfies -π ≤ Im(acosh(z)) ≤ π and 0 ≤ Re(acosh(z)) < ∞.

pub fn simd_atanh(self) -> Complex<AutoSimd<[f64; 8]>>

Computes the principal value of inverse hyperbolic tangent of self.

This function has two branch cuts:

• (-∞, -1], continuous from above.
• [1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Im(atanh(z)) ≤ π/2.

pub fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

The polar form of this complex number: (modulus, arg)

pub fn simd_to_exp(self) -> (Self::SimdRealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})

pub fn simd_signum(self) -> Self

The exponential part of this complex number: self / self.modulus()

pub fn simd_sinc(self) -> Self

Cardinal sine

pub fn simd_sinhc(self) -> Self

pub fn simd_cosc(self) -> Self

Cardinal cos

pub fn simd_coshc(self) -> Self

impl SimdComplexField for Complex<AutoSimd<[f64; 4]>>

type SimdRealField = AutoSimd<[f64; 4]>

Type of the coefficients of a complex number.

pub fn from_simd_real(
    re: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 4]>>

Builds a pure-real complex number from the given value.

pub fn simd_real(
    self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

The real part of this complex number.

pub fn simd_imaginary(
    self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

The imaginary part of this complex number.

pub fn simd_argument(
    self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

The argument of this complex number.

pub fn simd_modulus(
    self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

The modulus of this complex number.

pub fn simd_modulus_squared(
    self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

The squared modulus of this complex number.

pub fn simd_norm1(
    self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

The sum of the absolute value of this complex number’s real and imaginary part.

pub fn simd_recip(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_conjugate(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_scale(
    self,
    factor: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 4]>>

Multiplies this complex number by factor.

pub fn simd_unscale(
    self,
    factor: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 4]>>

Divides this complex number by factor.

pub fn simd_floor(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_ceil(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_round(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_trunc(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_fract(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_mul_add(
    self,
    a: Complex<AutoSimd<[f64; 4]>>,
    b: Complex<AutoSimd<[f64; 4]>>
) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_abs(
    self
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

The absolute value of this complex number: self / self.signum().

pub fn simd_exp2(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_exp_m1(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_ln_1p(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_log2(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_log10(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_cbrt(self) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f64; 4]>>

pub fn simd_exp(self) -> Complex<AutoSimd<[f64; 4]>>

Computes e^(self), where e is the base of the natural logarithm.

pub fn simd_ln(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of natural logarithm of self.

This function has one branch cut:

• (-∞, 0], continuous from above.

The branch satisfies -π ≤ arg(ln(z)) ≤ π.

pub fn simd_sqrt(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of the square root of self.

This function has one branch cut:

• (-∞, 0), continuous from above.

The branch satisfies -π/2 ≤ arg(sqrt(z)) ≤ π/2.

pub fn simd_hypot(
    self,
    b: Complex<AutoSimd<[f64; 4]>>
) -> <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()

pub fn simd_powf(
    self,
    exp: <Complex<AutoSimd<[f64; 4]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f64; 4]>>

Raises self to a floating point power.

pub fn simd_log(self, base: AutoSimd<[f64; 4]>) -> Complex<AutoSimd<[f64; 4]>>

Returns the logarithm of self with respect to an arbitrary base.

pub fn simd_powc(
    self,
    exp: Complex<AutoSimd<[f64; 4]>>
) -> Complex<AutoSimd<[f64; 4]>>

Raises self to a complex power.

pub fn simd_sin(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the sine of self.

pub fn simd_cos(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the cosine of self.

pub fn simd_sin_cos(
    self
) -> (Complex<AutoSimd<[f64; 4]>>, Complex<AutoSimd<[f64; 4]>>)

pub fn simd_tan(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the tangent of self.

pub fn simd_asin(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of the inverse sine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Re(asin(z)) ≤ π/2.

pub fn simd_acos(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of the inverse cosine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies 0 ≤ Re(acos(z)) ≤ π.

pub fn simd_atan(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of the inverse tangent of self.

This function has two branch cuts:

• (-∞i, -i], continuous from the left.
• [i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Re(atan(z)) ≤ π/2.

pub fn simd_sinh(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the hyperbolic sine of self.

pub fn simd_cosh(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the hyperbolic cosine of self.

pub fn simd_sinh_cosh(
    self
) -> (Complex<AutoSimd<[f64; 4]>>, Complex<AutoSimd<[f64; 4]>>)

pub fn simd_tanh(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the hyperbolic tangent of self.

pub fn simd_asinh(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of inverse hyperbolic sine of self.

This function has two branch cuts:

• (-∞i, -i), continuous from the left.
• (i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Im(asinh(z)) ≤ π/2.

pub fn simd_acosh(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of inverse hyperbolic cosine of self.

This function has one branch cut:

• (-∞, 1), continuous from above.

The branch satisfies -π ≤ Im(acosh(z)) ≤ π and 0 ≤ Re(acosh(z)) < ∞.

pub fn simd_atanh(self) -> Complex<AutoSimd<[f64; 4]>>

Computes the principal value of inverse hyperbolic tangent of self.

This function has two branch cuts:

• (-∞, -1], continuous from above.
• [1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Im(atanh(z)) ≤ π/2.

pub fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

The polar form of this complex number: (modulus, arg)

pub fn simd_to_exp(self) -> (Self::SimdRealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})

pub fn simd_signum(self) -> Self

The exponential part of this complex number: self / self.modulus()

pub fn simd_sinc(self) -> Self

Cardinal sine

pub fn simd_sinhc(self) -> Self

pub fn simd_cosc(self) -> Self

Cardinal cos

pub fn simd_coshc(self) -> Self

impl SimdComplexField for Complex<AutoSimd<[f32; 16]>>

type SimdRealField = AutoSimd<[f32; 16]>

Type of the coefficients of a complex number.

pub fn from_simd_real(
    re: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 16]>>

Builds a pure-real complex number from the given value.

pub fn simd_real(
    self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

The real part of this complex number.

pub fn simd_imaginary(
    self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

The imaginary part of this complex number.

pub fn simd_argument(
    self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

The argument of this complex number.

pub fn simd_modulus(
    self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

The modulus of this complex number.

pub fn simd_modulus_squared(
    self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

The squared modulus of this complex number.

pub fn simd_norm1(
    self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

The sum of the absolute value of this complex number’s real and imaginary part.

pub fn simd_recip(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_conjugate(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_scale(
    self,
    factor: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 16]>>

Multiplies this complex number by factor.

pub fn simd_unscale(
    self,
    factor: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 16]>>

Divides this complex number by factor.

pub fn simd_floor(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_ceil(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_round(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_trunc(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_fract(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_mul_add(
    self,
    a: Complex<AutoSimd<[f32; 16]>>,
    b: Complex<AutoSimd<[f32; 16]>>
) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_abs(
    self
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

The absolute value of this complex number: self / self.signum().

pub fn simd_exp2(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_exp_m1(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_ln_1p(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_log2(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_log10(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_cbrt(self) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_powi(self, n: i32) -> Complex<AutoSimd<[f32; 16]>>

pub fn simd_exp(self) -> Complex<AutoSimd<[f32; 16]>>

Computes e^(self), where e is the base of the natural logarithm.

pub fn simd_ln(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of natural logarithm of self.

This function has one branch cut:

• (-∞, 0], continuous from above.

The branch satisfies -π ≤ arg(ln(z)) ≤ π.

pub fn simd_sqrt(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of the square root of self.

This function has one branch cut:

• (-∞, 0), continuous from above.

The branch satisfies -π/2 ≤ arg(sqrt(z)) ≤ π/2.

pub fn simd_hypot(
    self,
    b: Complex<AutoSimd<[f32; 16]>>
) -> <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField

Computes (self.conjugate() * self + other.conjugate() * other).sqrt()

pub fn simd_powf(
    self,
    exp: <Complex<AutoSimd<[f32; 16]>> as SimdComplexField>::SimdRealField
) -> Complex<AutoSimd<[f32; 16]>>

Raises self to a floating point power.

pub fn simd_log(self, base: AutoSimd<[f32; 16]>) -> Complex<AutoSimd<[f32; 16]>>

Returns the logarithm of self with respect to an arbitrary base.

pub fn simd_powc(
    self,
    exp: Complex<AutoSimd<[f32; 16]>>
) -> Complex<AutoSimd<[f32; 16]>>

Raises self to a complex power.

pub fn simd_sin(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the sine of self.

pub fn simd_cos(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the cosine of self.

pub fn simd_sin_cos(
    self
) -> (Complex<AutoSimd<[f32; 16]>>, Complex<AutoSimd<[f32; 16]>>)

pub fn simd_tan(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the tangent of self.

pub fn simd_asin(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of the inverse sine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Re(asin(z)) ≤ π/2.

pub fn simd_acos(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of the inverse cosine of self.

This function has two branch cuts:

• (-∞, -1), continuous from above.
• (1, ∞), continuous from below.

The branch satisfies 0 ≤ Re(acos(z)) ≤ π.

pub fn simd_atan(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of the inverse tangent of self.

This function has two branch cuts:

• (-∞i, -i], continuous from the left.
• [i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Re(atan(z)) ≤ π/2.

pub fn simd_sinh(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the hyperbolic sine of self.

pub fn simd_cosh(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the hyperbolic cosine of self.

pub fn simd_sinh_cosh(
    self
) -> (Complex<AutoSimd<[f32; 16]>>, Complex<AutoSimd<[f32; 16]>>)

pub fn simd_tanh(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the hyperbolic tangent of self.

pub fn simd_asinh(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of inverse hyperbolic sine of self.

This function has two branch cuts:

• (-∞i, -i), continuous from the left.
• (i, ∞i), continuous from the right.

The branch satisfies -π/2 ≤ Im(asinh(z)) ≤ π/2.

pub fn simd_acosh(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of inverse hyperbolic cosine of self.

This function has one branch cut:

• (-∞, 1), continuous from above.

The branch satisfies -π ≤ Im(acosh(z)) ≤ π and 0 ≤ Re(acosh(z)) < ∞.

pub fn simd_atanh(self) -> Complex<AutoSimd<[f32; 16]>>

Computes the principal value of inverse hyperbolic tangent of self.

This function has two branch cuts:

• (-∞, -1], continuous from above.
• [1, ∞), continuous from below.

The branch satisfies -π/2 ≤ Im(atanh(z)) ≤ π/2.

pub fn simd_to_polar(self) -> (Self::SimdRealField, Self::SimdRealField)

The polar form of this complex number: (modulus, arg)

pub fn simd_to_exp(self) -> (Self::SimdRealField, Self)

The exponential form of this complex number: (modulus, e^{i arg})

pub fn simd_signum(self) -> Self

The exponential part of this complex number: self / self.modulus()

pub fn simd_sinc(self) -> Self

Cardinal sine

pub fn simd_sinhc(self) -> Self

pub fn simd_cosc(self) -> Self

Cardinal cos

pub fn simd_coshc(self) -> Self

impl<N> SimdValue for Complex<N> where
    N: SimdValue, 

type Element = Complex<<N as SimdValue>::Element>

The type of the elements of each lane of this SIMD value.

type SimdBool = <N as SimdValue>::SimdBool

Type of the result of comparing two SIMD values like self.

pub fn lanes() -> usize

The number of lanes of this SIMD value.

pub fn splat(val: <Complex<N> as SimdValue>::Element) -> Complex<N>

Initializes an SIMD value with each lanes set to val.

pub fn extract(&self, i: usize) -> <Complex<N> as SimdValue>::Element

Extracts the i-th lane of self.

pub unsafe fn extract_unchecked(
    &self,
    i: usize
) -> <Complex<N> as SimdValue>::Element

Extracts the i-th lane of self without bound-checking.

pub fn replace(&mut self, i: usize, val: <Complex<N> as SimdValue>::Element)

Replaces the i-th lane of self by val.

pub unsafe fn replace_unchecked(
    &mut self,
    i: usize,
    val: <Complex<N> as SimdValue>::Element
)

Replaces the i-th lane of self by val without bound-checking.

pub fn select(
    self,
    cond: <Complex<N> as SimdValue>::SimdBool,
    other: Complex<N>
) -> Complex<N>

Merges self and other depending on the lanes of cond.

pub fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Self where
    Self: Clone, 

Applies a function to each lane of self.

pub fn zip_map_lanes(
    self,
    b: Self,
    f: impl Fn(Self::Element, Self::Element) -> Self::Element
) -> Self where
    Self: Clone, 

Applies a function to each lane of self paired with the corresponding lane of b.

impl<'a, T> Sub<&'a Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn sub(
    self,
    other: &Complex<T>
) -> <Complex<T> as Sub<&'a Complex<T>>>::Output

Performs the - operation.

impl<'a, 'b> Sub<&'a Complex<f32>> for &'b f32

type Output = Complex<f32>

The resulting type after applying the - operator.

pub fn sub(self, other: &Complex<f32>) -> Complex<f32>

Performs the - operation.

impl<'a> Sub<&'a Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the - operator.

pub fn sub(self, other: &Complex<f32>) -> Complex<f32>

Performs the - operation.

impl<'a, 'b, T> Sub<&'a T> for &'b Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn sub(self, other: &T) -> <&'b Complex<T> as Sub<&'a T>>::Output

Performs the - operation.

impl<'a, T> Sub<&'a T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn sub(self, other: &T) -> <Complex<T> as Sub<&'a T>>::Output

Performs the - operation.

impl<'a, 'b, T> Sub<&'b Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn sub(
    self,
    other: &Complex<T>
) -> <&'a Complex<T> as Sub<&'b Complex<T>>>::Output

Performs the - operation.

impl<'a, T> Sub<Complex<T>> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn sub(
    self,
    other: Complex<T>
) -> <&'a Complex<T> as Sub<Complex<T>>>::Output

Performs the - operation.

impl<T> Sub<Complex<T>> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn sub(self, other: Complex<T>) -> <Complex<T> as Sub<Complex<T>>>::Output

Performs the - operation.

impl Sub<Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the - operator.

pub fn sub(self, other: Complex<f32>) -> <f32 as Sub<Complex<f32>>>::Output

Performs the - operation.

impl<'a> Sub<Complex<f32>> for &'a f32

type Output = Complex<f32>

The resulting type after applying the - operator.

pub fn sub(self, other: Complex<f32>) -> Complex<f32>

Performs the - operation.

impl<'a, T> Sub<T> for &'a Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn sub(self, other: T) -> <&'a Complex<T> as Sub<T>>::Output

Performs the - operation.

impl<T> Sub<T> for Complex<T> where
    T: Clone + Num, 

type Output = Complex<T>

The resulting type after applying the - operator.

pub fn sub(self, other: T) -> <Complex<T> as Sub<T>>::Output

Performs the - operation.

impl<'a, T> SubAssign<&'a Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn sub_assign(&mut self, other: &Complex<T>)

Performs the -= operation.

impl<'a, T> SubAssign<&'a T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn sub_assign(&mut self, other: &T)

Performs the -= operation.

impl<T> SubAssign<Complex<T>> for Complex<T> where
    T: Clone + NumAssign, 

pub fn sub_assign(&mut self, other: Complex<T>)

Performs the -= operation.

impl<T> SubAssign<T> for Complex<T> where
    T: Clone + NumAssign, 

pub fn sub_assign(&mut self, other: T)

Performs the -= operation.

impl<N2> SubsetOf<Complex<N2>> for i16 where
    N2: Zero + SupersetOf<i16>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> i16

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for u128 where
    N2: Zero + SupersetOf<u128>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> u128

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for i8 where
    N2: Zero + SupersetOf<i8>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> i8

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for i64 where
    N2: Zero + SupersetOf<i64>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> i64

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for u32 where
    N2: Zero + SupersetOf<u32>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> u32

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for u8 where
    N2: Zero + SupersetOf<u8>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> u8

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for isize where
    N2: Zero + SupersetOf<isize>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> isize

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for i128 where
    N2: Zero + SupersetOf<i128>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> i128

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for u64 where
    N2: Zero + SupersetOf<u64>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> u64

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for f32 where
    N2: Zero + SupersetOf<f32>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> f32

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for i32 where
    N2: Zero + SupersetOf<i32>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> i32

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for usize where
    N2: Zero + SupersetOf<usize>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> usize

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for f64 where
    N2: Zero + SupersetOf<f64>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> f64

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N1, N2> SubsetOf<Complex<N2>> for Complex<N1> where
    N2: SupersetOf<N1>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> Complex<N1>

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<N2> SubsetOf<Complex<N2>> for u16 where
    N2: Zero + SupersetOf<u16>, 

pub fn to_superset(&self) -> Complex<N2>

The inclusion map: converts self to the equivalent element of its superset.

pub fn from_superset_unchecked(element: &Complex<N2>) -> u16

Use with care! Same as self.to_superset but without any property checks. Always succeeds.

pub fn is_in_subset(c: &Complex<N2>) -> bool

Checks if element is actually part of the subset Self (and can be converted to it).

pub fn from_superset(element: &T) -> Option<Self>

The inverse inclusion map: attempts to construct self from the equivalent element of its superset.

impl<'a, T> Sum<&'a Complex<T>> for Complex<T> where
    T: 'a + Num + Clone, 

pub fn sum<I>(iter: I) -> Complex<T> where
    I: Iterator<Item = &'a Complex<T>>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> Sum<Complex<T>> for Complex<T> where
    T: Num + Clone, 

pub fn sum<I>(iter: I) -> Complex<T> where
    I: Iterator<Item = Complex<T>>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> ToPrimitive for Complex<T> where
    T: ToPrimitive + Num, 

pub fn to_usize(&self) -> Option<usize>

Converts the value of self to a usize. If the value cannot be represented by a usize, then None is returned.

pub fn to_isize(&self) -> Option<isize>

Converts the value of self to an isize. If the value cannot be represented by an isize, then None is returned.

pub fn to_u8(&self) -> Option<u8>

Converts the value of self to a u8. If the value cannot be represented by a u8, then None is returned.

pub fn to_u16(&self) -> Option<u16>

Converts the value of self to a u16. If the value cannot be represented by a u16, then None is returned.

pub fn to_u32(&self) -> Option<u32>

Converts the value of self to a u32. If the value cannot be represented by a u32, then None is returned.

pub fn to_u64(&self) -> Option<u64>

Converts the value of self to a u64. If the value cannot be represented by a u64, then None is returned.

pub fn to_i8(&self) -> Option<i8>

Converts the value of self to an i8. If the value cannot be represented by an i8, then None is returned.

pub fn to_i16(&self) -> Option<i16>

Converts the value of self to an i16. If the value cannot be represented by an i16, then None is returned.

pub fn to_i32(&self) -> Option<i32>

Converts the value of self to an i32. If the value cannot be represented by an i32, then None is returned.

pub fn to_i64(&self) -> Option<i64>

Converts the value of self to an i64. If the value cannot be represented by an i64, then None is returned.

pub fn to_u128(&self) -> Option<u128>

Converts the value of self to a u128. If the value cannot be represented by a u128 (u64 under the default implementation), then None is returned.

pub fn to_i128(&self) -> Option<i128>

Converts the value of self to an i128. If the value cannot be represented by an i128 (i64 under the default implementation), then None is returned.

pub fn to_f32(&self) -> Option<f32>

Converts the value of self to an f32. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f32.

pub fn to_f64(&self) -> Option<f64>

Converts the value of self to an f64. Overflows may map to positive or negative inifinity, otherwise None is returned if the value cannot be represented by an f64.

impl<T> UpperExp for Complex<T> where
    T: UpperExp + Num + PartialOrd<T> + Clone, 

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

Formats the value using the given formatter.

impl<T> UpperHex for Complex<T> where
    T: UpperHex + Num + PartialOrd<T> + Clone, 

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

Formats the value using the given formatter.

impl<T> Zero for Complex<T> where
    T: Clone + Num, 

pub fn zero() -> Complex<T>

Returns the additive identity element of Self, 0.

pub fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

pub fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<T> Copy for Complex<T> where
    T: Copy, 

impl<T> Eq for Complex<T> where
    T: Eq, 

impl<N> Field for Complex<N> where
    N: SimdValue + Clone + NumAssign + ClosedNeg, 

impl<N> PrimitiveSimdValue for Complex<N> where
    N: PrimitiveSimdValue, 

impl<T> StructuralEq for Complex<T>

impl<T> StructuralPartialEq for Complex<T>