# Struct num_complex::Complex
[−]
[src]

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

A complex number in Cartesian form.

## Representation and Foreign Function Interface Compatibility

`Complex<T>`

is memory layout compatible with an array `[T; 2]`

.

Note that `Complex<F>`

where F is a floating point type is **only** memory
layout compatible with C's complex types, **not** necessarily calling
convention compatible. This means that for FFI you can only pass
`Complex<F>`

behind a pointer, not as a value.

## Examples

Example of extern function declaration.

use num_complex::Complex; use std::os::raw::c_int; extern "C" { fn zaxpy_(n: *const c_int, alpha: *const Complex<f64>, x: *const Complex<f64>, incx: *const c_int, y: *mut Complex<f64>, incy: *const c_int); }Run

## Fields

`re: T`

Real portion of the complex number

`im: T`

Imaginary portion of the complex number

## Methods

`impl<T: Clone + Num> Complex<T>`

[src]

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

Create a new Complex

`fn i() -> Complex<T>`

Returns imaginary unit

`fn norm_sqr(&self) -> T`

Returns the square of the norm (since `T`

doesn't necessarily
have a sqrt function), i.e. `re^2 + im^2`

.

`fn scale(&self, t: T) -> Complex<T>`

Multiplies `self`

by the scalar `t`

.

`fn unscale(&self, t: T) -> Complex<T>`

Divides `self`

by the scalar `t`

.

`impl<T: Clone + Num + Neg<Output = T>> Complex<T>`

[src]

`fn conj(&self) -> Complex<T>`

Returns the complex conjugate. i.e. `re - i im`

`fn inv(&self) -> Complex<T>`

Returns `1/self`

`impl<T: Clone + Float> Complex<T>`

[src]

`fn norm(&self) -> T`

Calculate |self|

`fn arg(&self) -> T`

Calculate the principal Arg of self.

`fn to_polar(&self) -> (T, T)`

Convert to polar form (r, theta), such that `self = r * exp(i * theta)`

`fn from_polar(r: &T, theta: &T) -> Complex<T>`

Convert a polar representation into a complex number.

`fn exp(&self) -> Complex<T>`

Computes `e^(self)`

, where `e`

is the base of the natural logarithm.

`fn ln(&self) -> Complex<T>`

Computes the principal value of natural logarithm of `self`

.

This function has one branch cut:

`(-∞, 0]`

, continuous from above.

The branch satisfies `-π ≤ arg(ln(z)) ≤ π`

.

`fn sqrt(&self) -> Complex<T>`

Computes the principal value of the square root of `self`

.

This function has one branch cut:

`(-∞, 0)`

, continuous from above.

The branch satisfies `-π/2 ≤ arg(sqrt(z)) ≤ π/2`

.

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

Raises `self`

to a floating point power.

`fn log(&self, base: T) -> Complex<T>`

Returns the logarithm of `self`

with respect to an arbitrary base.

`fn powc(&self, exp: Complex<T>) -> Complex<T>`

Raises `self`

to a complex power.

`fn expf(&self, base: T) -> Complex<T>`

Raises a floating point number to the complex power `self`

.

`fn sin(&self) -> Complex<T>`

Computes the sine of `self`

.

`fn cos(&self) -> Complex<T>`

Computes the cosine of `self`

.

`fn tan(&self) -> Complex<T>`

Computes the tangent of `self`

.

`fn asin(&self) -> Complex<T>`

