Struct Complex 

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

Complex number.

Fields

re: T

im: T

Implementations

impl<T> Complex<T>

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

Constructs a new complex number from components.

impl<T: Zero> Complex<T>

pub const ZERO: Complex<T>

Zero complex number.

impl<T: Zero + One> Complex<T>

pub const UNIT: Complex<T>

Unit complex number.

impl<T: Float> Complex<T>

pub fn rotation(angle: Angle<T>) -> Complex<T>

Rotating complex number.

pub fn rotation_between(from: Vec2<T>, to: Vec2<T>) -> Complex<T>

Returns the shortest rotation that aligns vector from with vector to.

The resulting complex number R satisfies:

R * from = to

Both vectors are expected to be normalized. The implementation avoids trigonometric functions.

The 2D rotation is uniquely defined even when the vectors are opposite, so this returns a 180° rotation in that case.

This is useful for constructing a 2D orientation that points one direction vector toward another.

let from = cvmath::Vec2(1.0, 1.0).norm();
let to = cvmath::Vec2(-1.0, 1.0).norm();
let rotation = cvmath::Complex::rotation_between(from, to);

let expected = to.cast::<f32>();
let actual = (rotation * from).cast::<f32>();
assert_eq!(expected, actual);

impl<T: Float> Complex<T>

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

Squares the complex number.

pub fn abs_sqr(self) -> T

Calculates the squared absolute value.

pub fn abs(self) -> T

Calculates the absolute value.

pub fn arg(self) -> Angle<T>

Calculates the argument (angle).

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

Calculates the complex conjugate.

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

Normalizes the complex number.

After normalization, the complex number has an absolute value of 1.0 except zero remains zero.

pub fn polar(self) -> Polar<T>

Converts to polar coordinates.

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

Calculates the reciprocal.

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

Raises the complex number to a power.

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

Raises the complex number to an integer power.

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

Calculates the natural logarithm.

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

Calculates the exponential.

impl<T: Copy + Neg<Output = T>> Complex<T>

pub fn mat2(self) -> Mat2<T>

pub fn vec2(self) -> Vec2<T>

Trait Implementations

impl<T: Add<Output = T>> Add for Complex<T>

type Output = Complex<T>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Performs the += operation.

impl<T> AsMut<[T; 2]> for Complex<T>

fn as_mut(&mut self) -> &mut [T; 2]

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

impl<T> AsRef<[T; 2]> for Complex<T>

fn as_ref(&self) -> &[T; 2]

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

impl<T: Binary> Binary for Complex<T>

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

Formats the value using the given formatter.

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

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: Debug> Debug for Complex<T>

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

Formats the value using the given formatter.

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

fn default() -> Complex<T>

Returns the “default value” for a type.

impl<T: Display> Display for Complex<T>

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

Formats the value using the given formatter.

impl<T: Div<Output = T> + Copy> Div<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> Complex<T>

Performs the / operation.

impl<T: Copy + Mul<Output = T> + Div<Output = T> + Add<Output = T> + Sub<Output = T>> Div for Complex<T>

type Output = Complex<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T: Copy + DivAssign> DivAssign<T> for Complex<T>

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T: Copy + Mul<Output = T> + Div<Output = T> + Add<Output = T> + Sub<Output = T>> DivAssign for Complex<T>

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

Performs the /= operation.

impl<T: Float> From<Complex<T>> for Polar<T>

fn from(complex: Complex<T>) -> Polar<T>

Converts to this type from the input type.

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

fn from(complex: Complex<T>) -> Vec2<T>

Converts to this type from the input type.

impl<T: Float> From<Polar<T>> for Complex<T>

fn from(polar: Polar<T>) -> Complex<T>

Converts to this type from the input type.

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

fn from(vec: Vec2<T>) -> Complex<T>

Converts to this type from the input type.

impl<T: FromStr + Default> FromStr for Complex<T>

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

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<T: LowerExp> LowerExp for Complex<T>

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

Formats the value using the given formatter.

impl<T: LowerHex> LowerHex for Complex<T>

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

Formats the value using the given formatter.

impl<T: Mul<Output = T> + Copy> Mul<T> for Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Complex<T>

Performs the * operation.

impl<T: Copy + Mul<Output = T> + Add<Output = T> + Sub<Output = T>> Mul<Vec2<T>> for Complex<T>

type Output = Vec2<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vec2<T>) -> Vec2<T>

Performs the * operation.

impl<T: Copy + Mul<Output = T> + Add<Output = T> + Sub<Output = T>> Mul for Complex<T>

type Output = Complex<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Copy + MulAssign> MulAssign<T> for Complex<T>

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: Copy + Mul<Output = T> + Add<Output = T> + Sub<Output = T>> MulAssign for Complex<T>

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

Performs the *= operation.

impl<T: Neg<Output = T>> Neg for Complex<T>

type Output = Complex<T>

The resulting type after applying the - operator.

fn neg(self) -> Complex<T>

Performs the unary - operation.

impl<T: Octal> Octal for Complex<T>

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

Formats the value using the given formatter.

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

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Sub<Output = T>> Sub for Complex<T>

type Output = Complex<T>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

impl<T: UpperExp> UpperExp for Complex<T>

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

Formats the value using the given formatter.

impl<T: UpperHex> UpperHex for Complex<T>

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

Formats the value using the given formatter.

impl<T: Copy> Copy for Complex<T>

impl<T> StructuralPartialEq for Complex<T>