Struct rugcom::Complex

pub struct Complex { /* fields omitted */ }

A multi-precision complex number. The precision has to be set during construction.

There are two versions of most methods:

1. The first rounds the returned or stored Complex number to the nearest representable value.
2. The second applies the specified rounding methods for the real and imaginary parts, and returns the rounding directions for both:
   • Ordering::Less if the returned/stored part is less than the exact result,
   • Ordering::Equal if the returned/stored part is equal to the exact result,
   • Ordering::Greater if the returned/stored part is greater than the exact result,

Note on Round::AwayFromZero

For Complex numbers, Round::AwayFromZero is not implemented, and trying to use it will start a panic.

Methods

impl Complex

fn new(prec: (u32, u32)) -> Complex

Create a new complex number with the specified precisions for the real and imaginary parts and with value 0.

Panics

Panics if prec.0 or prec.1 is out of the allowed range.

fn prec(&self) -> (u32, u32)

Returns the precision of the real and imaginary parts.

fn set_prec(&mut self, prec: (u32, u32))

Sets the precision of the real and imaginary parts exactly, rounding to the nearest.

Panics

Panics if prec.0 or prec.1 is out of the allowed range.

fn set_prec_round(
    &mut self,
    prec: (u32, u32),
    round: (Round, Round)
) -> (Ordering, Ordering)

Sets the precision of the real and imaginary parts exactly, applying the specified rounding method.

Panics

Panics if prec.0 or prec.1 is out of the allowed range.

fn real(&self) -> &Float

Borrows the real part.

fn imag(&self) -> &Float

Borrows the imaginary part.

fn mut_real(&mut self) -> &mut Float

Borrows the real part mutably.

Examples

extern crate rugint;
extern crate rugcom;
use rugint::Assign;
use rugcom::Complex;

fn main() {
    let mut c = Complex::from(((1, 2), (53, 53)));
    assert!(c == (1, 2));
    c.mut_real().assign(12.5);
    *c.mut_imag() += 12;
    assert!(c == (12.5, 14));
}

fn mut_imag(&mut self) -> &mut Float

Borrows the imaginary part mutably.

See the example for mut_real().

fn as_real_imag(&self) -> (&Float, &Float)

Borrows the real and imaginary parts.

fn as_mut_real_imag(&mut self) -> (&mut Float, &mut Float)

Borrows the real and imaginary parts mutably.

Examples

use rugcom::Complex;

let mut c = Complex::from(((1, 2), (53, 53)));
{
    let mut real_imag = c.as_mut_real_imag();
    *real_imag.0 += 3;
    *real_imag.1 += 4;
    // borrow ends here
}
let (real, imag) = c.as_real_imag();
assert!(*real == 4 && *imag == 6);

fn into_real_imag(self) -> (Float, Float)

Converts self into real and imaginary Float values, consuming self.

fn proj(&mut self) -> &mut Complex

Computes a projection onto the Riemann sphere, rounding to the nearest.

fn proj_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes a projection onto the Riemann sphere, applying the specified rounding method.

fn square(&mut self) -> &mut Complex

Computes the square, rounding to the nearest.

fn square_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the square, applying the specified rounding method.

fn sqrt(&mut self) -> &mut Complex

Computes the square root, rounding to the nearest.

fn sqrt_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the square root, applying the specified rounding method.

fn conjugate(&mut self) -> &mut Complex

Computes the complex conjugate, rounding to the nearest.

fn abs<'a>(&self, buf: &'a mut Float) -> &'a mut Float

Computes the absolute value, rounding to the nearest.

Examples

extern crate rugflo;
extern crate rugcom;
use rugflo::{Float, Special};
use rugcom::Complex;

fn main() {
    let mut f = Float::new(53);
    let c1 = Complex::from(((30, 40), (53, 53)));
    assert!(*c1.abs(&mut f) == 50);
    let c2 = Complex::from(((12, Special::Infinity), (53, 53)));
    assert!(c2.abs(&mut f).is_infinite());
}

fn abs_round(&self, buf: &mut Float, round: Round) -> Ordering

Computes the absolute value, applying the specified rounding method.

fn arg<'a>(&self, buf: &'a mut Float) -> &'a mut Float

