Struct Complex 

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

A complex number in rectangular form.

Fields

re: FT

im: FT

Implementations

impl Complex<f32>

pub const NEG_ONE: Self

pub const NEG_I: Self

impl Complex<f64>

pub const NEG_ONE: Self

pub const NEG_I: Self

impl<FT> Complex<FT>

pub const fn new(re: FT, im: FT) -> Self

Creates a complex number.

impl<FT: Number> Complex<FT>

pub const ZERO: Self

pub const ONE: Self

pub const I: Self

pub fn conjugate(self) -> Self

Computes the conjugate.

pub fn abs(self) -> FT

Computes the absolute value.

pub fn square(self) -> Self

pub fn abs_sq(self) -> FT

Computes the squared absolute value.

This is faster than abs() as it avoids a square root operation.

pub fn arg(self) -> FT

Computes the argument in the range (-π, +π].

pub fn recip(self) -> Self

Computes the reciprocal.

pub fn to_polar(self) -> Polar<FT>

Convert to polar form.

pub fn exp(self) -> Polar<FT>

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

pub fn exp2(self) -> Polar<FT>

Computes 2^self.

pub fn expm1(self) -> Self

Computes e^self - 1.

More numerically stable than self.exp().to_rectangular() - 1 when self ≈ 0.

pub fn ln(self) -> Self

Computes the principal natural logarithm.

pub fn ln_1p(self) -> Self

Computes the principal natural logarithm of 1 + self.

More numerically stable than (self + 1).ln() when self ≈ 0.

pub fn log2(self) -> Self

Computes the principal logarithm in base 2.

pub fn log10(self) -> Self

Computes the principal logarithm in base 10.

pub fn ln_branch(self, k: i32) -> Self

Computes the k-th branch of the natural logarithm.

The principal value is k = 0. Each increment of k adds 2πi.

pub fn ln_1p_branch(self, k: i32) -> Self

Computes the k-th branch of the natural logarithm of 1 + self.

The principal value is k = 0. Each increment of k adds 2πi.

pub fn log2_branch(self, k: i32) -> Self

Computes the k-th branch of the base-2 logarithm.

pub fn log10_branch(self, k: i32) -> Self

Computes the k-th branch of the base-10 logarithm.

pub fn sqrt_branch(self, k: i32) -> Polar<FT>

Computes the k-th square root.

The principal value is k = 0. Only k = 0 and k = 1 give distinct values.

pub fn nth_root(self, n: i32, k: i32) -> Polar<FT>

Computes the k-th value of the n-th root.

The n distinct values correspond to k = 0..n-1.

pub fn pow_rational(self, p: i32, q: i32, k: i32) -> Polar<FT>

Raises self to the rational power p/q, selecting the k-th branch.

There are q distinct values corresponding to k = 0..q-1, provided p/q is in lowest terms. If p/q is not reduced, first reduce it to find the true number of distinct values.

pub fn powi(self, n: i32) -> Polar<FT>

Raises self to an integer power.

pub fn powf(self, x: FT) -> Polar<FT>

Raises self to a floating point power.

pub fn sqrt(self) -> Self

Computes the principal square root.

pub fn distance(self, other: Self) -> FT

Computes the euclidian distance between two points.

pub fn distance_squared(self, other: Self) -> FT

Computes the squared euclidian distance between two points.

pub fn lerp(self, other: Self, t: FT) -> Self

Computes the linear interpolation between two points based on the value t.

pub fn is_finite(self) -> bool

Returns whether both the real and imaginary component are finite.

impl<FT: AsPrimitive<f32>> Complex<FT>

pub fn as_vec2(self) -> Vec2

Casts to a glam::Vec2.

impl<FT: AsPrimitive<f64>> Complex<FT>

pub fn as_dvec2(self) -> DVec2

Casts to a glam::DVec2.

Trait Implementations

impl<FT: AbsDiffEq + Copy> AbsDiffEq for Complex<FT>

where <FT as AbsDiffEq>::Epsilon: Copy,

Available on crate feature approx only.

type Epsilon = <FT as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<FT: Number> Add for Complex<FT>

type Output = Complex<FT>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Complex<f64>> for f64

type Output = Complex<f64>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<FT: Number> Add<FT> for Complex<FT>

type Output = Complex<FT>

The resulting type after applying the + operator.

fn add(self, re: FT) -> Self::Output

