Struct 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 the imaginary unit.

See also Complex::I.

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: Float,

pub fn cis(phase: T) -> Complex<T>

Create a new Complex with a given phase: exp(i * phase). See cis (mathematics).

pub fn norm(self) -> T

Calculate |self|

pub fn arg(self) -> T

Calculate the principal Arg of self.

pub fn to_polar(self) -> (T, T)

Convert to polar form (r, theta), such that self = r * exp(i * theta)

pub fn from_polar(r: T, theta: T) -> Complex<T>

Convert a polar representation into a complex number.

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

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

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

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<T>

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 cbrt(self) -> Complex<T>

Computes the principal value of the cube root of self.

This function has one branch cut:

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

The branch satisfies -π/3 ≤ arg(cbrt(z)) ≤ π/3.

Note that this does not match the usual result for the cube root of negative real numbers. For example, the real cube root of -8 is -2, but the principal complex cube root of -8 is 1 + i√3.

pub fn powf(self, exp: T) -> Complex<T>

Raises self to a floating point power.

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

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

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

Raises self to a complex power.

pub fn expf(self, base: T) -> Complex<T>

Raises a floating point number to the complex power self.

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

Computes the sine of self.

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

Computes the cosine of self.

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

Computes the tangent of self.

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

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<T>

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<T>

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<T>

Computes the hyperbolic sine of self.

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

Computes the hyperbolic cosine of self.

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

Computes the hyperbolic tangent of self.

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

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<T>

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<T>

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 finv(self) -> Complex<T>

Returns 1/self using floating-point operations.

This may be more accurate than the generic self.inv() in cases where self.norm_sqr() would overflow to ∞ or underflow to 0.

Examples

use num_complex::Complex64;
let c = Complex64::new(1e300, 1e300);

// The generic `inv()` will overflow.
assert!(!c.inv().is_normal());

// But we can do better for `Float` types.
let inv = c.finv();
assert!(inv.is_normal());
println!("{:e}", inv);

let expected = Complex64::new(5e-301, -5e-301);
assert!((inv - expected).norm() < 1e-315);

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

Returns self/other using floating-point operations.

This may be more accurate than the generic Div implementation in cases where other.norm_sqr() would overflow to ∞ or underflow to 0.

Examples

use num_complex::Complex64;
let a = Complex64::new(2.0, 3.0);
let b = Complex64::new(1e300, 1e300);

// Generic division will overflow.
assert!(!(a / b).is_normal());

// But we can do better for `Float` types.
let quotient = a.fdiv(b);
assert!(quotient.is_normal());
println!("{:e}", quotient);

let expected = Complex64::new(2.5e-300, 5e-301);
assert!((quotient - expected).norm() < 1e-315);

impl<T> Complex<T>

where T: Float + FloatConst,

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

Computes 2^(self).

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

Computes the principal value of log base 2 of self.

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

Computes the principal value of log base 10 of self.

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

impl<T> Complex<T>

where T: ConstZero,

pub const ZERO: Complex<T>

A constant Complex 0.

impl<T> Complex<T>

where T: ConstOne + ConstZero,

pub const ONE: Complex<T>

A constant Complex 1.

pub const I: Complex<T>

A constant Complex i, the imaginary unit.

Trait Implementations

impl<T> Add for Complex<T>

where T: Clone + Num,

type Output = Complex<T>

The resulting type after applying the + operator.

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

Performs the + operation.

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.

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

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.

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.

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.

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.

fn add(self, other: Complex<T>) -> <&'a Complex<T> as Add<Complex<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.

fn add(self, other: T) -> <Complex<T> as Add<T>>::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.

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

Performs the + operation.

impl<T> AddAssign for Complex<T>

where T: Clone + NumAssign,

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

Performs the += operation.

impl<'a, T> AddAssign<&'a Complex<T>> for Complex<T>

where T: Clone + NumAssign,

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

Performs the += operation.

impl<'a, T> AddAssign<&'a T> for Complex<T>

where T: Clone + NumAssign,

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

Performs the += operation.

impl<T> AddAssign<T> for Complex<T>

where T: Clone + NumAssign,

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,

fn as_(self) -> U

Convert a value to another, using the as operator.

impl<T> Binary for Complex<T>

where T: Binary + Num + PartialOrd + Clone,

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

Formats the value using the given formatter.

impl Binary<Complex<f32>> for Equal

fn one(&self, x: Complex<f32>, y: Complex<f32>) -> bool

fn judged(&self, x: Complex<f32>, y: Complex<f32>) -> (bool, bool)