Computes the principal value of the inverse sine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Re(asin(z)) ≤ π/2`

.

`fn acos(&self) -> Complex<T>`

Computes the principal value of the inverse cosine of `self`

.

This function has two branch cuts:

`(-∞, -1)`

, continuous from above.`(1, ∞)`

, continuous from below.

The branch satisfies `0 ≤ Re(acos(z)) ≤ π`

.

`fn atan(&self) -> Complex<T>`

Computes the principal value of the inverse tangent of `self`

.

This function has two branch cuts:

`(-∞i, -i]`

, continuous from the left.`[i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Re(atan(z)) ≤ π/2`

.

`fn sinh(&self) -> Complex<T>`

Computes the hyperbolic sine of `self`

.

`fn cosh(&self) -> Complex<T>`

Computes the hyperbolic cosine of `self`

.

`fn tanh(&self) -> Complex<T>`

Computes the hyperbolic tangent of `self`

.

`fn asinh(&self) -> Complex<T>`

Computes the principal value of inverse hyperbolic sine of `self`

.

This function has two branch cuts:

`(-∞i, -i)`

, continuous from the left.`(i, ∞i)`

, continuous from the right.

The branch satisfies `-π/2 ≤ Im(asinh(z)) ≤ π/2`

.

`fn acosh(&self) -> Complex<T>`

Computes the principal value of inverse hyperbolic cosine of `self`

.

This function has one branch cut:

`(-∞, 1)`

, continuous from above.

The branch satisfies `-π ≤ Im(acosh(z)) ≤ π`

and `0 ≤ Re(acosh(z)) < ∞`

.

`fn atanh(&self) -> Complex<T>`

Computes the principal value of inverse hyperbolic tangent of `self`

.

This function has two branch cuts:

`(-∞, -1]`

, continuous from above.`[1, ∞)`

, continuous from below.

The branch satisfies `-π/2 ≤ Im(atanh(z)) ≤ π/2`

.

`fn is_nan(self) -> bool`

Checks if the given complex number is NaN

`fn is_infinite(self) -> bool`

Checks if the given complex number is infinite

`fn is_finite(self) -> bool`

Checks if the given complex number is finite

`fn is_normal(self) -> bool`

Checks if the given complex number is normal

## Trait Implementations

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

[src]

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

This method tests for `self`

and `other`

values to be equal, and is used by `==`

. Read more

`fn ne(&self, __arg_0: &Complex<T>) -> bool`

This method tests for `!=`

.

`impl<T: Eq> Eq for Complex<T>`

[src]

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

[src]

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

[src]

`fn clone(&self) -> Complex<T>`

Returns a copy of the value. Read more

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

1.0.0

Performs copy-assignment from `source`

. Read more

`impl<T: Hash> Hash for Complex<T>`

[src]

`fn hash<__HT: Hasher>(&self, __arg_0: &mut __HT)`

Feeds this value into the given [`Hasher`

]. Read more

`fn hash_slice<H>(data: &[Self], state: &mut H) where`

H: Hasher,

1.3.0

H: Hasher,

Feeds a slice of this type into the given [`Hasher`

]. Read more

`impl<T: Debug> Debug for Complex<T>`

[src]

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

[src]

`impl<T: Encodable> Encodable for Complex<T>`

[src]

`fn encode<__ST: Encoder>(&self, __arg_0: &mut __ST) -> Result<(), __ST::Error>`

Serialize a value using an `Encoder`

.

`impl<T: Decodable> Decodable for Complex<T>`

[src]

`fn decode<__DT: Decoder>(__arg_0: &mut __DT) -> Result<Complex<T>, __DT::Error>`

Deserialize a value using a `Decoder`

.

`impl<T: Clone + Num> From<T> for Complex<T>`

[src]

`impl<'a, T: Clone + Num> From<&'a T> for Complex<T>`

[src]

`impl<'a, 'b, T: Clone + Num> Add<&'b Complex<T>> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

`impl<'a, T: Clone + Num> Add<Complex<T>> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

`impl<'a, T: Clone + Num> Add<&'a Complex<T>> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

`impl<T: Clone + Num> Add<Complex<T>> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

`impl<'a, 'b, T: Clone + Num> Sub<&'b Complex<T>> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

`impl<'a, T: Clone + Num> Sub<Complex<T>> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

`impl<'a, T: Clone + Num> Sub<&'a Complex<T>> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

`impl<T: Clone + Num> Sub<Complex<T>> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

`impl<'a, 'b, T: Clone + Num> Mul<&'b Complex<T>> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

`impl<'a, T: Clone + Num> Mul<Complex<T>> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

`impl<'a, T: Clone + Num> Mul<&'a Complex<T>> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

`impl<T: Clone + Num> Mul<Complex<T>> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

`impl<'a, 'b, T: Clone + Num> Div<&'b Complex<T>> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

`impl<'a, T: Clone + Num> Div<Complex<T>> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

`impl<'a, T: Clone + Num> Div<&'a Complex<T>> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

`impl<T: Clone + Num> Div<Complex<T>> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

`impl<T: Clone + Num + Neg<Output = T>> Neg for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

`fn neg(self) -> Complex<T>`

The method for the unary `-`

operator

`impl<'a, T: Clone + Num + Neg<Output = T>> Neg for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

`fn neg(self) -> Complex<T>`

The method for the unary `-`

operator

`impl<'a, T: Clone + Num> Add<&'a T> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

`impl<'a, T: Clone + Num> Add<T> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

`impl<'a, 'b, T: Clone + Num> Add<&'a T> for &'b Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

`impl<'a, T: Clone + Num> Sub<&'a T> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

`impl<'a, T: Clone + Num> Sub<T> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

`impl<'a, 'b, T: Clone + Num> Sub<&'a T> for &'b Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

`impl<'a, T: Clone + Num> Mul<&'a T> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

`impl<'a, T: Clone + Num> Mul<T> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

`impl<'a, 'b, T: Clone + Num> Mul<&'a T> for &'b Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

`impl<'a, T: Clone + Num> Div<&'a T> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

`impl<'a, T: Clone + Num> Div<T> for &'a Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

`impl<'a, 'b, T: Clone + Num> Div<&'a T> for &'b Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

`impl<T: Clone + Num> Add<T> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `+`

operator

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

The method for the `+`

operator

`impl<T: Clone + Num> Sub<T> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `-`

operator

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

The method for the `-`

operator

`impl<T: Clone + Num> Mul<T> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `*`

operator

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

The method for the `*`

operator

`impl<T: Clone + Num> Div<T> for Complex<T>`

[src]

`type Output = Complex<T>`

The resulting type after applying the `/`

operator

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

The method for the `/`

operator

`impl<T: Clone + Num> Zero for Complex<T>`

[src]

`fn zero() -> Complex<T>`

Returns the additive identity element of `Self`

, `0`

. Read more

`fn is_zero(&self) -> bool`

Returns `true`

if `self`

is equal to the additive identity.

`impl<T: Clone + Num> One for Complex<T>`

[src]

`impl<T> Display for Complex<T> where`

T: Display + Num + PartialOrd + Clone,

[src]

T: Display + Num + PartialOrd + Clone,

`impl<T> LowerExp for Complex<T> where`

T: LowerExp + Num + PartialOrd + Clone,

[src]

T: LowerExp + Num + PartialOrd + Clone,

`impl<T> UpperExp for Complex<T> where`

T: UpperExp + Num + PartialOrd + Clone,

[src]

T: UpperExp + Num + PartialOrd + Clone,

`impl<T> LowerHex for Complex<T> where`

T: LowerHex + Num + PartialOrd + Clone,

[src]

T: LowerHex + Num + PartialOrd + Clone,

`impl<T> UpperHex for Complex<T> where`

T: UpperHex + Num + PartialOrd + Clone,

[src]

T: UpperHex + Num + PartialOrd + Clone,

`impl<T> Octal for Complex<T> where`

T: Octal + Num + PartialOrd + Clone,

[src]

T: Octal + Num + PartialOrd + Clone,

`impl<T> Binary for Complex<T> where`

T: Binary + Num + PartialOrd + Clone,

[src]

T: Binary + Num + PartialOrd + Clone,