Computes the argument, rounding to the nearest.

Examples

extern crate rugint;
extern crate rugflo;
extern crate rugcom;
use rugint::Assign;
use rugflo::{Float, Special};
use rugcom::Complex;
use std::f64;

fn main() {
    // f has precision 53, just like f64, so PI constants match.
    let mut f = Float::new(53);
    let c_pos = Complex::from((1, (53, 53)));
    assert!(c_pos.arg(&mut f).is_zero());
    let c_neg = Complex::from((-1.3, (53, 53)));
    assert!(*c_neg.arg(&mut f) == f64::consts::PI);
    let c_pi_4 = Complex::from(((1.333, 1.333), (53, 53)));
    assert!(*c_pi_4.arg(&mut f) == f64::consts::FRAC_PI_4);
    // Special values are handled like atan2 in IEEE 754-2008.
    // Examples for real, imag set to plus, minus zero below:
    let mut zero = Complex::new((53, 53));
    zero.assign((Special::Zero, Special::Zero));
    assert!(zero.arg(&mut f).is_zero() && !f.get_sign());
    zero.assign((Special::Zero, Special::MinusZero));
    assert!(zero.arg(&mut f).is_zero() && f.get_sign());
    zero.assign((Special::MinusZero, Special::Zero));
    println!("{} {}", zero, zero.arg(&mut f));
    assert!(*zero.arg(&mut f) == f64::consts::PI);
    zero.assign((Special::MinusZero, Special::MinusZero));
    assert!(*zero.arg(&mut f) == -f64::consts::PI);
}

fn arg_round(&self, buf: &mut Float, round: Round) -> Ordering

Computes the argument, applying the specified rounding method.

fn mul_i(&mut self, negative: bool) -> &mut Complex

Multiplies the complex number by i, rounding to the nearest.

fn mul_i_round(
    &mut self,
    negative: bool,
    round: (Round, Round)
) -> (Ordering, Ordering)

Multiplies the complex number by i, applying the specified rounding method.

fn recip(&mut self) -> &mut Complex

Computes the reciprocal, rounding to the nearest.

fn recip_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the reciprocal, applying the specified rounding method.

fn norm<'a>(&self, buf: &'a mut Float) -> &'a mut Float

Computes the norm, that is the square of the absolute value, rounding to the nearest.

fn norm_round(&self, buf: &mut Float, round: Round) -> Ordering

Computes the norm, that is the square of the absolute value, applying the specified rounding method.

fn ln(&mut self) -> &mut Complex

Computes the natural logarithm, rounding to the nearest.

fn ln_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the natural logarithm, applying the specified rounding method.

fn log10(&mut self) -> &mut Complex

Computes the logarithm to base 10, rounding to the nearest.

fn log10_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the logarithm to base 10, applying the specified rounding method.

fn exp(&mut self) -> &mut Complex

Computes the exponential, rounding to the nearest.

fn exp_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the exponential, applying the specified rounding method.

fn sin(&mut self) -> &mut Complex

Computes the sine, rounding to the nearest.

fn sin_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the sine, applying the specified rounding method.

fn cos(&mut self) -> &mut Complex

Computes the cosine, rounding to the nearest.

fn cos_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the cosine, applying the specified rounding method.

fn sin_cos(&mut self, buf: &mut Complex)

Computes the sine and cosine, rounding to the nearest. The sine is stored in self and keeps its precision, while the cosine is stored in buf keeping its precision.

fn sin_cos_round(
    &mut self,
    buf: &mut Complex,
    round_sin: (Round, Round),
    round_cos: (Round, Round)
) -> ((Ordering, Ordering), (Ordering, Ordering))

Computes the sine and cosine, applying the specified rounding methods. The sine is stored in self and keeps its precision, while the cosine is stored in buf keeping its precision.

fn tan(&mut self) -> &mut Complex

Computes the tangent, rounding to the nearest.

fn tan_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the tangent, applying the specified rounding method.

fn sinh(&mut self) -> &mut Complex

Computes the hyperbolic sine, rounding to the nearest.

fn sinh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the hyperboic sine, applying the specified rounding method.

fn cosh(&mut self) -> &mut Complex

Computes the hyperbolic cosine, rounding to the nearest.