Performs the + operation.

impl<FT: Number> AddAssign for Complex<FT>

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<FT: Number> AddAssign<FT> for Complex<FT>

fn add_assign(&mut self, re: FT)

Performs the += operation.

impl<FT: Clone> Clone for Complex<FT>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<FT: Copy> Copy for Complex<FT>

impl<FT: Debug> Debug for Complex<FT>

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

Formats the value using the given formatter.

impl<FT: Default> Default for Complex<FT>

fn default() -> Complex<FT>

Returns the “default value” for a type.

impl Display for Complex<f32>

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

Formats the value using the given formatter.

impl Display for Complex<f64>

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

Formats the value using the given formatter.

impl Distribution<Complex<f32>> for StandardUniform

Available on crate feature rand only.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Complex<f32>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl Distribution<Complex<f64>> for StandardUniform

Available on crate feature rand only.

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Complex<f64>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> Iter<Self, R, T>

where R: Rng, Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> Map<Self, F, T, S>

where F: Fn(T) -> S, Self: Sized,

Map sampled values to type S

impl<FT: Number> Div for Complex<FT>

type Output = Complex<FT>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Complex<f64>> for f64

type Output = Complex<f64>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<FT: Number> Div<FT> for Complex<FT>

type Output = Complex<FT>

The resulting type after applying the / operator.

fn div(self, re: FT) -> Self::Output

Performs the / operation.

impl<FT: Number> DivAssign for Complex<FT>

fn div_assign(&mut self, other: Self)

Performs the /= operation.

impl<FT: Number> DivAssign<FT> for Complex<FT>

fn div_assign(&mut self, re: FT)

Performs the /= operation.

impl<T: Into<f32>> From<Complex<T>> for Vec2

Available on crate feature glam only.

fn from(z: Complex<T>) -> Self

Converts to this type from the input type.

impl<T: Into<f64>> From<Complex<T>> for DVec2

Available on crate feature glam only.

fn from(z: Complex<T>) -> Self

Converts to this type from the input type.

impl<T: From<f64>> From<DVec2> for Complex<T>

Available on crate feature glam only.

fn from(v: DVec2) -> Self

Converts to this type from the input type.

impl<FT: Number> From<FT> for Complex<FT>

fn from(value: FT) -> Self

Converts to this type from the input type.

impl<T: From<f32>> From<Vec2> for Complex<T>

Available on crate feature glam only.

fn from(v: Vec2) -> Self

Converts to this type from the input type.

impl<FT: Number> Mul for Complex<FT>

type Output = Complex<FT>

The resulting type after applying the * operator.

fn mul(self, other: Self) -> Self

Performs the * operation.

impl Mul<Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Complex<f64>> for f64

type Output = Complex<f64>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<FT: Number> Mul<FT> for Complex<FT>

type Output = Complex<FT>

The resulting type after applying the * operator.

fn mul(self, re: FT) -> Self

Performs the * operation.

impl<FT: Number> MulAssign for Complex<FT>

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<FT: Number> MulAssign<FT> for Complex<FT>

fn mul_assign(&mut self, re: FT)

Performs the *= operation.

impl<FT: Number> Neg for Complex<FT>

type Output = Complex<FT>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<FT: PartialEq> PartialEq for Complex<FT>

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

Equality operator ==.

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

Inequality operator !=.

impl<FT: RelativeEq + Copy> RelativeEq for Complex<FT>

where <FT as AbsDiffEq>::Epsilon: Copy,

Available on crate feature approx only.

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<FT: PartialEq> StructuralPartialEq for Complex<FT>

impl<FT: Number> Sub for Complex<FT>

type Output = Complex<FT>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Complex<f32>> for f32

type Output = Complex<f32>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Complex<f64>> for f64

type Output = Complex<f64>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<FT: Number> Sub<FT> for Complex<FT>

type Output = Complex<FT>

The resulting type after applying the - operator.

fn sub(self, re: FT) -> Self::Output

Performs the - operation.

impl<FT: Number> SubAssign for Complex<FT>

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<FT: Number> SubAssign<FT> for Complex<FT>

fn sub_assign(&mut self, re: FT)

Performs the -= operation.

impl<FT: UlpsEq + Copy> UlpsEq for Complex<FT>

where <FT as AbsDiffEq>::Epsilon: Copy,

Available on crate feature approx only.

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.