Struct Complex 

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

🔬This is a nightly-only experimental API. (complex_numbers #154023)

A complex number, represented in rectangular form.

Basic operations

A Complex<T> supports addition, subtraction, and negation when T does. The conjugation requires that T supports negation.

#![feature(complex_numbers)]

use std::num::Complex;

let x = Complex { re: 5.0, im: 9.0 };
let y = Complex::new(2.0, 3.0);

// Scalar addition and subtraction operate on the real component.
assert_eq!(x + 1.0, Complex::new(6.0, 9.0));
assert_eq!(x - 1.0, Complex::new(4.0, 9.0));

// Complex addition and subtraction operate on each component separately.
assert_eq!(x + y, Complex::new(7.0, 12.0));
assert_eq!(x - y, Complex::new(3.0, 6.0));

// Negation occurs on both components.
// Geometrically this is a rotation by 180 degrees.
assert_eq!(-x, Complex::new(-5.0, -9.0));

// The conjugate negates only the imaginary component.
// Geometrically this is a reflection across the real axis.
assert_eq!(x.conjugate(), Complex::new(5.0, -9.0));

Complex multiplication and division of floating points

Multiplication and division follow the textbook formulas, except that they attempt to correct for overflow of intermediate steps of the calculation.

This behavior mirrors the C standard, although it does not specify exactly when the output should be corrected. Hence, the exact output may vary from platform to platform.

#![feature(complex_numbers)]

use std::num::Complex;

assert_eq!(Complex::new(1.0, 2.0) * Complex::new(3.0, 4.0), Complex::new(-5.0, 10.0));
assert_eq!(Complex::new(2.0, 11.0) / Complex::new(2.0, 1.0), Complex::new(3.0, 4.0));

// The textbook algorithm would return NaN + NaNi for these inputs.
assert_eq!(
    Complex::new(1.0, 0.0) * Complex::new(f64::INFINITY, f64::INFINITY),
    Complex::new(f64::INFINITY, f64::INFINITY)
);
assert_eq!(
    Complex::new(1.0, 1.0) / Complex::new(f64::INFINITY, 0.0),
    Complex::new(0.0, 0.0)
);

FFI compatibility

The following types are guaranteed to fully match the platform’s _Complex in terms of layout and ABI:

• Complex<c_float>
• Complex<c_double>

For any other Complex<T> ABI compatibility is not guaranteed.

Fields

re: T

🔬This is a nightly-only experimental API. (complex_numbers #154023)

The real component.

im: T

🔬This is a nightly-only experimental API. (complex_numbers #154023)

The imaginary component.

Implementations

impl<T> Complex<T>

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

🔬This is a nightly-only experimental API. (complex_numbers #154023)

Create a new complex number from a real and imaginary component.

impl<T> Complex<T>

where T: Neg<Output = T>,

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

🔬This is a nightly-only experimental API. (complex_numbers #154023)

The complex conjugate of a complex number.

The conjugate of a + bi is a - bi: the imaginary component is negated. Geometrically, this is a reflection across the real axis.

#![feature(complex_numbers)]

use std::num::Complex;

assert_eq!(Complex::new(3.0, 2.0).conjugate(), Complex::new(3.0, -2.0));
assert_eq!(Complex::new(-3.0, -2.0).conjugate(), Complex::new(-3.0, 2.0));

Trait Implementations

impl<T> Add for Complex<T>

where T: Add,

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

Complex addition operates on each component separately.

#![feature(complex_numbers)]

use std::num::Complex;

assert_eq!(Complex::new(2.0, 3.0) + Complex::new(5.0, 9.0), Complex::new(7.0, 12.0));

type Output = Complex<<T as Add>::Output>

The resulting type after applying the + operator.

impl<T> Add<T> for Complex<T>

where T: Add<Output = T>,

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

Scalar addition operates only on the real component.

#![feature(complex_numbers)]

use std::num::Complex;

assert_eq!(Complex::new(2.0, 3.0) + 10.0, Complex::new(12.0, 3.0));

type Output = Complex<<T as Add>::Output>

The resulting type after applying the + operator.

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> 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 Div for Complex<f16>

type Output = Complex<f16>

The resulting type after applying the / operator.

fn div(self, rhs: Complex<f16>) -> <Complex<f16> as Div>::Output

Performs the / operation.

impl Div for Complex<f32>

type Output = Complex<f32>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div for Complex<f64>

type Output = Complex<f64>

The resulting type after applying the / operator.

fn div(self, rhs: Complex<f64>) -> <Complex<f64> as Div>::Output

Performs the / operation.

impl Div for Complex<f128>

type Output = Complex<f128>

The resulting type after applying the / operator.

fn div(self, rhs: Complex<f128>) -> <Complex<f128> as Div>::Output

Performs the / operation.

impl<T> Eq for Complex<T>

where T: Eq,

impl Mul for Complex<f16>

type Output = Complex<f16>

The resulting type after applying the * operator.

fn mul(self, rhs: Complex<f16>) -> <Complex<f16> as Mul>::Output

Performs the * operation.

impl Mul for Complex<f32>

type Output = Complex<f32>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul for Complex<f64>

type Output = Complex<f64>

The resulting type after applying the * operator.

fn mul(self, rhs: Complex<f64>) -> <Complex<f64> as Mul>::Output

Performs the * operation.

impl Mul for Complex<f128>

type Output = Complex<f128>

The resulting type after applying the * operator.

fn mul(self, rhs: Complex<f128>) -> <Complex<f128> as Mul>::Output

Performs the * operation.

impl<T> Neg for Complex<T>

where T: Neg,

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

Negate a complex number.

The negation of a + bi is -a - bi: both components are negated. Geometrically this is a rotation of 180°.

#![feature(complex_numbers)]

use std::num::Complex;

assert_eq!(-Complex::new(3.0, 2.0), Complex::new(-3.0, -2.0));

type Output = Complex<<T as Neg>::Output>

The resulting type after applying the - operator.

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<T> StructuralPartialEq for Complex<T>

where T: PartialEq,

impl<T> Sub for Complex<T>

where T: Sub,

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

Complex subtraction operates on each component separately.

#![feature(complex_numbers)]

use std::num::Complex;

assert_eq!(Complex::new(2.0, 3.0) - Complex::new(5.0, 9.0), Complex::new(-3.0, -6.0));

type Output = Complex<<T as Sub>::Output>

The resulting type after applying the - operator.

impl<T> Sub<T> for Complex<T>

where T: Sub<Output = T>,

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

Scalar subtraction operates only on the real component.

#![feature(complex_numbers)]

use std::num::Complex;

assert_eq!(Complex::new(2.0, 3.0) - 10.0, Complex::new(-8.0, 3.0));

type Output = Complex<<T as Sub>::Output>

The resulting type after applying the - operator.