fn cosh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the hyperboic cosine, applying the specified rounding method.

fn tanh(&mut self) -> &mut Complex

Computes the hyperbolic tangent, rounding to the nearest.

fn tanh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the hyperboic tangent, applying the specified rounding method.

fn asin(&mut self) -> &mut Complex

Computes the inverse sine, rounding to the nearest.

fn asin_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the inverse sine, applying the specified rounding method.

fn acos(&mut self) -> &mut Complex

Computes the inverse cosine, rounding to the nearest.

fn acos_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the inverse cosine, applying the specified rounding method.

fn atan(&mut self) -> &mut Complex

Computes the inverse tangent, rounding to the nearest.

fn atan_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the inverse tangent, applying the specified rounding method.

fn asinh(&mut self) -> &mut Complex

Computes the inverse hyperbolic sine, rounding to the nearest.

fn asinh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the inverse hyperboic sine, applying the specified rounding method.

fn acosh(&mut self) -> &mut Complex

Computes the inverse hyperbolic cosine, rounding to the nearest.

fn acosh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the inverse hyperboic cosine, applying the specified rounding method.

fn atanh(&mut self) -> &mut Complex

Computes the inverse hyperbolic tangent, rounding to the nearest.

fn atanh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)

Computes the inverse hyperboic tangent, applying the specified rounding method.

fn assign_random_bits<R: Rng>(&mut self, rng: &mut R)

Generates a random complex number with both the real and imaginary parts in the range 0 <= n < 1.

This is equivalent to calling assign_random_bits_round(rng, (Round::Nearest, Round::Nearest)).

fn assign_random_bits_round<R: Rng>(
    &mut self,
    rng: &mut R,
    round: (Round, Round)
) -> (Ordering, Ordering)

Generates a random complex number with both the real and imaginary parts in the range 0 <= n < 1.

This is equivalent to calling assign_random_bits_round(rng, round.0) on the real part, and the same with round.1 on the imaginary part.

fn assign_random_cont<R: Rng>(&mut self, rng: &mut R)

Generates a random complex number, rounding to the nearest.

Both the real and imaginary parts are in the continuous range 0 <= n < 1. After rounding, the value may be equal to one. Calling this method is equivalent to calling assign_random_cont_round(rng, (Round::Nearest, Round::Nearest)).

fn assign_random_cont_round<R: Rng>(
    &mut self,
    rng: &mut R,
    round: (Round, Round)
) -> (Ordering, Ordering)

Generates a random complex number, applying the specified rounding method.

Both the real and imaginary parts are in the continuous range 0 <= n < 1. After rounding, the value may be equal to one. Calling this method is equivalent to calling assign_random_cont_round(rng, round.0) on the real part, and the same with round.1 on the imaginary part.

fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String

Returns a string representation of self for the specified radix rounding to the nearest.

The exponent is encoded in decimal. The output string will have enough precision such that reading it again will give the exact same number.

Panics

Panics if radix is less than 2 or greater than 36.

fn to_string_radix_round(
    &self,
    radix: i32,
    num_digits: Option<usize>,
    round: (Round, Round)
) -> String

Returns a string representation of self for the specified radix applying the specified rounding method.

The exponent is encoded in decimal. The output string will have enough precision such that reading it again will give the exact same number.

Panics

Panics if radix is less than 2 or greater than 36.

fn from_str(src: &str, prec: (u32, u32)) -> Result<Complex, ParseComplexError>

Parses a Complex number with the specified precision, rounding to the nearest.

See the corresponding assignment.

fn from_str_radix(
    src: &str,
    radix: i32,
    prec: (u32, u32)
) -> Result<Complex, ParseComplexError>

Parses a Complex number with the specified radix and precision, rounding to the nearest.

See the corresponding assignment.

Panics

Panics if radix is less than 2 or greater than 36.

fn from_str_round(
    src: &str,
    prec: (u32, u32),
    round: (Round, Round)
) -> Result<(Complex, (Ordering, Ordering)), ParseComplexError>

Parses a Complex number with the specified precision, applying the specified rounding.

See the corresponding assignment.

fn from_str_radix_round(
    src: &str,
    radix: i32,
    prec: (u32, u32),
    round: (Round, Round)
) -> Result<(Complex, (Ordering, Ordering)), ParseComplexError>