fn slice( &self, _: [Arg<'_, Complex<f32>>; 2], n: usize, out: &mut [MaybeUninit<bool>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f32>> for NotEqual

fn one(&self, x: Complex<f32>, y: Complex<f32>) -> bool

fn judged(&self, x: Complex<f32>, y: Complex<f32>) -> (bool, bool)

fn slice( &self, _: [Arg<'_, Complex<f32>>; 2], n: usize, out: &mut [MaybeUninit<bool>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f32>> for Residue

fn one(&self, x: Complex<f32>, y: Complex<f32>) -> Complex<f32>

fn judged(&self, x: Complex<f32>, y: Complex<f32>) -> (Complex<f32>, bool)

fn slice( &self, _: [Arg<'_, Complex<f32>>; 2], n: usize, out: &mut [MaybeUninit<Complex<f32>>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f32>> for Gcd

fn one(&self, x: Complex<f32>, y: Complex<f32>) -> Complex<f32>

fn judged(&self, x: Complex<f32>, y: Complex<f32>) -> (Complex<f32>, bool)

fn slice( &self, _: [Arg<'_, Complex<f32>>; 2], n: usize, out: &mut [MaybeUninit<Complex<f32>>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f32>> for Lcm

fn one(&self, x: Complex<f32>, y: Complex<f32>) -> Complex<f32>

fn judged(&self, x: Complex<f32>, y: Complex<f32>) -> (Complex<f32>, bool)

fn slice( &self, _: [Arg<'_, Complex<f32>>; 2], n: usize, out: &mut [MaybeUninit<Complex<f32>>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f64>> for Equal

fn one(&self, x: Complex<f64>, y: Complex<f64>) -> bool

fn judged(&self, x: Complex<f64>, y: Complex<f64>) -> (bool, bool)

fn slice( &self, _: [Arg<'_, Complex<f64>>; 2], n: usize, out: &mut [MaybeUninit<bool>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f64>> for NotEqual

fn one(&self, x: Complex<f64>, y: Complex<f64>) -> bool

fn judged(&self, x: Complex<f64>, y: Complex<f64>) -> (bool, bool)

fn slice( &self, _: [Arg<'_, Complex<f64>>; 2], n: usize, out: &mut [MaybeUninit<bool>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f64>> for Residue

fn one(&self, x: Complex<f64>, y: Complex<f64>) -> Complex<f64>

fn judged(&self, x: Complex<f64>, y: Complex<f64>) -> (Complex<f64>, bool)

fn slice( &self, _: [Arg<'_, Complex<f64>>; 2], n: usize, out: &mut [MaybeUninit<Complex<f64>>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f64>> for Gcd

fn one(&self, x: Complex<f64>, y: Complex<f64>) -> Complex<f64>

fn judged(&self, x: Complex<f64>, y: Complex<f64>) -> (Complex<f64>, bool)

fn slice( &self, _: [Arg<'_, Complex<f64>>; 2], n: usize, out: &mut [MaybeUninit<Complex<f64>>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Binary<Complex<f64>> for Lcm

fn one(&self, x: Complex<f64>, y: Complex<f64>) -> Complex<f64>

fn judged(&self, x: Complex<f64>, y: Complex<f64>) -> (Complex<f64>, bool)

fn slice( &self, _: [Arg<'_, Complex<f64>>; 2], n: usize, out: &mut [MaybeUninit<Complex<f64>>], ) -> bool

fn checked(&self, x: T, y: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Cast for Complex<f32>

fn cast(view: View<'_>, item: usize) -> Result<Complex<f32>, Error>

Item item of view, or an error where it doesn’t convert.

fn extend_cast( view: View<'_>, len: usize, checked: bool, out: &mut Vec<Self>, ) -> Result<(), Error>

Appends the first len items of view to out, each as Cast::cast converts it and [kept] keeps it. Element types override this with one typed loop for each source dtype they read often.

impl Cast for Complex<f64>

fn cast(view: View<'_>, item: usize) -> Result<Complex<f64>, Error>

Item item of view, or an error where it doesn’t convert.

fn extend_cast( view: View<'_>, len: usize, checked: bool, out: &mut Vec<Self>, ) -> Result<(), Error>

Appends the first len items of view to out, each as Cast::cast converts it and [kept] keeps it. Element types override this with one typed loop for each source dtype they read often.

impl<T> Clone for Complex<T>

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> ComplexFloat for Complex<T>

where T: Float + FloatConst,

type Real = T

The type used to represent the real coefficients of this complex number.

fn re(self) -> <Complex<T> as ComplexFloat>::Real

Returns the real part of the number.

fn im(self) -> <Complex<T> as ComplexFloat>::Real

Returns the imaginary part of the number.

fn abs(self) -> <Complex<T> as ComplexFloat>::Real

Returns the absolute value of the number. See also Complex::norm

fn recip(self) -> Complex<T>

Take the reciprocal (inverse) of a number, 1/x. See also Complex::finv.

fn l1_norm(&self) -> <Complex<T> as ComplexFloat>::Real

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

fn is_nan(self) -> bool

Returns true if this value is NaN and false otherwise.

fn is_infinite(self) -> bool

Returns true if this value is positive infinity or negative infinity and false otherwise.

fn is_finite(self) -> bool

Returns true if this number is neither infinite nor NaN.

fn is_normal(self) -> bool

Returns true if the number is neither zero, infinite, subnormal, or NaN.

fn arg(self) -> <Complex<T> as ComplexFloat>::Real

Computes the argument of the number.

fn powc( self, exp: Complex<<Complex<T> as ComplexFloat>::Real>, ) -> Complex<<Complex<T> as ComplexFloat>::Real>

Raises self to a complex power.

fn exp2(self) -> Complex<T>

Returns 2^(self).

fn log(self, base: <Complex<T> as ComplexFloat>::Real) -> Complex<T>

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

fn log2(self) -> Complex<T>

Returns the base 2 logarithm of the number.

fn log10(self) -> Complex<T>

Returns the base 10 logarithm of the number.

fn powf(self, f: <Complex<T> as ComplexFloat>::Real) -> Complex<T>

Raises self to a real power.

fn sqrt(self) -> Complex<T>

Take the square root of a number.

fn cbrt(self) -> Complex<T>

Take the cubic root of a number.

fn exp(self) -> Complex<T>

Returns e^(self), (the exponential function).

fn expf(self, base: <Complex<T> as ComplexFloat>::Real) -> Complex<T>

Returns base^(self).

fn ln(self) -> Complex<T>

Returns the natural logarithm of the number.

fn sin(self) -> Complex<T>

Computes the sine of a number (in radians).

fn cos(self) -> Complex<T>

Computes the cosine of a number (in radians).

fn tan(self) -> Complex<T>

Computes the tangent of a number (in radians).

fn asin(self) -> Complex<T>

Computes the arcsine of a number. Return value is in radians in the range [-pi/2, pi/2] or NaN if the number is outside the range [-1, 1].

fn acos(self) -> Complex<T>

Computes the arccosine of a number. Return value is in radians in the range [0, pi] or NaN if the number is outside the range [-1, 1].

fn atan(self) -> Complex<T>

Computes the arctangent of a number. Return value is in radians in the range [-pi/2, pi/2];

fn sinh(self) -> Complex<T>

Hyperbolic sine function.

fn cosh(self) -> Complex<T>

Hyperbolic cosine function.

fn tanh(self) -> Complex<T>

Hyperbolic tangent function.

fn asinh(self) -> Complex<T>

Inverse hyperbolic sine function.

fn acosh(self) -> Complex<T>

Inverse hyperbolic cosine function.

fn atanh(self) -> Complex<T>

Inverse hyperbolic tangent function.

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

Raises self to a signed integer power.

fn conj(self) -> Complex<T>

Computes the complex conjugate of the number.

impl<T> ConstOne for Complex<T>

where T: Clone + Num + ConstOne + ConstZero,

const ONE: Complex<T> = Self::ONE

The multiplicative identity element of Self, 1.

impl<T> ConstZero for Complex<T>

where T: Clone + Num + ConstZero,

const ZERO: Complex<T> = Self::ZERO

The additive identity element of Self, 0.

impl<T> Copy for Complex<T>

where T: Copy,

impl<T> Debug for Complex<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Complex<T>

where T: Default,

fn default() -> Complex<T>

Returns the “default value” for a type.

impl<T> Display for Complex<T>

where T: Display + Num + PartialOrd + Clone,

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

Formats the value using the given formatter.

impl<T> Div for Complex<T>

where T: Clone + Num,

type Output = Complex<T>

The resulting type after applying the / operator.

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

Performs the / operation.

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.

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

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.

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.

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.

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.

fn div(self, other: Complex<T>) -> <&'a Complex<T> as Div<Complex<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.

fn div(self, other: T) -> <Complex<T> as Div<T>>::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.

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

Performs the / operation.

impl<T> DivAssign for Complex<T>

where T: Clone + NumAssign,

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

Performs the /= operation.

impl<'a, T> DivAssign<&'a Complex<T>> for Complex<T>

where T: Clone + NumAssign,

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

Performs the /= operation.

impl<'a, T> DivAssign<&'a T> for Complex<T>

where T: Clone + NumAssign,

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

Performs the /= operation.

impl<T> DivAssign<T> for Complex<T>

where T: Clone + NumAssign,

fn div_assign(&mut self, other: T)

Performs the /= operation.

impl Element for Complex<f32>

const FILL: Complex<f32>

The item that a missing keyed entry reads as: zero, false or a space.

const DTYPE: DType

The dtype of buffers of this type.

fn of(view: View<'_>) -> Option<&[Complex<f32>]>

The items of view, when they have this type.

fn of_mut(buffer: &mut Buffer) -> Option<&mut [Complex<f32>]>

The writable items of buffer, when they have this type. The allocation and length don’t change.

fn view(items: &[Complex<f32>]) -> View<'_>

items as a view.

fn buffer(data: Vec<Complex<f32>>) -> Buffer

A buffer that holds data.

fn vec(buffer: Buffer) -> Option<Vec<Complex<f32>>>

The items of buffer, moved out, when they have this type.

fn vec_mut(buffer: &mut Buffer) -> Option<&mut Vec<Complex<f32>>>

The items of buffer as their vector, when they have this type, for a writer that appends or clears them.

fn truth(b: bool) -> Complex<f32>

b as an item of this type: 1 or 0 for a number, the Boolean itself, or the characters U+0001 and U+0000. A Boolean mask becomes lanes of the items that a kernel such as Choose chooses between. A number converts through an integer, which suits stored Booleans. A comparison’s lane mask turns into 1 or 0 faster by a choice between the two, so Indicator writes its own (tolerant::indicated).

impl Element for Complex<f64>

const FILL: Complex<f64>

The item that a missing keyed entry reads as: zero, false or a space.

const DTYPE: DType

The dtype of buffers of this type.

fn of(view: View<'_>) -> Option<&[Complex<f64>]>

The items of view, when they have this type.

fn of_mut(buffer: &mut Buffer) -> Option<&mut [Complex<f64>]>

The writable items of buffer, when they have this type. The allocation and length don’t change.

fn view(items: &[Complex<f64>]) -> View<'_>

items as a view.

fn buffer(data: Vec<Complex<f64>>) -> Buffer

A buffer that holds data.

fn vec(buffer: Buffer) -> Option<Vec<Complex<f64>>>

The items of buffer, moved out, when they have this type.

fn vec_mut(buffer: &mut Buffer) -> Option<&mut Vec<Complex<f64>>>

The items of buffer as their vector, when they have this type, for a writer that appends or clears them.

fn truth(b: bool) -> Complex<f64>

b as an item of this type: 1 or 0 for a number, the Boolean itself, or the characters U+0001 and U+0000. A Boolean mask becomes lanes of the items that a kernel such as Choose chooses between. A number converts through an integer, which suits stored Booleans. A comparison’s lane mask turns into 1 or 0 faster by a choice between the two, so Indicator writes its own (tolerant::indicated).

impl<T> Eq for Complex<T>

where T: Eq,

impl Factor for Complex<f32>

fn matrix_lu_into(a: &[Complex<f32>], n: usize, work: &mut LuWork<Complex<f32>>)

The LU factorization of the n×n matrix a, into work’s buffers.

fn matrix_lu_solve( lu: Lu<Complex<f32>, &[Complex<f32>], &[usize]>, b: &[Complex<f32>], k: usize, ) -> Vec<Complex<f32>>

The solution of a x = b for the matrix that lu factors and the n×k matrix b.

fn matrix_lu_inverse_into( lu: Lu<Complex<f32>, &[Complex<f32>], &[usize]>, x: &mut Vec<Complex<f32>>, out: &mut [Complex<f32>], )

The inverse of the matrix that lu factors, written into out, with x as scratch.

fn matrix_cholesky(a: &[Complex<f32>], n: usize) -> Option<Vec<Complex<f32>>>

The Cholesky factor of the n×n matrix a, or None where a isn’t positive definite.

fn matrix_qr( a: &[Complex<f32>], size: [usize; 2], complete: bool, ) -> (Vec<Complex<f32>>, Vec<Complex<f32>>)

The QR factorization of the matrix a of size [m, n]: thin, or complete where complete is true.

fn matrix_qr_into( a: &[Complex<f32>], size: [usize; 2], complete: bool, work: &mut QrWork<Complex<f32>>, q: &mut [Complex<f32>], r: &mut [Complex<f32>], )

matrix_qr’s Q and R, written into q and r, with work’s buffers.

fn matrix_svd( a: &[Complex<f32>], size: [usize; 2], vectors: bool, ) -> Svd<Complex<f32>>

The thin SVD of the matrix a of size [m, n], with its singular vectors only where vectors is true.

fn matrix_truncated_svd( a: &[Complex<f32>], size: [usize; 2], k: usize, ) -> Svd<Complex<f32>>

An approximation to the thin SVD’s first k singular values and vectors of the matrix a of size [m, n].

fn matrix_svd_solve( svd: Svd<Complex<f32>, &[Complex<f32>], &[<Complex<f32> as Scalar>::Real]>, b: Option<&[Complex<f32>]>, k: usize, ) -> Vec<Complex<f32>>

The least-squares solution of a x = b for the matrix that svd factors and the m×k matrix b, or without b its n×m pseudoinverse.

fn matrix_lstsq( a: &[Complex<f32>], b: &[Complex<f32>], size: [usize; 2], k: usize, ) -> (Vec<Complex<f32>>, Vec<<Complex<f32> as Scalar>::Real>)

The least-squares solution of a x = b, and a’s singular values, for the matrix a of size [m, n] and the m×k matrix b.

fn matrix_eigh( a: &[Complex<f32>], n: usize, vectors: bool, ) -> Option<Eigh<Complex<f32>>>

The eigen decomposition of the Hermitian n×n matrix a, from its lower triangle, with its eigenvectors only where vectors is true, or None where it doesn’t converge.

fn matrix_eig( a: &[Complex<f32>], n: usize, vectors: bool, ) -> Option<Eig<<Complex<f32> as Scalar>::Real>>

The eigen decomposition of the n×n matrix a, with its eigenvectors only where vectors is true, or None where it doesn’t converge.

impl Factor for Complex<f64>

fn matrix_lu_into(a: &[Complex<f64>], n: usize, work: &mut LuWork<Complex<f64>>)

The LU factorization of the n×n matrix a, into work’s buffers.

fn matrix_lu_solve( lu: Lu<Complex<f64>, &[Complex<f64>], &[usize]>, b: &[Complex<f64>], k: usize, ) -> Vec<Complex<f64>>

The solution of a x = b for the matrix that lu factors and the n×k matrix b.

fn matrix_lu_inverse_into( lu: Lu<Complex<f64>, &[Complex<f64>], &[usize]>, x: &mut Vec<Complex<f64>>, out: &mut [Complex<f64>], )

The inverse of the matrix that lu factors, written into out, with x as scratch.

fn matrix_cholesky(a: &[Complex<f64>], n: usize) -> Option<Vec<Complex<f64>>>

The Cholesky factor of the n×n matrix a, or None where a isn’t positive definite.

fn matrix_qr( a: &[Complex<f64>], size: [usize; 2], complete: bool, ) -> (Vec<Complex<f64>>, Vec<Complex<f64>>)

The QR factorization of the matrix a of size [m, n]: thin, or complete where complete is true.

fn matrix_qr_into( a: &[Complex<f64>], size: [usize; 2], complete: bool, work: &mut QrWork<Complex<f64>>, q: &mut [Complex<f64>], r: &mut [Complex<f64>], )

matrix_qr’s Q and R, written into q and r, with work’s buffers.

fn matrix_svd( a: &[Complex<f64>], size: [usize; 2], vectors: bool, ) -> Svd<Complex<f64>>

The thin SVD of the matrix a of size [m, n], with its singular vectors only where vectors is true.

fn matrix_truncated_svd( a: &[Complex<f64>], size: [usize; 2], k: usize, ) -> Svd<Complex<f64>>

An approximation to the thin SVD’s first k singular values and vectors of the matrix a of size [m, n].

fn matrix_svd_solve( svd: Svd<Complex<f64>, &[Complex<f64>], &[<Complex<f64> as Scalar>::Real]>, b: Option<&[Complex<f64>]>, k: usize, ) -> Vec<Complex<f64>>

The least-squares solution of a x = b for the matrix that svd factors and the m×k matrix b, or without b its n×m pseudoinverse.

fn matrix_lstsq( a: &[Complex<f64>], b: &[Complex<f64>], size: [usize; 2], k: usize, ) -> (Vec<Complex<f64>>, Vec<<Complex<f64> as Scalar>::Real>)

The least-squares solution of a x = b, and a’s singular values, for the matrix a of size [m, n] and the m×k matrix b.

fn matrix_eigh( a: &[Complex<f64>], n: usize, vectors: bool, ) -> Option<Eigh<Complex<f64>>>

The eigen decomposition of the Hermitian n×n matrix a, from its lower triangle, with its eigenvectors only where vectors is true, or None where it doesn’t converge.

fn matrix_eig( a: &[Complex<f64>], n: usize, vectors: bool, ) -> Option<Eig<<Complex<f64> as Scalar>::Real>>

The eigen decomposition of the n×n matrix a, with its eigenvectors only where vectors is true, or None where it doesn’t converge.

impl<'a, T> From<&'a T> for Complex<T>

where T: Clone + Num,

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

Converts to this type from the input type.

impl<T> From<T> for Complex<T>

where T: Clone + Num,

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

Converts to this type from the input type.

impl<T> FromPrimitive for Complex<T>

where T: FromPrimitive + Num,

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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,

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

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

The associated error which can be returned from parsing.

impl<T> Hash for Complex<T>

where T: Hash,

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

where __H: Hasher,

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Inner<Complex<f32>> for PlusTimes

type Out = Complex<f32>

The type of each result.

fn inner_ops( &self, a: &[Complex<f32>], b: &[Complex<f32>], _: [Orientation; 2], _: [usize; 3], ) -> Vec<Complex<f32>>

inner of the matrices that a and b give in the orientations given, with size [m, k, n] for those matrices. A transposed a holds a k×m matrix, row-major, and gives its m×k transpose. This default copies a transposed operand into its orientation. Float and complex PlusTimes read it in place.

fn inner_into( &self, a: &[Complex<f32>], b: &[Complex<f32>], _: [usize; 3], c: &mut [Complex<f32>], )

The m×n inner product of a, an m×k matrix, and b, a k×n matrix, both row-major, written row-major into out, which holds m×n items. size is [m, k, n]. Where k is 0, each result is the identity of f. An integer result that doesn’t fit its type panics, where checked_into gives false.

fn inner_mapped_into( &self, a: Mapped<'_, Complex<f32>>, b: Mapped<'_, Complex<f32>>, orientations: [Orientation; 2], size: [usize; 3], out: &mut [Complex<f32>], )

inner_into of operands whose items come through mappings, as Mapped describes. This default reads each operand whole and copies transposed operands into their orientations. Float and complex PlusTimes read an operand that isn’t held in order one block of its stored rows at a time and multiply each block as it’s read. Only one block of that operand then exists at once.

fn inner(&self, a: &[T], b: &[T], size: [usize; 3]) -> Vec<Self::Out>

inner_into’s results, as a new row-major matrix.

fn checked_into( &self, a: &[T], b: &[T], size: [usize; 3], out: &mut [Self::Out], ) -> bool

inner_into, or false where an integer result doesn’t fit its type, for callers that keep integers exact or report overflow. Where it gives true, out holds the exact results. Floats always give true.

fn inner_mapped( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, orientations: [Orientation; 2], size: [usize; 3], ) -> Vec<Self::Out>

where T: Element,

inner_mapped_into’s results, as a new row-major matrix.

impl Inner<Complex<f64>> for PlusTimes

type Out = Complex<f64>

The type of each result.

fn inner_ops( &self, a: &[Complex<f64>], b: &[Complex<f64>], _: [Orientation; 2], _: [usize; 3], ) -> Vec<Complex<f64>>

inner of the matrices that a and b give in the orientations given, with size [m, k, n] for those matrices. A transposed a holds a k×m matrix, row-major, and gives its m×k transpose. This default copies a transposed operand into its orientation. Float and complex PlusTimes read it in place.

fn inner_into( &self, a: &[Complex<f64>], b: &[Complex<f64>], _: [usize; 3], c: &mut [Complex<f64>], )

The m×n inner product of a, an m×k matrix, and b, a k×n matrix, both row-major, written row-major into out, which holds m×n items. size is [m, k, n]. Where k is 0, each result is the identity of f. An integer result that doesn’t fit its type panics, where checked_into gives false.

fn inner_mapped_into( &self, a: Mapped<'_, Complex<f64>>, b: Mapped<'_, Complex<f64>>, orientations: [Orientation; 2], size: [usize; 3], out: &mut [Complex<f64>], )

inner_into of operands whose items come through mappings, as Mapped describes. This default reads each operand whole and copies transposed operands into their orientations. Float and complex PlusTimes read an operand that isn’t held in order one block of its stored rows at a time and multiply each block as it’s read. Only one block of that operand then exists at once.

fn inner(&self, a: &[T], b: &[T], size: [usize; 3]) -> Vec<Self::Out>

inner_into’s results, as a new row-major matrix.

fn checked_into( &self, a: &[T], b: &[T], size: [usize; 3], out: &mut [Self::Out], ) -> bool

inner_into, or false where an integer result doesn’t fit its type, for callers that keep integers exact or report overflow. Where it gives true, out holds the exact results. Floats always give true.

fn inner_mapped( &self, a: Mapped<'_, T>, b: Mapped<'_, T>, orientations: [Orientation; 2], size: [usize; 3], ) -> Vec<Self::Out>

where T: Element,

inner_mapped_into’s results, as a new row-major matrix.

impl<T> Inv for Complex<T>

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

type Output = Complex<T>

The result after applying the operator.

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.

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

Returns the multiplicative inverse of self.

impl<F> Inverse<Complex<F>> for Sum

where F: Native,

fn inverse(acc: Complex<F>, x: Complex<F>) -> (Complex<F>, bool)

acc with the item x taken away, and whether it fits.

fn undo(a: Complex<F>, b: Complex<F>) -> (Complex<F>, bool)

The fold a with the fold b of the next run taken away, and whether it fits.

fn alternating(x: &[Complex<F>]) -> (Complex<F>, bool)

The right fold of the slice x by the inverse, and whether it fits: for sums through a sum at each parity (alternated), and for products through the pairs’ quotients (pairwise).

fn fits(_: Self::Total) -> bool

Whether a running total fits, as every one does apart from a float quotient outside the normal range.

impl<F> Inverse<Complex<F>> for Product

where F: Native,

Product’s inverse on complex numbers, which divides as crate::divide does.

fn inverse(acc: Complex<F>, x: Complex<F>) -> (Complex<F>, bool)

acc with the item x taken away, and whether it fits.

fn undo(a: Complex<F>, b: Complex<F>) -> (Complex<F>, bool)

The fold a with the fold b of the next run taken away, and whether it fits.

fn fits(q: Complex<F>) -> bool

Whether a running total fits, as every one does apart from a float quotient outside the normal range.

fn alternating(x: &[Complex<F>]) -> (Complex<F>, bool)

The right fold of the slice x by the inverse, and whether it fits: for sums through a sum at each parity (alternated), and for products through the pairs’ quotients (pairwise).

impl Item for Complex<f32>

type Unit = [u32; 2]

The unit that holds an item’s bytes.

fn cells_from<S, C>( _out: &mut [Self], _items: &[S], _conv: &C, _at: usize, _step: isize, _rest: &[Cow<'_, Steps>], ) -> bool

where S: Item, C: Convert<S, Self>,

Writes items into out, each converted by conv: one cell at each start along a stride of step from at, with its items at the offsets that rest reaches. Gives whether a fixed-width loop that converts from S wrote them. Only f64 has such loops, for the sources whose Item::cells_into_f64 has one. Otherwise scatter_walk converts a block at a time.

fn cells_into_f64<C>( _out: &mut [f64], _items: &[Self], _conv: &C, _at: usize, _step: isize, _rest: &[Cow<'_, Steps>], ) -> bool

where C: Convert<Self, f64>,

Item::cells_from from this type into f64.

impl Item for Complex<f64>

type Unit = [u64; 2]

The unit that holds an item’s bytes.

fn cells_from<S, C>( _out: &mut [Self], _items: &[S], _conv: &C, _at: usize, _step: isize, _rest: &[Cow<'_, Steps>], ) -> bool

where S: Item, C: Convert<S, Self>,

Writes items into out, each converted by conv: one cell at each start along a stride of step from at, with its items at the offsets that rest reaches. Gives whether a fixed-width loop that converts from S wrote them. Only f64 has such loops, for the sources whose Item::cells_into_f64 has one. Otherwise scatter_walk converts a block at a time.

fn cells_into_f64<C>( _out: &mut [f64], _items: &[Self], _conv: &C, _at: usize, _step: isize, _rest: &[Cow<'_, Steps>], ) -> bool

where C: Convert<Self, f64>,

Item::cells_from from this type into f64.

impl KernelItem for Complex<f32>

const NAN: bool = true

Whether the type has NaN, as floats and complex numbers do.

fn has_nan(self) -> bool

Whether this item is NaN, or for a complex number has a NaN part. An integer or Boolean never is.

impl KernelItem for Complex<f64>

const NAN: bool = true

Whether the type has NaN, as floats and complex numbers do.

fn has_nan(self) -> bool

Whether this item is NaN, or for a complex number has a NaN part. An integer or Boolean never is.

impl<T> LowerExp for Complex<T>

where T: LowerExp + Num + PartialOrd + Clone,

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 + Clone,

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

Formats the value using the given formatter.

impl<T> Mul for Complex<T>

where T: Clone + Num,

type Output = Complex<T>

The resulting type after applying the * operator.

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

Performs the * operation.

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.

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

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.

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.

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.

fn mul( self, other: &Complex<T>, ) -> <&'a Complex<T> as Mul<&'b 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.

fn mul(self, other: Complex<T>) -> <&'a Complex<T> as Mul<Complex<T>>>::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.

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.

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

Performs the * operation.

impl<T> MulAdd for Complex<T>

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

type Output = Complex<T>

The resulting type after applying the fused multiply-add.

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

Performs the fused multiply-add operation (self * a) + b

impl<'a, 'b, T> MulAdd<&'b Complex<T>> for &'a Complex<T>

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

type Output = Complex<T>

The resulting type after applying the fused multiply-add.

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

Performs the fused multiply-add operation (self * a) + b

impl<T> MulAddAssign for Complex<T>

where T: Clone + NumAssign + MulAddAssign,

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

Performs the fused multiply-add assignment operation *self = (*self * a) + b

impl<'a, 'b, T> MulAddAssign<&'a Complex<T>, &'b Complex<T>> for Complex<T>

where T: Clone + NumAssign + MulAddAssign,

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

Performs the fused multiply-add assignment operation *self = (*self * a) + b

impl<T> MulAssign for Complex<T>

where T: Clone + NumAssign,

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

Performs the *= operation.

impl<'a, T> MulAssign<&'a Complex<T>> for Complex<T>

where T: Clone + NumAssign,

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

Performs the *= operation.

impl<'a, T> MulAssign<&'a T> for Complex<T>

where T: Clone + NumAssign,

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

Performs the *= operation.

impl<T> MulAssign<T> for Complex<T>

where T: Clone + NumAssign,

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.

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.

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

Performs the unary - operation.

impl<T> Num for Complex<T>

where T: Num + Clone,

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

radix must be <= 18; larger radix would include i and j as digits, which cannot be supported.

The conversion returns an error if 18 <= radix <= 36; it panics if radix > 36.

The elements of T are parsed using Num::from_str_radix too, and errors (or panics) from that are reflected here as well.

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

impl<T> NumCast for Complex<T>

where T: NumCast + Num,

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 + Clone,

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,

fn one() -> Complex<T>

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

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

impl OutputItem for Complex<f32>

fn slots<'s, 'b>( output: &'s mut MapOutput<'_, 'b>, ) -> Option<&'s mut Slots<'b, Complex<f32>>>

impl OutputItem for Complex<f64>

fn slots<'s, 'b>( output: &'s mut MapOutput<'_, 'b>, ) -> Option<&'s mut Slots<'b, Complex<f64>>>

impl<T> PartialEq for Complex<T>

where T: PartialEq,

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

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<'a, 'b, T> Pow<&'b Complex<T>> for &'a Complex<T>

where T: Float,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

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

Returns self to the power rhs.

impl<'b, T> Pow<&'b Complex<T>> for Complex<T>

where T: Float,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

fn pow(self, _: &'b Complex<T>) -> <Complex<T> as Pow<&'b Complex<T>>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b f32> for &'a Complex<T>

where T: Float, f32: Into<T>,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

fn pow(self, _: &f32) -> <&'a Complex<T> as Pow<&'b f32>>::Output

Returns self to the power rhs.

impl<'b, T> Pow<&'b f32> for Complex<T>

where T: Float, f32: Into<T>,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

fn pow(self, _: &f32) -> <Complex<T> as Pow<&'b f32>>::Output

Returns self to the power rhs.

impl<'a, 'b, T> Pow<&'b f64> for &'a Complex<T>

where T: Float, f64: Into<T>,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

fn pow(self, _: &f64) -> <&'a Complex<T> as Pow<&'b f64>>::Output

Returns self to the power rhs.

impl<'b, T> Pow<&'b f64> for Complex<T>

where T: Float, f64: Into<T>,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

fn pow(self, _: &f64) -> <Complex<T> as Pow<&'b f64>>::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.

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 i16> for &'a Complex<T>

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

type Output = Complex<T>

The result after applying the operator.

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.

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.

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 i128> for &'a Complex<T>

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

type Output = Complex<T>

The result after applying the operator.

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 isize> for &'a Complex<T>

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

type Output = Complex<T>

The result after applying the operator.

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 u8> for &'a Complex<T>

where T: Clone + Num,

type Output = Complex<T>

The result after applying the operator.

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 u16> for &'a Complex<T>

where T: Clone + Num,

type Output = Complex<T>

The result after applying the operator.

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.

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.

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 u128> for &'a Complex<T>

where T: Clone + Num,

type Output = Complex<T>

The result after applying the operator.

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 usize> for &'a Complex<T>

where T: Clone + Num,

type Output = Complex<T>

The result after applying the operator.

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

Returns self to the power rhs.

impl<'a, T> Pow<Complex<T>> for &'a Complex<T>

where T: Float,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

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

Returns self to the power rhs.

impl<T> Pow<Complex<T>> for Complex<T>

where T: Float,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

fn pow(self, exp: Complex<T>) -> <Complex<T> as Pow<Complex<T>>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<f32> for &'a Complex<T>

where T: Float, f32: Into<T>,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

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

Returns self to the power rhs.

impl<T> Pow<f32> for Complex<T>

where T: Float, f32: Into<T>,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

fn pow(self, exp: f32) -> <Complex<T> as Pow<f32>>::Output

Returns self to the power rhs.

impl<'a, T> Pow<f64> for &'a Complex<T>

where T: Float, f64: Into<T>,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

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

Returns self to the power rhs.

impl<T> Pow<f64> for Complex<T>

where T: Float, f64: Into<T>,

Available on crate features libm or std only.

type Output = Complex<T>

The result after applying the operator.

fn pow(self, exp: f64) -> <Complex<T> as Pow<f64>>::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.

fn pow(self, exp: i8) -> <&'a Complex<T> as Pow<i8>>::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.

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.

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.

fn pow(self, exp: i64) -> <&'a Complex<T> as Pow<i64>>::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.

fn pow(self, exp: i128) -> <&'a Complex<T> as Pow<i128>>::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.

fn pow(self, exp: isize) -> <&'a Complex<T> as Pow<isize>>::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.

fn pow(self, exp: u8) -> <&'a Complex<T> as Pow<u8>>::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.

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.

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.

fn pow(self, exp: u64) -> <&'a Complex<T> as Pow<u64>>::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.

fn pow(self, exp: u128) -> <&'a Complex<T> as Pow<u128>>::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.

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

Returns self to the power rhs.

impl<T> Product for Complex<T>

where T: Num + Clone,

fn product<I>(iter: I) -> Complex<T>

where I: Iterator<Item = Complex<T>>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'a, T> Product<&'a Complex<T>> for Complex<T>

where T: 'a + Num + Clone,

fn product<I>(iter: I) -> Complex<T>

where I: Iterator<Item = &'a Complex<T>>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<F> Reduction<Complex<F>> for Sum

where F: Native,

Each sum of complex numbers adds their real parts and their imaginary parts, in any order.

const COMMUTATIVE: bool = true

Whether disjoint subsequences may be merged in any order.

type Total = Complex<F>

The type of a fold: the item type, i64 for a sum or product of integers narrower than 64 bits, f32 for a sum or product of f16s, i16 for an XNOR of bytes, the C of SumAs, f64 for Squares, a Scaled product for ScaledProduct, or a total with the parity of its count for Alternated.

fn unit() -> Complex<F>

The fold of no items: 0, 1, -∞ or ∞, the integer type’s least or greatest value, all ones, or false or true.

fn step(acc: Complex<F>, x: Complex<F>) -> Complex<F>

acc combined with one more item.

fn merge(a: Complex<F>, b: Complex<F>) -> (Complex<F>, bool)

The folds of two neighbouring runs of items combined into the fold of both, and whether it fits.

fn identity() -> Complex<F>

The exact identity of step, which leaves every total unchanged. For float sums it’s -0.0, because adding unit(), 0.0, turns a total of -0.0 into 0.0. For every other reduction it’s unit().

fn slice(x: &[Complex<F>]) -> (Complex<F>, bool)

The fold of x, which is unit() where x is empty, and whether it fits. The default takes each item in turn by checked.

fn scan( x: &[Complex<F>], start: Option<Complex<F>>, out: &mut Vec<Complex<F>>, ) -> bool

Appends the running folds of x to out, the first combining start where it is given, and gives whether every one fits. The default takes each item in turn by checked (checked_steps).

fn checked(acc: Self::Total, x: T) -> (Self::Total, bool)

step, and whether its result fits. An integer sum or product wraps where it doesn’t.

fn one(x: T) -> (Self::Total, bool)

The fold of the one item x, checked(identity(), x), and whether it fits.

fn chain(a: Self::Total, b: Self::Total) -> (Self::Total, bool)

merge, for a chain of folds whose every step waits for the one before, as van Herk-Gil-Werman’s suffixes and prefixes do. As in merge, a folds the earlier items. Float maximums and minimums override it with Folds::step_max and step_min, which use AArch64’s one-instruction fmaxnm and fminnm. LLVM can’t vectorize those, so they stay out of merge.

fn rows(data: &[T], columns: usize, out: &mut [Self::Total]) -> bool

where Self: Sized, T: Copy,

Folds each row of data, a matrix with columns items in each row, into the matching item of out, and gives whether every fold fits. The default is fold_rows, which folds each row of 16 items or more by slice. Float sums and products, integer maximums and minimums, and bitwise folds fold rows of 16 to 63 items by checked instead, eight rows side by side (rows_side_by_side). Each of their steps is one instruction, so keeping several rows’ steps in flight costs less than a call of slice for each row. Other reductions keep fold_rows, where slice vectorizes within the row: an integer sum’s step checks for overflow, and a float maximum’s or minimum’s slice runs Folds’ vector kernels. Nobody has timed float maximums side by side since their step became one select on x86.

fn short_lanes( _data: &[T], _len: usize, _start: Option<Self::Total>, _out: &mut Vec<Self::Total>, ) -> Option<bool>

where Self: Sized,

Appends the running folds of data’s lanes of len consecutive items to out, each lane from start, through a route that runs many short lanes at once, and gives whether every fold fits. A reduction without such a route gives None and appends nothing, as the default does. scan_along then runs the lanes itself. The Boolean reductions run lanes of 1 to 64 items through Logical, 64 items to a word.

const SPLIT: usize = 8

The most classes for which crate::search::ClassNumbers folds each class into four totals by position. Each step of a class’s total waits on the last through memory, so a reduction whose step takes longer gains from the split over more classes.

impl<F> Reduction<Complex<F>> for Product

where F: Native,

Complex products regroup multiplication through the same running totals as real products.

const COMMUTATIVE: bool = true

Whether disjoint subsequences may be merged in any order.

type Total = Complex<F>

The type of a fold: the item type, i64 for a sum or product of integers narrower than 64 bits, f32 for a sum or product of f16s, i16 for an XNOR of bytes, the C of SumAs, f64 for Squares, a Scaled product for ScaledProduct, or a total with the parity of its count for Alternated.

fn unit() -> Complex<F>

The fold of no items: 0, 1, -∞ or ∞, the integer type’s least or greatest value, all ones, or false or true.

fn step(acc: Complex<F>, x: Complex<F>) -> Complex<F>

acc combined with one more item.

fn merge(a: Complex<F>, b: Complex<F>) -> (Complex<F>, bool)

The folds of two neighbouring runs of items combined into the fold of both, and whether it fits.

fn slice(x: &[Complex<F>]) -> (Complex<F>, bool)

The fold of x, which is unit() where x is empty, and whether it fits. The default takes each item in turn by checked.

fn scan( x: &[Complex<F>], start: Option<Complex<F>>, out: &mut Vec<Complex<F>>, ) -> bool

Appends the running folds of x to out, the first combining start where it is given, and gives whether every one fits. The default takes each item in turn by checked (checked_steps).

fn identity() -> Self::Total

The exact identity of step, which leaves every total unchanged. For float sums it’s -0.0, because adding unit(), 0.0, turns a total of -0.0 into 0.0. For every other reduction it’s unit().

fn checked(acc: Self::Total, x: T) -> (Self::Total, bool)

step, and whether its result fits. An integer sum or product wraps where it doesn’t.

fn one(x: T) -> (Self::Total, bool)

The fold of the one item x, checked(identity(), x), and whether it fits.

fn chain(a: Self::Total, b: Self::Total) -> (Self::Total, bool)

merge, for a chain of folds whose every step waits for the one before, as van Herk-Gil-Werman’s suffixes and prefixes do. As in merge, a folds the earlier items. Float maximums and minimums override it with Folds::step_max and step_min, which use AArch64’s one-instruction fmaxnm and fminnm. LLVM can’t vectorize those, so they stay out of merge.

fn rows(data: &[T], columns: usize, out: &mut [Self::Total]) -> bool

where Self: Sized, T: Copy,

Folds each row of data, a matrix with columns items in each row, into the matching item of out, and gives whether every fold fits. The default is fold_rows, which folds each row of 16 items or more by slice. Float sums and products, integer maximums and minimums, and bitwise folds fold rows of 16 to 63 items by checked instead, eight rows side by side (rows_side_by_side). Each of their steps is one instruction, so keeping several rows’ steps in flight costs less than a call of slice for each row. Other reductions keep fold_rows, where slice vectorizes within the row: an integer sum’s step checks for overflow, and a float maximum’s or minimum’s slice runs Folds’ vector kernels. Nobody has timed float maximums side by side since their step became one select on x86.

fn short_lanes( _data: &[T], _len: usize, _start: Option<Self::Total>, _out: &mut Vec<Self::Total>, ) -> Option<bool>

where Self: Sized,

Appends the running folds of data’s lanes of len consecutive items to out, each lane from start, through a route that runs many short lanes at once, and gives whether every fold fits. A reduction without such a route gives None and appends nothing, as the default does. scan_along then runs the lanes itself. The Boolean reductions run lanes of 1 to 64 items through Logical, 64 items to a word.

const SPLIT: usize = 8

The most classes for which crate::search::ClassNumbers folds each class into four totals by position. Each step of a class’s total waits on the last through memory, so a reduction whose step takes longer gains from the split over more classes.

impl<T> Rem for Complex<T>

where T: Clone + Num,

type Output = Complex<T>

The resulting type after applying the % operator.

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

Performs the % operation.

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.

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

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.

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.

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.

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.

fn rem(self, other: Complex<T>) -> <&'a Complex<T> as Rem<Complex<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.

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

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.

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

Performs the % operation.

impl<T> RemAssign for Complex<T>

where T: Clone + NumAssign,

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

Performs the %= operation.

impl<'a, T> RemAssign<&'a Complex<T>> for Complex<T>

where T: Clone + NumAssign,

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

Performs the %= operation.

impl<'a, T> RemAssign<&'a T> for Complex<T>

where T: Clone + NumAssign,

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

Performs the %= operation.

impl<T> RemAssign<T> for Complex<T>

where T: Clone + NumAssign,

fn rem_assign(&mut self, other: T)

Performs the %= operation.

impl Results<Complex<f32>, 1> for Floor

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f32>

The type of each result.

impl Results<Complex<f32>, 1> for Ceil

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f32>

The type of each result.

impl Results<Complex<f32>, 2> for Equal

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = bool

The type of each result.

impl Results<Complex<f32>, 2> for NotEqual

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = bool

The type of each result.

impl Results<Complex<f32>, 2> for Residue

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f32>

The type of each result.

impl Results<Complex<f32>, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f32>

The type of each result.

impl Results<Complex<f32>, 2> for Lcm

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f32>

The type of each result.

impl Results<Complex<f32>, 3> for Choose

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f32>

The type of each result.

impl Results<Complex<f64>, 1> for Floor

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f64>

The type of each result.

impl Results<Complex<f64>, 1> for Ceil

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f64>

The type of each result.

impl Results<Complex<f64>, 2> for Equal

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = bool

The type of each result.

impl Results<Complex<f64>, 2> for NotEqual

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = bool

The type of each result.

impl Results<Complex<f64>, 2> for Residue

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f64>

The type of each result.

impl Results<Complex<f64>, 2> for Gcd

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f64>

The type of each result.

impl Results<Complex<f64>, 2> for Lcm

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f64>

The type of each result.

impl Results<Complex<f64>, 3> for Choose

const TOTAL: bool

Whether no result fails: checked always gives Some, and many and many_into always give true. A total float function gives NaN from arguments that aren’t NaN only where NaN is its value, as Subtract gives for ∞ - ∞ and Sin for ±∞.

type Out = Complex<f64>

The type of each result.

impl<T> Scalar for Complex<T>

where T: Native,

const COMPLEX: bool = true

Whether the type is complex, with a real and an imaginary part.

type Real = T

The type of the real and imaginary parts.

fn conj(self) -> Complex<T>

fn re(self) -> T

fn im(self) -> T

fn from_real(x: T) -> Complex<T>

fn abs1(self) -> T

|re| + |im|, within a factor of √2 of the modulus and cheaper. Pivot searches and scaling compare it.

fn modulus(self) -> T

|self|, computed without overflow where the result fits, as hypot computes it.

fn mul_real(self, x: T) -> Complex<T>

fn div_real(self, x: T) -> Complex<T>

fn mul_acc(self, b: Complex<T>, c: Complex<T>) -> Complex<T>

self × b + c, each multiply-add rounding once where FUSED is true, as Core::mla does.

fn reciprocal(self) -> Complex<T>

fn quotient(self, d: Complex<T>) -> Complex<T>

self / d. A complex quotient halves operands near overflow and scales up operands near underflow, by powers of two, as Baudin and Smith’s form of Smith’s algorithm does. It then applies Smith’s formula.

impl Source<Complex<f32>> for bool

fn read(self) -> Complex<f32>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f32>> for u8

fn read(self) -> Complex<f32>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f32>> for i16

fn read(self) -> Complex<f32>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f32>> for i32

fn read(self) -> Complex<f32>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f32>> for i64

fn read(self) -> Complex<f32>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f32>> for f16

fn read(self) -> Complex<f32>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f32>> for f32

fn read(self) -> Complex<f32>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f32>> for f64

fn read(self) -> Complex<f32>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f32>> for Complex<f64>

fn read(self) -> Complex<f32>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f64>> for bool

fn read(self) -> Complex<f64>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f64>> for u8

fn read(self) -> Complex<f64>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f64>> for i16

fn read(self) -> Complex<f64>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f64>> for i32

fn read(self) -> Complex<f64>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f64>> for i64

fn read(self) -> Complex<f64>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f64>> for f16

fn read(self) -> Complex<f64>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f64>> for f32

fn read(self) -> Complex<f64>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f64>> for f64

fn read(self) -> Complex<f64>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl Source<Complex<f64>> for Complex<f32>

fn read(self) -> Complex<f64>

fn borrowed(_items: &[Self]) -> Option<&[A]>

items as A with no copy, where the items already have type A.

impl<T> StructuralPartialEq for Complex<T>

where T: PartialEq,

impl<T> Sub for Complex<T>

where T: Clone + Num,

type Output = Complex<T>

The resulting type after applying the - operator.

fn sub(self, other: Complex<T>) -> <Complex<T> as Sub>::Output

Performs the - operation.

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.

fn sub(self, other: &Complex<T>) -> <Complex<T> as Sub<&'a Complex<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.

fn sub(self, other: &T) -> <Complex<T> as Sub<&'a T>>::Output

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.

fn sub(self, other: &T) -> <&'b 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.

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.

fn sub(self, other: Complex<T>) -> <&'a Complex<T> as Sub<Complex<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.

fn sub(self, other: T) -> <Complex<T> as Sub<T>>::Output

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.

fn sub(self, other: T) -> <&'a Complex<T> as Sub<T>>::Output

Performs the - operation.

impl<T> SubAssign for Complex<T>

where T: Clone + NumAssign,

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

Performs the -= operation.

impl<'a, T> SubAssign<&'a Complex<T>> for Complex<T>

where T: Clone + NumAssign,

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

Performs the -= operation.

impl<'a, T> SubAssign<&'a T> for Complex<T>

where T: Clone + NumAssign,

fn sub_assign(&mut self, other: &T)

Performs the -= operation.

impl<T> SubAssign<T> for Complex<T>

where T: Clone + NumAssign,

fn sub_assign(&mut self, other: T)

Performs the -= operation.

impl<T> Sum for Complex<T>

where T: Num + Clone,

fn sum<I>(iter: I) -> Complex<T>

where I: Iterator<Item = Complex<T>>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, T> Sum<&'a Complex<T>> for Complex<T>

where T: 'a + Num + Clone,

fn sum<I>(iter: I) -> Complex<T>

where I: Iterator<Item = &'a Complex<T>>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Ternary<Complex<f32>> for Choose

fn one(&self, x: Complex<f32>, y: Complex<f32>, m: Complex<f32>) -> Complex<f32>

fn judged( &self, x: Complex<f32>, y: Complex<f32>, m: Complex<f32>, ) -> (Complex<f32>, bool)

fn slice( &self, args: [Arg<'_, Complex<f32>>; 3], n: usize, out: &mut [MaybeUninit<Complex<f32>>], ) -> bool

fn checked(&self, x: T, y: T, z: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, z: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, z: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Ternary<Complex<f64>> for Choose

fn one(&self, x: Complex<f64>, y: Complex<f64>, m: Complex<f64>) -> Complex<f64>

fn judged( &self, x: Complex<f64>, y: Complex<f64>, m: Complex<f64>, ) -> (Complex<f64>, bool)

fn slice( &self, args: [Arg<'_, Complex<f64>>; 3], n: usize, out: &mut [MaybeUninit<Complex<f64>>], ) -> bool

fn checked(&self, x: T, y: T, z: T) -> Option<Self::Out>

fn many( &self, x: Arg<'_, T>, y: Arg<'_, T>, z: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>, ) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, y: Arg<'_, T>, z: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl<T> ToPrimitive for Complex<T>

where T: ToPrimitive + Num,

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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 Unary<Complex<f32>> for Floor

fn one(&self, y: Complex<f32>) -> Complex<f32>

fn judged(&self, y: Complex<f32>) -> (Complex<f32>, bool)

fn slice( &self, _: [Arg<'_, Complex<f32>>; 1], n: usize, out: &mut [MaybeUninit<Complex<f32>>], ) -> bool

fn checked(&self, x: T) -> Option<Self::Out>

fn many(&self, x: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Unary<Complex<f32>> for Ceil

fn one(&self, y: Complex<f32>) -> Complex<f32>

fn judged(&self, y: Complex<f32>) -> (Complex<f32>, bool)

fn slice( &self, _: [Arg<'_, Complex<f32>>; 1], n: usize, out: &mut [MaybeUninit<Complex<f32>>], ) -> bool

fn checked(&self, x: T) -> Option<Self::Out>

fn many(&self, x: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Unary<Complex<f64>> for Floor

fn one(&self, y: Complex<f64>) -> Complex<f64>

fn judged(&self, y: Complex<f64>) -> (Complex<f64>, bool)

fn slice( &self, _: [Arg<'_, Complex<f64>>; 1], n: usize, out: &mut [MaybeUninit<Complex<f64>>], ) -> bool

fn checked(&self, x: T) -> Option<Self::Out>

fn many(&self, x: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl Unary<Complex<f64>> for Ceil

fn one(&self, y: Complex<f64>) -> Complex<f64>

fn judged(&self, y: Complex<f64>) -> (Complex<f64>, bool)

fn slice( &self, _: [Arg<'_, Complex<f64>>; 1], n: usize, out: &mut [MaybeUninit<Complex<f64>>], ) -> bool

fn checked(&self, x: T) -> Option<Self::Out>

fn many(&self, x: Arg<'_, T>, n: usize, out: &mut Vec<Self::Out>) -> bool

where T: Copy + Sync,

fn many_into( &self, x: Arg<'_, T>, n: usize, out: &mut Slots<'_, Self::Out>, ) -> bool

where T: Copy,

impl<T> UpperExp for Complex<T>

where T: UpperExp + Num + PartialOrd + Clone,

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 + Clone,

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,

fn zero() -> Complex<T>

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.