Struct Complex 

pub struct Complex<T> { /* private fields */ }

Implementations

impl<T> Complex<T>

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

creates new complex number from real and imaginary parts

Example

let z = Complex::new(3.0, 4.0); // 3 + 4i

---

basic constructor for complex numbers

impl<T: Copy> Complex<T>

pub fn re(&self) -> T

pub fn im(&self) -> T

impl Complex<f64>

pub fn modulus(&self) -> f64

calculates absolute value (modulus) of complex number

Example

let z = Complex::new(3.0, 4.0);
assert_eq!(z.modulus(), 5.0);

---

computes √(re² + im²)

pub fn argument(&self) -> f64

calculates argument (phase) of complex number

Example

let z = Complex::new(1.0, 1.0);
assert_eq!(z.argument(), std::f64::consts::PI/4.0);

---

returns angle in radians from positive real axis

pub fn conjugate(&self) -> Self

returns complex conjugate

Example

let z = Complex::new(3.0, 4.0);
let conj = z.conjugate(); // 3 - 4i

---

negates imaginary part while keeping real part

pub fn exp(&self) -> Self

computes exponential of complex number

Example

let z = Complex::I * std::f64::consts::PI;
let exp_z = z.exp(); // ≈ -1 + 0i

---

uses euler’s formula: e^(a+bi) = e^a(cos(b) + i*sin(b))

pub fn ln(&self) -> Self

computes natural logarithm of complex number

Example

let z = Complex::new(1.0, 0.0);
let ln_z = z.ln(); // 0 + 0i

---

returns ln|z| + i*arg(z)

pub fn pow(&self, n: f64) -> Self

raises complex number to real power

Example

let z = Complex::new(1.0, 1.0);
let z_squared = z.pow(2.0);

---

uses polar form for computation

pub fn sqrt(&self) -> Self

calculates square root of complex number

Example

let z = Complex::new(-1.0, 0.0);
let sqrt_z = z.sqrt(); // 0 + 1i

---

returns principal square root

pub fn sin(&self) -> Self

pub fn cos(&self) -> Self

pub fn tan(&self) -> Self

pub fn sinh(&self) -> Self

pub fn cosh(&self) -> Self

pub fn tanh(&self) -> Self

impl Complex<f64>

pub const I: Complex<f64>

pub const ONE: Complex<f64>

pub const ZERO: Complex<f64>

impl Complex<f64>

pub fn from_polar(r: f64, theta: f64) -> Self

creates complex number from polar coordinates

Example

let z = Complex::from_polar(2.0, std::f64::consts::PI/4.0);

---

converts (r,θ) to x + yi form

pub fn to_polar(&self) -> (f64, f64)

converts to polar coordinates

Example

let z = Complex::new(1.0, 1.0);
let (r, theta) = z.to_polar();

---

returns tuple of (modulus, argument)

Trait Implementations

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

type Output = Complex<T>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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

Formats the value using the given formatter.

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

type Output = Complex<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl From<f64> for Complex<f64>

fn from(x: f64) -> Self

Converts to this type from the input type.

impl From<i32> for Complex<f64>

fn from(x: i32) -> Self

Converts to this type from the input type.

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

type Output = Complex<T>

The resulting type after applying the * operator.

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

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) -> Self::Output

Performs the unary - operation.

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: Copy + Sub<Output = T>> Sub for Complex<T>

type Output = Complex<T>

The resulting type after applying the - operator.

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

Performs the - operation.

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

impl<T> StructuralPartialEq for Complex<T>