Parses a Complex number with the specified radix and precision, applying the specified rounding.

See the corresponding assignment.

Panics

Panics if radix is less than 2 or greater than 36.

fn assign_str(&mut self, src: &str) -> Result<(), ParseComplexError>

Parses a Complex number from a string, rounding to the nearest.

Examples

use rugcom::Complex;
let mut c = Complex::new((53, 53));
c.assign_str("(12.5e2 2.5e-1)").unwrap();
assert!(*c.real() == 12.5e2);
assert!(*c.imag() == 2.5e-1);
let ret = c.assign_str("bad");
assert!(ret.is_err());

fn assign_str_radix(
    &mut self,
    src: &str,
    radix: i32
) -> Result<(), ParseComplexError>

Parses a Complex number from a string with the specified radix, rounding to the nearest.

Examples

use rugcom::Complex;
let mut c = Complex::new((53, 53));
c.assign_str_radix("f.f", 16).unwrap();
assert!(*c.real() == 15.9375);
assert!(*c.imag() == 0);

Panics

Panics if radix is less than 2 or greater than 36.

fn assign_str_round(
    &mut self,
    src: &str,
    round: (Round, Round)
) -> Result<(Ordering, Ordering), ParseComplexError>

Parses a Complex number from a string, applying the specified rounding.

Examples

extern crate rugflo;
extern crate rugcom;
use rugflo::Round;
use rugcom::Complex;
use std::cmp::Ordering;

fn main() {
    let mut c = Complex::new((4, 4));
    let round = (Round::Down, Round::Up);
    let dir = c.assign_str_round("(14.1 14.2)", round).unwrap();
    assert!(*c.real() == 14);
    assert!(*c.imag() == 15);
    assert!(dir == (Ordering::Less, Ordering::Greater));
}

fn assign_str_radix_round(
    &mut self,
    src: &str,
    radix: i32,
    round: (Round, Round)
) -> Result<(Ordering, Ordering), ParseComplexError>

Parses a Complex number from a string with the specified radix, applying the specified rounding.

Examples

extern crate rugflo;
extern crate rugcom;
use rugflo::Round;
use rugcom::Complex;
use std::cmp::Ordering;

fn main() {
    let mut c = Complex::new((4, 4));
    let round = (Round::Nearest, Round::Nearest);
    let dir = c.assign_str_radix_round("(c.c c.1)", 16, round).unwrap();
    assert!(*c.real() == 13);
    assert!(*c.imag() == 12);
    assert!(dir == (Ordering::Greater, Ordering::Less));
}

Panics

Panics if radix is less than 2 or greater than 36.

fn valid_str_radix(src: &str, radix: i32) -> Result<(), ParseComplexError>

Checks if a Complex number can be parsed.

If this method does not return an error, neither will any other function that parses a Complex number. If this method returns an error, the other functions will return the same error.

Panics

Panics if radix is less than 2 or greater than 36.

Trait Implementations

impl Drop for Complex

fn drop(&mut self)

A method called when the value goes out of scope.

impl Clone for Complex

fn clone(&self) -> Complex

Returns a copy of the value.

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

Performs copy-assignment from source.

impl From<(Float, Float)> for Complex

fn from((real, imag): (Float, Float)) -> Complex

Constructs a Complex number from a real Float and imaginary Float.

This constructor does not allocate, as it reuses the Float components.

impl<T> From<(T, (i32, i32))> for Complex where
    Complex: From<(T, (u32, u32))>, 

fn from((t, prec): (T, (i32, i32))) -> Complex

Performs the conversion.

