Struct Complex

pub struct Complex { /* private fields */ }

Describes a complex number in both cartesian and polar form.

Implementations

impl Complex

pub fn new_cartesian(re: f64, im: f64) -> Self

Creates a complex number from its cartesian parts.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);

pub fn new_polar(mag: f64, ang: f64) -> Self

Creates a complex number from its polar parts.

Examples

use std::f64::consts::PI;
use complex_stuff::Complex;

let complex = Complex::new_polar(5.0, PI / 2.0);

pub fn new_real(re: f64) -> Self

Creates a complex number just from its real cartesian part leaving the imaginary part 0.

Examples

use complex_stuff::Complex;

let complex = Complex::new_real(5.0);

assert_eq!(5.0, complex.re());
assert_eq!(0.0, complex.im());

pub fn new_imaginary(im: f64) -> Self

Creates a complex number just from its imaginary cartesian part leaving the real part 0.

Examples

use complex_stuff::Complex;

let complex = Complex::new_imaginary(3.0);

assert_eq!(0.0, complex.re());
assert_eq!(3.0, complex.im());

pub fn zero() -> Self

Creates a complex number representing the value 0.

Examples

use complex_stuff::Complex;

let complex = Complex::zero();

assert_eq!(0.0, complex.re());
assert_eq!(0.0, complex.im());

pub fn one() -> Self

Creates a complex number representing the value 1.

Examples

use complex_stuff::Complex;

let complex = Complex::one();

assert_eq!(1.0, complex.re());
assert_eq!(0.0, complex.im());

pub fn i() -> Self

Creates a complex number representing the value i.

Examples

use complex_stuff::Complex;

let complex = Complex::i();

assert_eq!(0.0, complex.re());
assert_eq!(1.0, complex.im());

pub fn e() -> Self

Creates a complex number representing the value e.

Examples

use std::f64::consts::E;
use complex_stuff::Complex;

let complex = Complex::e();

assert_eq!(E, complex.re());
assert_eq!(0.0, complex.im());

impl Complex

pub fn cartesian(&self) -> ComplexCartesian

Returns the complex number in cartesian form.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);

let cartesian = complex.cartesian();

assert_eq!(5.0, cartesian.re);
assert_eq!(3.0, cartesian.im);

pub fn polar(&self) -> ComplexPolar

Returns the complex number in polar form.

Examples

use std::f64::consts::PI;
use complex_stuff::Complex;

let complex = Complex::new_polar(5.0, PI / 2.0);

let polar = complex.polar();

assert_eq!(5.0, polar.mag);
assert_eq!(PI / 2.0, polar.ang);

pub fn re(&self) -> f64

Returns just the real part of the complex numbers cartesian form.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);

let real = complex.re();

assert_eq!(5.0, real);

pub fn im(&self) -> f64

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);

let imaginary = complex.im();

assert_eq!(3.0, imaginary);

Returns just the imaginary part of the complex numbers cartesian form.

pub fn mag(&self) -> f64

Returns just the magnitude of the complex numbers polar form.

Examples

use std::f64::consts::PI;
use complex_stuff::Complex;

let complex = Complex::new_polar(5.0, PI / 2.0);

let magnitude = complex.mag();

assert_eq!(5.0, magnitude);

pub fn ang(&self) -> f64

Returns just the angle of the complex numbers polar form.

Examples

use std::f64::consts::PI;
use complex_stuff::Complex;

let complex = Complex::new_polar(5.0, PI / 2.0);

let angle = complex.ang();

assert_eq!(PI / 2.0, angle);

impl Complex

pub fn opposite(self) -> Self

Returns the negation of the complex number. Same as using the unary negation operator -.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);

let opposite = complex.opposite();

assert_eq!(-5.0, opposite.re());
assert_eq!(-3.0, opposite.im());

pub fn reciprocal(self) -> Option<Self>

Returns the reciprocal of the complex number.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 0.0);

let reciprocal = complex.reciprocal();

impl Complex

pub fn ln(self) -> Option<Self>

Returns the natural logarithm of the complex number.

Returns None when the result is undefined or infinite.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);

let result = complex.ln()?;

pub fn log(self, other: Self) -> Option<Self>

Returns the logarithm to any other base of the complex number.

Returns None when the result is undefined or infinite.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);
let base = Complex::new_cartesian(7.0, 10.0);

let result = complex.log(base)?;

impl Complex

pub fn pow(self, other: Self) -> Option<Self>

Raises the complex number to any other complex number and returns the result.

Returns None when the result is undefined or infinite.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);
let exponent = Complex::new_cartesian(2.0, 1.0);

let result = complex.pow(exponent)?;

pub fn root(self, other: Self) -> Option<Self>

Retuns the nth root of the complex number with n being any other complex number.

Returns None when the result is undefined or infinite.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);
let n = Complex::new_cartesian(2.0, 1.0);

let result = complex.root(n)?;

impl Complex

pub fn sin(self) -> Option<Self>

Returns the sine of the complex number.

Returns None when the result is undefined or infinite.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);

let result = complex.sin()?;

pub fn cos(self) -> Option<Self>

Returns the cosine of the complex number.

Returns None when the result is undefined or infinite.

Examples

use complex_stuff::Complex;

let complex = Complex::new_cartesian(5.0, 3.0);

let result = complex.cos()?;

Trait Implementations

impl Add for Complex

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

Performs the + operation.

Examples

use complex_stuff::Complex;

let c1 = Complex::new_cartesian(5.0, 3.0);
let c2 = Complex::new_cartesian(1.0, 2.0);

let sum = c1 + c2;

assert_eq!(6.0, sum.re());
assert_eq!(5.0, sum.im());

type Output = Complex

The resulting type after applying the + operator.

impl Clone for Complex

fn clone(&self) -> Complex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Complex

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

Formats the value using the given formatter.

impl Display for Complex

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

Formats the value using the given formatter.

impl Div for Complex

fn div(self, other: Self) -> Option<Self>

Performs the / operation.

Returns None when the result is undefined or infinite.

Examples

use complex_stuff::Complex;

let c1 = Complex::new_polar(5.0, 2.0);
let c2 = Complex::new_polar(2.0, 1.0);

let quotient = (c1 / c2)?;

assert_eq!(2.5, product.mag());
assert_eq!(1.0, product.ang());

type Output = Option<Complex>

The resulting type after applying the / operator.

impl Mul for Complex

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

Performs the * operation.

Examples

use complex_stuff::Complex;

let c1 = Complex::new_polar(5.0, 2.0);
let c2 = Complex::new_polar(2.0, 1.0);

let product = c1 * c2;

assert_eq!(10.0, product.mag());
assert_eq!(3.0, product.ang());

type Output = Complex

The resulting type after applying the * operator.

impl Neg for Complex

type Output = Complex

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl Sub for Complex

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

Performs the - operation.

Examples

use complex_stuff::Complex;

let c1 = Complex::new_cartesian(5.0, 3.0);
let c2 = Complex::new_cartesian(1.0, 2.0);

let diff = c1 - c2;

assert_eq!(4.0, diff.re());
assert_eq!(1.0, diff.im());

type Output = Complex

The resulting type after applying the - operator.

impl Copy for Complex