impl<T> FromRound<T, (i32, i32)> for Complex where
    Complex: FromRound<T, (u32, u32), Round = (Round, Round), Ordering = (Ordering, Ordering)>, 

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn from_round(
    t: T,
    prec: (i32, i32),
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the conversion.

impl<T> From<(T, (i32, u32))> for Complex where
    Complex: From<(T, (u32, u32))>, 

fn from((t, prec): (T, (i32, u32))) -> Complex

Performs the conversion.

impl<T> FromRound<T, (i32, u32)> for Complex where
    Complex: FromRound<T, (u32, u32), Round = (Round, Round), Ordering = (Ordering, Ordering)>, 

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn from_round(
    t: T,
    prec: (i32, u32),
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the conversion.

impl<T> From<(T, (u32, i32))> for Complex where
    Complex: From<(T, (u32, u32))>, 

fn from((t, prec): (T, (u32, i32))) -> Complex

Performs the conversion.

impl<T> FromRound<T, (u32, i32)> for Complex where
    Complex: FromRound<T, (u32, u32), Round = (Round, Round), Ordering = (Ordering, Ordering)>, 

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn from_round(
    t: T,
    prec: (u32, i32),
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the conversion.

impl<T> From<(T, (u32, u32))> for Complex where
    Complex: FromRound<T, (u32, u32), Round = (Round, Round)>, 

fn from((t, prec): (T, (u32, u32))) -> Complex

Performs the conversion.

impl<T> FromRound<T, (u32, u32)> for Complex where
    Complex: AssignRound<T, Round = (Round, Round), Ordering = (Ordering, Ordering)>, 

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn from_round(
    t: T,
    prec: (u32, u32),
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the conversion.

impl<T> Assign<T> for Complex where
    Complex: AssignRound<T, Round = (Round, Round), Ordering = (Ordering, Ordering)>, 

fn assign(&mut self, other: T)

Peforms the assignement.

impl<'a> AssignRound<&'a Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: &Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl<T, U> AssignRound<(T, U)> for Complex where
    Float: AssignRound<T, Round = Round, Ordering = Ordering>,
    Float: AssignRound<U, Round = Round, Ordering = Ordering>, 

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: (T, U),
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl<'a> AssignRound<&'a Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: &'a Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl<'a> AssignRound<&'a Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: &'a Rational,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl<'a> AssignRound<&'a Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: &'a Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: Rational,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<Special> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: Special,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<Constant> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: Constant,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl AssignRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    other: f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment and rounding.

impl<'a> Add<&'a Complex> for Complex

type Output = Complex

The resulting type after applying the + operator

fn add(self, op: &'a Complex) -> Complex

The method for the + operator

impl Add<Complex> for Complex

type Output = Complex

The resulting type after applying the + operator

fn add(self, op: Complex) -> Complex

The method for the + operator

impl<'a> AddRound<&'a Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the addition.

fn add_round(
    self,
    op: &'a Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the addition.

impl AddRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the addition.

fn add_round(
    self,
    op: Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the addition.

impl<'a> AddAssign<&'a Complex> for Complex

fn add_assign(&mut self, op: &'a Complex)

The method for the += operator

impl AddAssign<Complex> for Complex

fn add_assign(&mut self, op: Complex)

The method for the += operator

impl<'a> Sub<&'a Complex> for Complex

type Output = Complex

The resulting type after applying the - operator

fn sub(self, op: &'a Complex) -> Complex

The method for the - operator

impl Sub<Complex> for Complex

type Output = Complex

The resulting type after applying the - operator

fn sub(self, op: Complex) -> Complex

The method for the - operator

impl<'a> SubRound<&'a Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the subtraction.

fn sub_round(
    self,
    op: &'a Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the subtraction.

impl SubRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the subtraction.

fn sub_round(
    self,
    op: Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the subtraction.

impl<'a> SubAssign<&'a Complex> for Complex

fn sub_assign(&mut self, op: &'a Complex)

The method for the -= operator

impl SubAssign<Complex> for Complex

fn sub_assign(&mut self, op: Complex)

The method for the -= operator

impl SubFromAssign for Complex

fn sub_from_assign(&mut self, lhs: Complex)

Peforms the subtraction.

impl<'a> SubFromAssign<&'a Complex> for Complex

fn sub_from_assign(&mut self, lhs: &Complex)

Peforms the subtraction.

impl<'a> Mul<&'a Complex> for Complex

type Output = Complex

The resulting type after applying the * operator

fn mul(self, op: &'a Complex) -> Complex

The method for the * operator

impl Mul<Complex> for Complex

type Output = Complex

The resulting type after applying the * operator

fn mul(self, op: Complex) -> Complex

The method for the * operator

impl<'a> MulRound<&'a Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the multiplication.

fn mul_round(
    self,
    op: &'a Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the multiplication.

impl MulRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the multiplication.

fn mul_round(
    self,
    op: Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the multiplication.

impl<'a> MulAssign<&'a Complex> for Complex

fn mul_assign(&mut self, op: &'a Complex)

The method for the *= operator

impl MulAssign<Complex> for Complex

fn mul_assign(&mut self, op: Complex)

The method for the *= operator

impl<'a> Div<&'a Complex> for Complex

type Output = Complex

The resulting type after applying the / operator

fn div(self, op: &'a Complex) -> Complex

The method for the / operator

impl Div<Complex> for Complex

type Output = Complex

The resulting type after applying the / operator

fn div(self, op: Complex) -> Complex

The method for the / operator

impl<'a> DivRound<&'a Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the division.

fn div_round(
    self,
    op: &'a Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the division.

impl DivRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the division.

fn div_round(
    self,
    op: Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the division.

impl<'a> DivAssign<&'a Complex> for Complex

fn div_assign(&mut self, op: &'a Complex)

The method for the /= operator

impl DivAssign<Complex> for Complex

fn div_assign(&mut self, op: Complex)

The method for the /= operator

impl DivFromAssign for Complex

fn div_from_assign(&mut self, lhs: Complex)

Peforms the division.

impl<'a> DivFromAssign<&'a Complex> for Complex

fn div_from_assign(&mut self, lhs: &Complex)

Peforms the division.

impl<'a> Add<&'a Float> for Complex

type Output = Complex

The resulting type after applying the + operator

fn add(self, op: &'a Float) -> Complex

The method for the + operator

impl Add<Float> for Complex

type Output = Complex

The resulting type after applying the + operator

fn add(self, op: Float) -> Complex

The method for the + operator

impl<'a> AddRound<&'a Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the addition.

fn add_round(
    self,
    op: &'a Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the addition.

impl AddRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the addition.

fn add_round(
    self,
    op: Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the addition.

impl<'a> AddAssign<&'a Float> for Complex

fn add_assign(&mut self, op: &'a Float)

The method for the += operator

impl AddAssign<Float> for Complex

fn add_assign(&mut self, op: Float)

The method for the += operator

impl<'a> Sub<&'a Float> for Complex

type Output = Complex

The resulting type after applying the - operator

fn sub(self, op: &'a Float) -> Complex

The method for the - operator

impl Sub<Float> for Complex

type Output = Complex

The resulting type after applying the - operator

fn sub(self, op: Float) -> Complex

The method for the - operator

impl<'a> SubRound<&'a Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the subtraction.

fn sub_round(
    self,
    op: &'a Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the subtraction.

impl SubRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the subtraction.

fn sub_round(
    self,
    op: Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the subtraction.

impl<'a> SubAssign<&'a Float> for Complex

fn sub_assign(&mut self, op: &'a Float)

The method for the -= operator

impl SubAssign<Float> for Complex

fn sub_assign(&mut self, op: Float)

The method for the -= operator

impl SubFromAssign<Float> for Complex

fn sub_from_assign(&mut self, lhs: Float)

Peforms the subtraction.

impl<'a> SubFromAssign<&'a Float> for Complex

fn sub_from_assign(&mut self, lhs: &Float)

Peforms the subtraction.

impl<'a> Mul<&'a Float> for Complex

type Output = Complex

The resulting type after applying the * operator

fn mul(self, op: &'a Float) -> Complex

The method for the * operator

impl Mul<Float> for Complex

type Output = Complex

The resulting type after applying the * operator

fn mul(self, op: Float) -> Complex

The method for the * operator

impl<'a> MulRound<&'a Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the multiplication.

fn mul_round(
    self,
    op: &'a Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the multiplication.

impl MulRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the multiplication.

fn mul_round(
    self,
    op: Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the multiplication.

impl<'a> MulAssign<&'a Float> for Complex

fn mul_assign(&mut self, op: &'a Float)

The method for the *= operator

impl MulAssign<Float> for Complex

fn mul_assign(&mut self, op: Float)

The method for the *= operator

impl<'a> Div<&'a Float> for Complex

type Output = Complex

The resulting type after applying the / operator

fn div(self, op: &'a Float) -> Complex

The method for the / operator

impl Div<Float> for Complex

type Output = Complex

The resulting type after applying the / operator

fn div(self, op: Float) -> Complex

The method for the / operator

impl<'a> DivRound<&'a Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the division.

fn div_round(
    self,
    op: &'a Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the division.

impl DivRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the division.

fn div_round(
    self,
    op: Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the division.

impl<'a> DivAssign<&'a Float> for Complex

fn div_assign(&mut self, op: &'a Float)

The method for the /= operator

impl DivAssign<Float> for Complex

fn div_assign(&mut self, op: Float)

The method for the /= operator

impl DivFromAssign<Float> for Complex

fn div_from_assign(&mut self, lhs: Float)

Peforms the division.

impl<'a> DivFromAssign<&'a Float> for Complex

fn div_from_assign(&mut self, lhs: &Float)

Peforms the division.

impl Add<u32> for Complex

type Output = Complex

The resulting type after applying the + operator

fn add(self, op: u32) -> Complex

The method for the + operator

impl AddRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the addition.

fn add_round(
    self,
    op: u32,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the addition.

impl AddAssign<u32> for Complex

fn add_assign(&mut self, op: u32)

The method for the += operator

impl Sub<u32> for Complex

type Output = Complex

The resulting type after applying the - operator

fn sub(self, op: u32) -> Complex

The method for the - operator

impl SubRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the subtraction.

fn sub_round(
    self,
    op: u32,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the subtraction.

impl SubAssign<u32> for Complex

fn sub_assign(&mut self, op: u32)

The method for the -= operator

impl SubFromAssign<u32> for Complex

fn sub_from_assign(&mut self, lhs: u32)

Peforms the subtraction.

impl Mul<u32> for Complex

type Output = Complex

The resulting type after applying the * operator

fn mul(self, op: u32) -> Complex

The method for the * operator

impl MulRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the multiplication.

fn mul_round(
    self,
    op: u32,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the multiplication.

impl MulAssign<u32> for Complex

fn mul_assign(&mut self, op: u32)

The method for the *= operator

impl Mul<i32> for Complex

type Output = Complex

The resulting type after applying the * operator

fn mul(self, op: i32) -> Complex

The method for the * operator

impl MulRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the multiplication.

fn mul_round(
    self,
    op: i32,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the multiplication.

impl MulAssign<i32> for Complex

fn mul_assign(&mut self, op: i32)

The method for the *= operator

impl Div<u32> for Complex

type Output = Complex

The resulting type after applying the / operator

fn div(self, op: u32) -> Complex

The method for the / operator

impl DivRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the division.

fn div_round(
    self,
    op: u32,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the division.

impl DivAssign<u32> for Complex

fn div_assign(&mut self, op: u32)

The method for the /= operator

impl DivFromAssign<u32> for Complex

fn div_from_assign(&mut self, lhs: u32)

Peforms the division.

impl SubFromAssign<(u32, u32)> for Complex

fn sub_from_assign(&mut self, lhs: (u32, u32))

Peforms the subtraction.

impl Neg for Complex

type Output = Complex

The resulting type after applying the - operator

fn neg(self) -> Complex

The method for the unary - operator

impl NegAssign for Complex

fn neg_assign(&mut self)

Peforms the negation.

impl Shl<u32> for Complex

type Output = Complex

The resulting type after applying the << operator

fn shl(self, op: u32) -> Complex

Multiplies self by 2 to the power of op, rounding to the nearest.

impl ShlRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the left shift operation.

fn shl_round(
    self,
    op: u32,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Multiplies self by 2 to the power of op, applying the specified rounding.

impl ShlAssign<u32> for Complex

fn shl_assign(&mut self, op: u32)

Multiplies self by 2 to the power of op, rounding to the nearest.

impl Shr<u32> for Complex

type Output = Complex

The resulting type after applying the >> operator

fn shr(self, op: u32) -> Complex

Divides self by 2 to the power of op, rounding to the nearest.

impl ShrRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the right shift operation.

fn shr_round(
    self,
    op: u32,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Divides self by 2 to the power of op, applying the specified rounding.

impl ShrAssign<u32> for Complex

fn shr_assign(&mut self, op: u32)

Divides self by 2 to the power of op, rounding to the nearest.

impl Shl<i32> for Complex

type Output = Complex

The resulting type after applying the << operator

fn shl(self, op: i32) -> Complex

Multiplies self by 2 to the power of op, rounding to the nearest.

impl ShlRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the left shift operation.

fn shl_round(
    self,
    op: i32,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Multiplies self by 2 to the power of op, applying the specified rounding.

impl ShlAssign<i32> for Complex

fn shl_assign(&mut self, op: i32)

Multiplies self by 2 to the power of op, rounding to the nearest.

impl Shr<i32> for Complex

type Output = Complex

The resulting type after applying the >> operator

fn shr(self, op: i32) -> Complex

Divides self by 2 to the power of op, rounding to the nearest.

impl ShrRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the right shift operation.

fn shr_round(
    self,
    op: i32,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Divides self by 2 to the power of op, applying the specified rounding.

impl ShrAssign<i32> for Complex

fn shr_assign(&mut self, op: i32)

Divides self by 2 to the power of op, rounding to the nearest.

impl<'a> PowRound<&'a Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the power operation.

fn pow_round(
    self,
    op: &'a Integer,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the power operation.

impl<'a> PowAssign<&'a Integer> for Complex

fn pow_assign(&mut self, op: &'a Integer)

Peforms the power operation.

impl<'a> PowRound<&'a Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the power operation.

fn pow_round(
    self,
    op: &'a Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the power operation.

impl<'a> PowAssign<&'a Float> for Complex

fn pow_assign(&mut self, op: &'a Float)

Peforms the power operation.

impl<'a> PowRound<&'a Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the power operation.

fn pow_round(
    self,
    op: &'a Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the power operation.

impl<'a> PowAssign<&'a Complex> for Complex

fn pow_assign(&mut self, op: &'a Complex)

Peforms the power operation.

impl<'a> Pow<&'a Integer> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, op: &'a Integer) -> Complex

Performs the power operation.

impl Pow<Integer> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, op: Integer) -> Complex

Performs the power operation.

impl PowRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the power operation.

fn pow_round(
    self,
    op: Integer,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the power operation.

impl PowAssign<Integer> for Complex

fn pow_assign(&mut self, op: Integer)

Peforms the power operation.

impl<'a> Pow<&'a Float> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, op: &'a Float) -> Complex

Performs the power operation.

impl Pow<Float> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, op: Float) -> Complex

Performs the power operation.

impl PowRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the power operation.

fn pow_round(
    self,
    op: Float,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the power operation.

impl PowAssign<Float> for Complex

fn pow_assign(&mut self, op: Float)

Peforms the power operation.

impl<'a> Pow<&'a Complex> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, op: &'a Complex) -> Complex

Performs the power operation.

impl Pow<Complex> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, op: Complex) -> Complex

Performs the power operation.

impl PowRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

type Output = Complex

The resulting type after the power operation.

fn pow_round(
    self,
    op: Complex,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering))

Performs the power operation.

impl PowAssign<Complex> for Complex

fn pow_assign(&mut self, op: Complex)

Peforms the power operation.

impl PartialEq for Complex

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl<T, U> PartialEq<(T, U)> for Complex where
    Float: PartialEq<T>,
    Float: PartialEq<U>, 

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialEq<Integer> for Complex

fn eq(&self, other: &Integer) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialEq<Rational> for Complex

fn eq(&self, other: &Rational) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialEq<Float> for Complex

fn eq(&self, other: &Float) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialEq<u32> for Complex

fn eq(&self, other: &u32) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialEq<i32> for Complex

fn eq(&self, other: &i32) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialEq<f64> for Complex

fn eq(&self, other: &f64) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl PartialEq<f32> for Complex

fn eq(&self, other: &f32) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Display for Complex

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

Formats the value using the given formatter.

impl Debug for Complex

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

Formats the value using the given formatter.

impl LowerExp for Complex

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

Formats the value using the given formatter.

impl UpperExp for Complex

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

Formats the value using the given formatter.

impl Binary for Complex

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

Formats the value using the given formatter.

impl Octal for Complex

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

Formats the value using the given formatter.

impl LowerHex for Complex

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

Formats the value using the given formatter.

impl UpperHex for Complex

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

Formats the value using the given formatter.