Struct rug::Complex

pub struct Complex { /* fields omitted */ }

A multi-precision complex number with arbitrarily large precision and correct rounding.

The precision has to be set during construction. The rounding method of the required operations can be specified, and the direction of the rounding is returned.

Examples

use rug::{Assign, Complex, Float};
let c = Complex::with_val(53, (40, 30));
assert_eq!(format!("{:.3}", c), "(4.00e1 3.00e1)");
let mut f = Float::with_val(53, c.abs_ref());
assert_eq!(f, 50);
f.assign(c.arg_ref());
assert_eq!(f, 0.75_f64.atan());

Operations on two borrowed Complex numbers result in an intermediate value that has to be assigned to a new Complex value.

use rug::Complex;
let a = Complex::with_val(53, (10.5, -11));
let b = Complex::with_val(53, (-1.25, -1.5));
let a_b_ref = &a + &b;
let a_b = Complex::with_val(53, a_b_ref);
assert_eq!(a_b, (9.25, -12.5));

As a special case, when an intermediate value is obtained from multiplying two Complex references, it can be added to or subtracted from another Complex (or reference). This will result in a fused multiply-accumulate operation, with only one rounding operation taking place.

use rug::Complex;
let mut acc = Complex::with_val(53, (1000, 1000));
let m1 = Complex::with_val(53, (10, 0));
let m2 = Complex::with_val(53, (1, -1));
// (1000 + 1000i) - (10 + 0i) * (1 - i) = (990 + 1010i)
acc -= &m1 * &m2;
assert_eq!(acc, (990, 1010));

The Complex type supports various functions. Most methods have four versions:

1. The first method consumes the operand and rounds the returned Complex to the nearest representable value.
2. The second method has a _mut suffix, mutates the operand and rounds it the nearest representable value.
3. The third method has a _round suffix, mutates the operand, applies the specified rounding method to the real and imaginary parts, and returns the rounding direction for both:
   • Ordering::Less if the stored part is less than the exact result,
   • Ordering::Equal if the stored part is equal to the exact result,
   • Ordering::Greater if the stored part is greater than the exact result.
4. The fourth method has a _ref suffix and borrows the operand. The returned item can be assigned to a Complex, and the rounding method is selected during the assignment.

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let expected = Complex::with_val(53, (1.2985, 0.6350));

// 1. consume the operand, round to nearest
let a = Complex::with_val(53, (1, 1));
let sin_a = a.sin();
assert!((sin_a - &expected).abs() < 0.0001);

// 2. mutate the operand, round to nearest
let mut b = Complex::with_val(53, (1, 1));
b.sin_mut();
assert!((b - &expected).abs() < 0.0001);

// 3. mutate the operand, apply specified rounding
let mut c = Complex::with_val(4, (1, 1));
// using 4 significant bits, 1.2985 is rounded down to 1.25
// and 0.6350 is rounded down to 0.625.
let dir = c.sin_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (1.25, 0.625));
assert_eq!(dir, (Ordering::Less, Ordering::Less));

// 4. borrow the operand
let d = Complex::with_val(53, (1, 1));
let r = d.sin_ref();
let sin_d = Complex::with_val(53, r);
assert!((sin_d - &expected).abs() < 0.0001);
// d was not consumed
assert_eq!(d, (1, 1));

Methods

impl Complex

fn new<P: Prec>(prec: P) -> Complex

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

Examples

use rug::Complex;
let c1 = Complex::new(32);
assert_eq!(c1.prec(), (32, 32));
assert_eq!(c1, 0);
let c2 = Complex::new((32, 64));
assert_eq!(c2.prec(), (32, 64));
assert_eq!(c2, 0);

Panics

Panics if the precision is out of the allowed range.

fn with_val<P: Prec, T>(prec: P, val: T) -> Complex where
    Complex: Assign<T>, 

Create a new complex number with the specified precision and with the given value, rounding to the nearest.

Examples

use rug::Complex;
let c1 = Complex::with_val(53, (1.3f64, -12));
assert_eq!(c1.prec(), (53, 53));
assert_eq!(c1, (1.3f64, -12));
let c2 = Complex::with_val(53, 42.0);
assert_eq!(c2.prec(), (53, 53));
assert_eq!(c2, 42);
assert_eq!(c2, (42, 0));

Panics

Panics if prec is out of the allowed range.

fn with_val_round<P: Prec, T>(
    prec: P,
    val: T,
    round: (Round, Round)
) -> (Complex, (Ordering, Ordering)) where
    Complex: AssignRound<T, Round = (Round, Round), Ordering = (Ordering, Ordering)>, 

Create a new floating-point number with the specified precision and with the given value, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let round = (Round::Down, Round::Up);
let (c, dir) = Complex::with_val_round(4, (3.3, 2.3), round);
// 3.3 is rounded down to 3.25, 2.3 is rounded up to 2.5
assert_eq!(c.prec(), (4, 4));
assert_eq!(c, (3.25, 2.5));
assert_eq!(dir, (Ordering::Less, Ordering::Greater));

Panics

Panics if prec is out of the allowed range.

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

Returns the precision of the real and imaginary parts.

Examples

use rug::Complex;
let r = Complex::new((24, 53));
assert_eq!(r.prec(), (24, 53));

fn set_prec<P: Prec>(&mut self, prec: P)

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

Examples

use rug::Complex;
let mut r = Complex::with_val(6, (4.875, 4.625));
assert_eq!(r, (4.875, 4.625));
r.set_prec(4);
assert_eq!(r, (5.0, 4.5));

Panics

Panics if the precision is out of the allowed range.

fn set_prec_round<P: Prec>(
    &mut self,
    prec: P,
    round: (Round, Round)
) -> (Ordering, Ordering)

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

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let mut r = Complex::with_val(6, (4.875, 4.625));
assert_eq!(r, (4.875, 4.625));
let dir = r.set_prec_round(4, (Round::Down, Round::Up));
assert_eq!(r, (4.5, 5.0));
assert_eq!(dir, (Ordering::Less, Ordering::Greater));

Panics

Panics if the precision is out of the allowed range.

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

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

Examples

use rug::Complex;
let c = Complex::from_str("(12.5e2 2.5e-1)", 53).unwrap();
assert_eq!(*c.real(), 12.5e2);
assert_eq!(*c.imag(), 2.5e-1);
let bad = Complex::from_str("bad", 53);
assert!(bad.is_err());

Errors

If the string is not correctly formatted, a ParseComplexError is returned.

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

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

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let round = (Round::Down, Round::Up);
let res = Complex::from_str_round("(14.1 14.2)", 4, round);
let (c, dir) = res.unwrap();
assert_eq!(*c.real(), 14);
assert_eq!(*c.imag(), 15);
assert_eq!(dir, (Ordering::Less, Ordering::Greater));

Errors

If the string is not correctly formatted, a ParseComplexError is returned.

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

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

Examples

use rug::Complex;
let c = Complex::from_str_radix("f.f", 16, 53).unwrap();
assert_eq!(*c.real(), 15.9375);
assert_eq!(*c.imag(), 0);

Errors

If the string is not correctly formatted, a ParseComplexError is returned.

Panics

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

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

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

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let round = (Round::Nearest, Round::Nearest);
let res = Complex::from_str_radix_round("(c.c c.1)", 16, 4, round);
let (c, dir) = res.unwrap();
assert_eq!(*c.real(), 13);
assert_eq!(*c.imag(), 12);
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

Errors

If the string is not correctly formatted, a ParseComplexError is returned.

Panics

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

fn valid_str_radix(
    src: &str,
    radix: i32
) -> Result<ValidComplex, 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.

Examples

use rug::Complex;

let valid1 = Complex::valid_str_radix("(1.2e-1 2.3e+2)", 4);
let c1 = Complex::with_val(53, valid1.unwrap());
assert_eq!(c1, (0.25 * (1.0 + 0.25 * 2.0), 4.0 * (3.0 + 4.0 * 2.0)));
let valid2 = Complex::valid_str_radix("(12 yz)", 36);
let c2 = Complex::with_val(53, valid2.unwrap());
assert_eq!(c2, (2.0 + 36.0 * 1.0, 35.0 + 36.0 * 34.0));

let invalid = Complex::valid_str_radix("(0, 0)", 3);
let invalid_f = Complex::from_str_radix("(0, 0)", 3, 53);
assert_eq!(invalid.unwrap_err(), invalid_f.unwrap_err());

Errors

If the string is not correctly formatted, a ParseComplexError is returned.

Panics

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

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

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

The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.

Examples

use rug::Complex;
let c1 = Complex::with_val(53, 0);
assert_eq!(c1.to_string_radix(10, None), "(0.0 0.0)");
let c2 = Complex::with_val(12, (15, 5));
assert_eq!(c2.to_string_radix(16, None), "(f.000 5.000)");
let c3 = Complex::with_val(53, (10, -4));
assert_eq!(c3.to_string_radix(10, Some(3)), "(1.00e1 -4.00)");
assert_eq!(c3.to_string_radix(5, Some(3)), "(2.00e1 -4.00)");

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 the value for the specified radix applying the specified rounding method.

The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.

Examples

use rug::Complex;
use rug::float::Round;
let c = Complex::with_val(10, 10.4);
let down = (Round::Down, Round::Down);
let nearest = (Round::Nearest, Round::Nearest);
let up = (Round::Up, Round::Up);
let nd = c.to_string_radix_round(10, None, down);
assert_eq!(nd, "(1.0406e1 0.0)");
let nu = c.to_string_radix_round(10, None, up);
assert_eq!(nu, "(1.0407e1 0.0)");
let sd = c.to_string_radix_round(10, Some(2), down);
assert_eq!(sd, "(1.0e1 0.0)");
let sn = c.to_string_radix_round(10, Some(2), nearest);
assert_eq!(sn, "(1.0e1 0.0)");
let su = c.to_string_radix_round(10, Some(2), up);
assert_eq!(su, "(1.1e1 0.0)");

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 rug::Complex;
let mut c = Complex::new(53);
c.assign_str("(12.5e2 2.5e-1)").unwrap();
assert_eq!(*c.real(), 12.5e2);
assert_eq!(*c.imag(), 2.5e-1);
let ret = c.assign_str("bad");
assert!(ret.is_err());

Errors

If the string is not correctly formatted, a ParseComplexError is returned.

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

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
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_eq!(*c.real(), 14);
assert_eq!(*c.imag(), 15);
assert_eq!(dir, (Ordering::Less, Ordering::Greater));

Errors

If the string is not correctly formatted, a ParseComplexError is returned.

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 rug::Complex;
let mut c = Complex::new(53);
c.assign_str_radix("f.f", 16).unwrap();
assert_eq!(*c.real(), 15.9375);
assert_eq!(*c.imag(), 0);

Errors

If the string is not correctly formatted, a ParseComplexError is returned.

Panics

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

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

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
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_eq!(*c.real(), 13);
assert_eq!(*c.imag(), 12);
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

Errors

If the string is not correctly formatted, a ParseComplexError is returned.

Panics

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

unsafe fn from_raw(raw: mpc_t) -> Complex

Creates a Complex from an initialized MPC complex number.

Safety

• The value must be initialized.
• The gmp_mpfr_sys::mpc::mpc_t type can be considered as a kind of pointer, so there can be can multiple copies of it. Since this function takes over ownership, no other copies of the passed value should exist.

Examples

extern crate gmp_mpfr_sys;
extern crate rug;
use gmp_mpfr_sys::mpc;
use rug::Complex;
use std::mem;
fn main() {
    let c = unsafe {
        let mut m = mem::uninitialized();
        mpc::init3(&mut m, 53, 53);
        mpc::set_d_d(&mut m, -14.5, 3.25, mpc::RNDNN);
        // m is initialized and unique
        Complex::from_raw(m)
    };
    assert_eq!(c, (-14.5, 3.25));
    // since c is a Complex now, deallocation is automatic
}

fn into_raw(self) -> mpc_t

Converts a Complex into an MPC complex number.

The returned object should be freed to avoid memory leaks.

Examples

extern crate gmp_mpfr_sys;
extern crate rug;
use gmp_mpfr_sys::{mpc, mpfr};
use rug::Complex;
fn main() {
    let c = Complex::with_val(53, (-14.5, 3.25));
    let mut m = c.into_raw();
    unsafe {
        let re_ptr = mpc::realref_const(&m);
        let re = mpfr::get_d(re_ptr, mpfr::rnd_t::RNDN);
        assert_eq!(re, -14.5);
        let im_ptr = mpc::imagref_const(&m);
        let im = mpfr::get_d(im_ptr, mpfr::rnd_t::RNDN);
        assert_eq!(im, 3.25);
        // free object to prevent memory leak
        mpc::clear(&mut m);
    }
}

fn as_raw(&self) -> *const mpc_t

Returns a pointer to the internal MPC complex number.

The returned pointer will be valid for as long as self is valid.

Examples

extern crate gmp_mpfr_sys;
extern crate rug;
use gmp_mpfr_sys::{mpc, mpfr};
use rug::Complex;
fn main() {
    let c = Complex::with_val(53, (-14.5, 3.25));
    let m_ptr = c.as_raw();
    unsafe {
        let re_ptr = mpc::realref_const(m_ptr);
        let re = mpfr::get_d(re_ptr, mpfr::rnd_t::RNDN);
        assert_eq!(re, -14.5);
        let im_ptr = mpc::imagref_const(m_ptr);
        let im = mpfr::get_d(im_ptr, mpfr::rnd_t::RNDN);
        assert_eq!(im, 3.25);
    }
    // c is still valid
    assert_eq!(c, (-14.5, 3.25));
}

fn as_raw_mut(&mut self) -> *mut mpc_t

Returns an unsafe mutable pointer to the internal MPC complex number.

The returned pointer will be valid for as long as self is valid.

Examples

extern crate gmp_mpfr_sys;
extern crate rug;
use gmp_mpfr_sys::mpc;
use rug::Complex;
fn main() {
    let mut c = Complex::with_val(53, (-14.5, 3.25));
    let m_ptr = c.as_raw_mut();
    unsafe {
        mpc::conj(m_ptr, m_ptr, mpc::RNDNN);
    }
    assert_eq!(c, (-14.5, -3.25));
}

fn real(&self) -> &Float

Borrows the real part as a Float.

Examples

use rug::Complex;
let c = Complex::with_val(53, (12.5, -20.75));
assert_eq!(*c.real(), 12.5)

fn imag(&self) -> &Float

Borrows the imaginary part as a Float.

Examples

use rug::Complex;
let c = Complex::with_val(53, (12.5, -20.75));
assert_eq!(*c.imag(), -20.75)

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

Borrows the real part mutably.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (12.5, -20.75));
assert_eq!(c, (12.5, -20.75));
*c.mut_real() /= 2;
assert_eq!(c, (6.25, -20.75));

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

Borrows the imaginary part mutably.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (12.5, -20.75));
assert_eq!(c, (12.5, -20.75));
*c.mut_imag() *= 4;
assert_eq!(c, (12.5, -83));

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

Borrows the real and imaginary parts.

Examples

use rug::Complex;
let c = Complex::with_val(53, (12.5, -20.75));
assert_eq!(c, (12.5, -20.75));
let (re, im) = c.as_real_imag();
assert_eq!(*re, 12.5);
assert_eq!(*im, -20.75);

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

Borrows the real and imaginary parts mutably.

Examples

use rug::Complex;

let mut c = Complex::with_val(53, (12.5, -20.75));
{
    let (real, imag) = c.as_mut_real_imag();
    *real /= 2;
    *imag *= 4;
    // borrow ends here
}
assert_eq!(c, (6.25, -83));

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

Consumes and converts the value into real and imaginary Float values.

This function reuses the allocated memory and does not allocate any new memory.

use rug::Complex;
let c = Complex::with_val(53, (12.5, -20.75));
let (real, imag) = c.into_real_imag();
assert_eq!(real, 12.5);
assert_eq!(imag, -20.75);

fn as_neg(&self) -> BorrowComplex

Borrows a negated copy of the Complex number.

The returned object implements Deref<Target = Complex>.

This method performs a shallow copy and negates it, and negation does not change the allocated data.

Examples

use rug::Complex;
let c = Complex::with_val(53, (4.2, -2.3));
let neg_c = c.as_neg();
assert_eq!(*neg_c, (-4.2, 2.3));
// methods taking &self can be used on the returned object
let reneg_c = neg_c.as_neg();
assert_eq!(*reneg_c, (4.2, -2.3));
assert_eq!(*reneg_c, c);

fn as_conj(&self) -> BorrowComplex

Borrows a conjugate copy of the Complex number.

The returned object implements Deref<Target = Complex>.

This method performs a shallow copy and negates its imaginary part, and negation does not change the allocated data.

Examples

use rug::Complex;
let c = Complex::with_val(53, (4.2, -2.3));
let conj_c = c.as_conj();
assert_eq!(*conj_c, (4.2, 2.3));
// methods taking &self can be used on the returned object
let reconj_c = conj_c.as_conj();
assert_eq!(*reconj_c, (4.2, -2.3));
assert_eq!(*reconj_c, c);

fn as_mul_i(&self, negative: bool) -> BorrowComplex

Borrows a rotated copy of the Complex number.

The returned object implements Deref<Target = Complex>.

This method operates by performing some shallow copying; unlike the mul_i method and friends, this method swaps the precision of the real and imaginary parts if they have unequal precisions.

Examples

use rug::Complex;
let c = Complex::with_val(53, (4.2, -2.3));
let mul_i_c = c.as_mul_i(false);
assert_eq!(*mul_i_c, (2.3, 4.2));
// methods taking &self can be used on the returned object
let mul_ii_c = mul_i_c.as_mul_i(false);
assert_eq!(*mul_ii_c, (-4.2, 2.3));
let mul_1_c = mul_i_c.as_mul_i(true);
assert_eq!(*mul_1_c, (4.2, -2.3));
assert_eq!(*mul_1_c, c);

fn as_ord(&self) -> &OrdComplex

Borrows the Complex as an ordered complex number of type OrdComplex.

Examples

use rug::Complex;
use rug::float::Special;
use std::cmp::Ordering;

let nan_c = Complex::with_val(53, (Special::Nan, Special::Nan));
let nan = nan_c.as_ord();
assert_eq!(nan.cmp(nan), Ordering::Equal);

let one_neg0_c = Complex::with_val(53, (1, Special::NegZero));
let one_neg0 = one_neg0_c.as_ord();
let one_pos0_c = Complex::with_val(53, (1, Special::Zero));
let one_pos0 = one_pos0_c.as_ord();
assert_eq!(one_neg0.cmp(one_pos0), Ordering::Less);

let zero_inf_s = (Special::Zero, Special::Infinity);
let zero_inf_c = Complex::with_val(53, zero_inf_s);
let zero_inf = zero_inf_c.as_ord();
assert_eq!(one_pos0.cmp(zero_inf), Ordering::Greater);

fn cmp_abs(&self, other: &Complex) -> Option<Ordering>

Compares the absolute values of self and other.

Examples

use rug::Complex;
use std::cmp::Ordering;
let a = Complex::with_val(53, (5, 0));
let b = Complex::with_val(53, (3, -4));
let c = Complex::with_val(53, (-4, -4));
assert_eq!(a.cmp_abs(&b), Some(Ordering::Equal));
assert_eq!(a.cmp_abs(&c), Some(Ordering::Less));

fn mul_add(self, mul: &Self, add: &Self) -> Self

Multiplies and adds in one fused operation, rounding to the nearest with only one rounding error.

a.mul_add(&b, &c) produces a result like &a * &b + &c, but a is consumed and the result produced uses its precision.

Examples

use rug::Complex;
let a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) * (1 - i) + (1000 + 1000i) = (1010 + 990i)
let mul_add = a.mul_add(&b, &c);
assert_eq!(mul_add, (1010, 990));

fn mul_add_mut(&mut self, mul: &Self, add: &Self)

Multiplies and adds in one fused operation, rounding to the nearest with only one rounding error.

a.mul_add_mut(&b, &c) produces a result like &a * &b + &c, but stores the result in a using its precision.

Examples

use rug::Complex;
let mut a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) * (1 - i) + (1000 + 1000i) = (1010 + 990i)
a.mul_add_mut(&b, &c);
assert_eq!(a, (1010, 990));

fn mul_add_round(
    &mut self,
    mul: &Self,
    add: &Self,
    round: (Round, Round)
) -> (Ordering, Ordering)

Multiplies and adds in one fused operation, applying the specified rounding method with only one rounding error.

a.mul_add_round(&b, &c, round) produces a result like ans.assign_round(&a * &b + &c, round), but stores the result in a using its precision rather than in another Complex like ans.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let mut a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) * (1 - i) + (1000 + 1000i) = (1010 + 990i)
let dir = a.mul_add_round(&b, &c, (Round::Nearest, Round::Nearest));
assert_eq!(a, (1010, 990));
assert_eq!(dir, (Ordering::Equal, Ordering::Equal));

fn mul_add_ref<'a>(&'a self, mul: &'a Self, add: &'a Self) -> AddMulRef<'a>

Multiplies and adds in one fused operation.

AssignRound<Src> for Complex is implemented with the returned object as Src.

a.mul_add_ref(&b, &c) produces the exact same result as &a * &b + &c.

Examples

use rug::Complex;
let a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) * (1 - i) + (1000 + 1000i) = (1010 + 990i)
let ans = Complex::with_val(53, a.mul_add_ref(&b, &c));
assert_eq!(ans, (1010, 990));

fn mul_sub(self, mul: &Self, sub: &Self) -> Self

Multiplies and subtracts in one fused operation, rounding to the nearest with only one rounding error.

a.mul_sub(&b, &c) produces a result like &a * &b - &c, but a is consumed and the result produced uses its precision.

Examples

use rug::Complex;
let a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) * (1 - i) - (1000 + 1000i) = (-990 - 1010i)
let mul_sub = a.mul_sub(&b, &c);
assert_eq!(mul_sub, (-990, -1010));

fn mul_sub_mut(&mut self, mul: &Self, sub: &Self)

Multiplies and subtracts in one fused operation, rounding to the nearest with only one rounding error.

a.mul_sub_mut(&b, &c) produces a result like &a * &b - &c, but stores the result in a using its precision.

Examples

use rug::Complex;
let mut a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) * (1 - i) - (1000 + 1000i) = (-990 - 1010i)
a.mul_sub_mut(&b, &c);
assert_eq!(a, (-990, -1010));

fn mul_sub_round(
    &mut self,
    mul: &Self,
    sub: &Self,
    round: (Round, Round)
) -> (Ordering, Ordering)

Multiplies and subtracts in one fused operation, applying the specified rounding method with only one rounding error.

a.mul_sub_round(&b, &c, round) produces a result like ans.assign_round(&a * &b - &c, round), but stores the result in a using its precision rather than in another Complex like ans.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let mut a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) * (1 - i) - (1000 + 1000i) = (-990 - 1010i)
let dir = a.mul_sub_round(&b, &c, (Round::Nearest, Round::Nearest));
assert_eq!(a, (-990, -1010));
assert_eq!(dir, (Ordering::Equal, Ordering::Equal));

fn mul_sub_ref<'a>(&'a self, mul: &'a Self, sub: &'a Self) -> SubMulFromRef<'a>

Multiplies and subtracts in one fused operation.

AssignRound<Src> for Complex is implemented with the returned object as Src.

a.mul_sub_ref(&b, &c) produces the exact same result as &a * &b - &c.

Examples

use rug::Complex;
let a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) * (1 - i) - (1000 + 1000i) = (-990 - 1010i)
let ans = Complex::with_val(53, a.mul_sub_ref(&b, &c));
assert_eq!(ans, (-990, -1010));

fn proj(self) -> Self

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

If no parts of the number are infinite, the result is unchanged. If any part is infinite, the real part of the result is set to +∞ and the imaginary part of the result is set to 0 with the same sign as the imaginary part of the input.

Examples

use rug::Complex;
use std::f64;
let c1 = Complex::with_val(53, (1.5, 2.5));
let proj1 = c1.proj();
assert_eq!(proj1, (1.5, 2.5));
let c2 = Complex::with_val(53, (f64::NAN, f64::NEG_INFINITY));
let proj2 = c2.proj();
assert_eq!(proj2, (f64::INFINITY, 0.0));
// imaginary was negative, so now it is minus zero
assert!(proj2.imag().is_sign_negative());

fn proj_mut(&mut self)

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

If no parts of the number are infinite, the result is unchanged. If any part is infinite, the real part of the result is set to +∞ and the imaginary part of the result is set to 0 with the same sign as the imaginary part of the input.

Examples

use rug::Complex;
use std::f64;
let mut c1 = Complex::with_val(53, (1.5, 2.5));
c1.proj_mut();
assert_eq!(c1, (1.5, 2.5));
let mut c2 = Complex::with_val(53, (f64::NAN, f64::NEG_INFINITY));
c2.proj_mut();
assert_eq!(c2, (f64::INFINITY, 0.0));
// imaginary was negative, so now it is minus zero
assert!(c2.imag().is_sign_negative());

fn proj_ref(&self) -> ProjRef

Computes the projection onto the Riemann sphere.

If no parts of the number are infinite, the result is unchanged. If any part is infinite, the real part of the result is set to +∞ and the imaginary part of the result is set to 0 with the same sign as the imaginary part of the input.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
use std::f64;
let c1 = Complex::with_val(53, (f64::INFINITY, 50));
let proj1 = Complex::with_val(53, c1.proj_ref());
assert_eq!(proj1, (f64::INFINITY, 0.0));
let c2 = Complex::with_val(53, (f64::NAN, f64::NEG_INFINITY));
let proj2 = Complex::with_val(53, c2.proj_ref());
assert_eq!(proj2, (f64::INFINITY, 0.0));
// imaginary was negative, so now it is minus zero
assert!(proj2.imag().is_sign_negative());

fn square(self) -> Self

Computes the square, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, -2));
// (1 - 2i) squared is (-3 - 4i)
let square = c.square();
assert_eq!(square, (-3, -4));

fn square_mut(&mut self)

Computes the square, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, -2));
// (1 - 2i) squared is (-3 - 4i)
c.square_mut();
assert_eq!(c, (-3, -4));

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

Computes the square, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let mut c = Complex::with_val(4, (1.25, 1.25));
// (1.25 + 1.25i) squared is (0 + 3.125i).
// With 4 bits of precision, 3.125 is rounded down to 3.
let dir = c.square_round((Round::Down, Round::Down));
assert_eq!(c, (0, 3));
assert_eq!(dir, (Ordering::Equal, Ordering::Less));

fn square_ref(&self) -> SquareRef

Computes the square.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let c = Complex::with_val(53, (1.25, 1.25));
// (1.25 + 1.25i) squared is (0 + 3.125i).
let r = c.square_ref();
// With 4 bits of precision, 3.125 is rounded down to 3.
let round = (Round::Down, Round::Down);
let (square, dir) = Complex::with_val_round(4, r, round);
assert_eq!(square, (0, 3));
assert_eq!(dir, (Ordering::Equal, Ordering::Less));

fn sqrt(self) -> Self

Computes the square root, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (-1, 0));
// square root of (-1 + 0i) is (0 + i)
let sqrt = c.sqrt();
assert_eq!(sqrt, (0, 1));

fn sqrt_mut(&mut self)

Computes the square root, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (-1, 0));
// square root of (-1 + 0i) is (0 + i)
c.sqrt_mut();
assert_eq!(c, (0, 1));

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

Computes the square root, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let mut c = Complex::with_val(4, (2, 2.25));
// Square root of (2 + 2.25i) is (1.5828 + 0.7108i).
// Nearest with 4 bits of precision: (1.625 + 0.6875i)
let dir = c.sqrt_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (1.625, 0.6875));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

fn sqrt_ref(&self) -> SqrtRef

Computes the square root.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let c = Complex::with_val(53, (2, 2.25));
// Square root of (2 + 2.25i) is (1.5828 + 0.7108i).
let r = c.sqrt_ref();
// Nearest with 4 bits of precision: (1.625 + 0.6875i)
let nearest = (Round::Nearest, Round::Nearest);
let (sqrt, dir) = Complex::with_val_round(4, r, nearest);
assert_eq!(sqrt, (1.625, 0.6875));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

fn conj(self) -> Self

Computes the complex conjugate.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1.5, 2.5));
let conj = c.conj();
assert_eq!(conj, (1.5, -2.5));

fn conj_mut(&mut self)

Computes the complex conjugate.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1.5, 2.5));
c.conj_mut();
assert_eq!(c, (1.5, -2.5));

fn conj_ref(&self) -> ConjugateRef

Computes the complex conjugate.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1.5, 2.5));
let conj = Complex::with_val(53, c.conj_ref());
assert_eq!(conj, (1.5, -2.5));

fn abs(self) -> Float

Computes the absolute value and returns it as a Float with the precision of the real part.

Examples

use rug::Complex;
let c = Complex::with_val(53, (30, 40));
let f = c.abs();
assert_eq!(f, 50);

fn abs_mut(&mut self)

Computes the absolute value.

The real part is set to the absolute value and the imaginary part is set to zero.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (30, 40));
c.abs_mut();
assert_eq!(c, (50, 0));

fn abs_ref(&self) -> AbsRef

Computes the absolute value.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::{Complex, Float};
let c = Complex::with_val(53, (30, 40));
let f = Float::with_val(53, c.abs_ref());
assert_eq!(f, 50);

fn arg(self) -> Float

Computes the argument, rounding to the nearest.

The argument is returned as a Float with the precision of the real part.

Examples

use rug::Complex;
let c = Complex::with_val(53, (4, 3));
let f = c.arg();
assert_eq!(f, 0.75_f64.atan());

Special values are handled like atan2 in IEEE 754-2008.

use rug::{Assign, Complex, Float};
use rug::float::Special;
use std::f64;
// f has precision 53, just like f64, so PI constants match.
let mut arg = Float::new(53);
let mut zero = Complex::new(53);
zero.assign((Special::Zero, Special::Zero));
arg.assign(zero.arg_ref());
assert!(arg.is_zero() && arg.is_sign_positive());
zero.assign((Special::Zero, Special::NegZero));
arg.assign(zero.arg_ref());
assert!(arg.is_zero() && arg.is_sign_negative());
zero.assign((Special::NegZero, Special::Zero));
arg.assign(zero.arg_ref());
assert_eq!(arg, f64::consts::PI);
zero.assign((Special::NegZero, Special::NegZero));
arg.assign(zero.arg_ref());
assert_eq!(arg, -f64::consts::PI);

fn arg_mut(&mut self)

Computes the argument, rounding to the nearest.

The real part is set to the argument and the imaginary part is set to zero.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (40, 30));
c.arg_mut();
assert_eq!(c, (0.75_f64.atan(), 0));

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

Computes the argument, applying the specified rounding method.

The real part is set to the argument and the imaginary part is set to zero.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// use only 4 bits of precision
let mut c = Complex::with_val(4, (3, 4));
// arg(3 + 4i) = 0.9316.
// 0.9316 rounded to the nearest is 0.9375.
let dir = c.arg_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.9375, 0));
assert_eq!(dir, (Ordering::Greater, Ordering::Equal));

fn arg_ref(&self) -> ArgRef

Computes the argument.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::{Assign, Complex, Float};
use std::f64;
// f has precision 53, just like f64, so PI constants match.
let mut arg = Float::new(53);
let c_pos = Complex::with_val(53, 1);
arg.assign(c_pos.arg_ref());
assert!(arg.is_zero());
let c_neg = Complex::with_val(53, -1.3);
arg.assign(c_neg.arg_ref());
assert_eq!(arg, f64::consts::PI);
let c_pi_4 = Complex::with_val(53, (1.333, 1.333));
arg.assign(c_pi_4.arg_ref());
assert_eq!(arg, f64::consts::FRAC_PI_4);

fn mul_i(self, negative: bool) -> Self

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

Examples

use rug::Complex;
let c = Complex::with_val(53, (13, 24));
let rot1 = c.mul_i(false);
assert_eq!(rot1, (-24, 13));
let rot2 = rot1.mul_i(false);
assert_eq!(rot2, (-13, -24));
let rot2_less1 = rot2.mul_i(true);
assert_eq!(rot2_less1, (-24, 13));

fn mul_i_mut(&mut self, negative: bool)

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

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (13, 24));
c.mul_i_mut(false);
assert_eq!(c, (-24, 13));
c.mul_i_mut(false);
assert_eq!(c, (-13, -24));
c.mul_i_mut(true);
assert_eq!(c, (-24, 13));

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

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

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// only 4 bits of precision for imaginary part
let mut c = Complex::with_val((53, 4), (127, 15));
assert_eq!(c, (127, 15));
let dir = c.mul_i_round(false, (Round::Down, Round::Down));
assert_eq!(c, (-15, 120));
assert_eq!(dir, (Ordering::Equal, Ordering::Less));
let dir = c.mul_i_round(true, (Round::Down, Round::Down));
assert_eq!(c, (120, 15));
assert_eq!(dir, (Ordering::Equal, Ordering::Equal));

fn mul_i_ref(&self, negative: bool) -> MulIRef

Multiplies the complex number by ±i.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (13, 24));
let rotated = Complex::with_val(53, c.mul_i_ref(false));
assert_eq!(rotated, (-24, 13));

fn recip(self) -> Self

Computes the reciprocal, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
// 1/(1 + i) = (0.5 - 0.5i)
let recip = c.recip();
assert_eq!(recip, (0.5, -0.5));

fn recip_mut(&mut self)

Computes the reciprocal, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
// 1/(1 + i) = (0.5 - 0.5i)
c.recip_mut();
assert_eq!(c, (0.5, -0.5));

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

Computes the reciprocal, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
let mut c = Complex::with_val(4, (1, 2));
// 1/(1 + 2i) = (0.2 - 0.4i), binary (0.00110011..., -0.01100110...)
// 4 bits of precision: (0.001101, -0.01101) = (13/64, -13/32)
let dir = c.recip_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (13.0/64.0, -13.0/32.0));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

fn recip_ref(&self) -> RecipRef

Computes the reciprocal.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
// 1/(1 + i) = (0.5 - 0.5i)
let recip = Complex::with_val(53, c.recip_ref());
assert_eq!(recip, (0.5, -0.5));

fn norm(self) -> Float

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

The norm is returned as a Float with the precision of the real part.

Examples

use rug::Complex;
let c = Complex::with_val(53, (3, 4));
let f = c.norm();
assert_eq!(f, 25);

fn norm_mut(&mut self)

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

The real part is set to the norm and the imaginary part is set to zero.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (3, 4));
c.norm_mut();
assert_eq!(c, (25, 0));

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

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

The real part is set to the norm and the imaginary part is set to zero.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// use only 4 bits of precision
let mut c = Complex::with_val(4, (3, 4));
// 25 rounded up using 4 bits is 26
let dir = c.norm_round((Round::Up, Round::Up));
assert_eq!(c, (26, 0));
assert_eq!(dir, (Ordering::Greater, Ordering::Equal));

fn norm_ref(&self) -> NormRef

Computes the norm, that is the square of the absolute value.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::{Complex, Float};
let c = Complex::with_val(53, (3, 4));
let f = Float::with_val(53, c.norm_ref());
assert_eq!(f, 25);

fn ln(self) -> Self

Computes the natural logarithm, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1.5, -0.5));
let ln = c.ln();
let expected = Complex::with_val(53, (0.4581, -0.3218));
assert!((ln - expected).abs() < 0.0001);

fn ln_mut(&mut self)

Computes the natural logarithm, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1.5, -0.5));
c.ln_mut();
let expected = Complex::with_val(53, (0.4581, -0.3218));
assert!((c - expected).abs() < 0.0001);

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

Computes the natural logarithm, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1.5, -0.5));
// ln(1.5 - 0.5i) = (0.4581 - 0.3218i)
// using 4 significant bits: (0.46875 - 0.3125i)
let dir = c.ln_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.46875, -0.3125));
assert_eq!(dir, (Ordering::Greater, Ordering::Greater));

fn ln_ref(&self) -> LnRef

Computes the natural logarithm;

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1.5, -0.5));
let ln = Complex::with_val(53, c.ln_ref());
let expected = Complex::with_val(53, (0.4581, -0.3218));
assert!((ln - expected).abs() < 0.0001);

fn log10(self) -> Self

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

Examples

use rug::Complex;
let c = Complex::with_val(53, (1.5, -0.5));
let log10 = c.log10();
let expected = Complex::with_val(53, (0.1990, -0.1397));
assert!((log10 - expected).abs() < 0.0001);

fn log10_mut(&mut self)

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

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1.5, -0.5));
c.log10_mut();
let expected = Complex::with_val(53, (0.1990, -0.1397));
assert!((c - expected).abs() < 0.0001);

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

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

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1.5, -0.5));
// log10(1.5 - 0.5i) = (0.1990 - 0.1397i)
// using 4 significant bits: (0.203125 - 0.140625i)
let dir = c.log10_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.203125, -0.140625));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

fn log10_ref(&self) -> Log10Ref

Computes the logarithm to base 10.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1.5, -0.5));
let log10 = Complex::with_val(53, c.log10_ref());
let expected = Complex::with_val(53, (0.1990, -0.1397));
assert!((log10 - expected).abs() < 0.0001);

fn root_of_unity(n: u32, k: u32) -> RootOfUnity

Generates a root of unity, rounding to the nearest.

The generated number is the nth root of unity raised to the power k, that is its magnitude is 1 and its argument is 2πk/n.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let r = Complex::root_of_unity(3, 2);
let c = Complex::with_val(53, r);
let expected = Complex::with_val(53, (-0.5, -0.8660));
assert!((c - expected).abs() < 0.0001);

fn exp(self) -> Self

Computes the exponential, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (0.5, -0.75));
let exp = c.exp();
let expected = Complex::with_val(53, (1.2064, -1.1238));
assert!((exp - expected).abs() < 0.0001);

fn exp_mut(&mut self)

Computes the exponential, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (0.5, -0.75));
c.exp_mut();
let expected = Complex::with_val(53, (1.2064, -1.1238));
assert!((c - expected).abs() < 0.0001);

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

Computes the exponential, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (0.5, -0.75));
// exp(0.5 - 0.75i) = (1.2064 - 1.1238i)
// using 4 significant bits: (1.25 - 1.125)
let dir = c.exp_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (1.25, -1.125));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

fn exp_ref(&self) -> ExpRef

Computes the exponential.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (0.5, -0.75));
let exp = Complex::with_val(53, c.exp_ref());
let expected = Complex::with_val(53, (1.2064, -1.1238));
assert!((exp - expected).abs() < 0.0001);

fn sin(self) -> Self

Computes the sine, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let sin = c.sin();
let expected = Complex::with_val(53, (1.2985, 0.6350));
assert!((sin - expected).abs() < 0.0001);

fn sin_mut(&mut self)

Computes the sine, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.sin_mut();
let expected = Complex::with_val(53, (1.2985, 0.6350));
assert!((c - expected).abs() < 0.0001);

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

Computes the sine, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// sin(1 + i) = (1.2985 + 0.6350i)
// using 4 significant bits: (1.25 + 0.625i)
let dir = c.sin_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (1.25, 0.625));
assert_eq!(dir, (Ordering::Less, Ordering::Less));

fn sin_ref(&self) -> SinRef

Computes the sine.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let sin = Complex::with_val(53, c.sin_ref());
let expected = Complex::with_val(53, (1.2985, 0.6350));
assert!((sin - expected).abs() < 0.0001);

fn cos(self) -> Self

Computes the cosine, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let cos = c.cos();
let expected = Complex::with_val(53, (0.8337, -0.9889));
assert!((cos - expected).abs() < 0.0001);

fn cos_mut(&mut self)

Computes the cosine, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.cos_mut();
let expected = Complex::with_val(53, (0.8337, -0.9889));
assert!((c - expected).abs() < 0.0001);

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

Computes the cosine, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// cos(1 + i) = (0.8337 - 0.9889i)
// using 4 significant bits: (0.8125 - i)
let dir = c.cos_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.8125, -1));
assert_eq!(dir, (Ordering::Less, Ordering::Less));

fn cos_ref(&self) -> CosRef

Computes the cosine.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let cos = Complex::with_val(53, c.cos_ref());
let expected = Complex::with_val(53, (0.8337, -0.9889));
assert!((cos - expected).abs() < 0.0001);

fn sin_cos(self, cos: Self) -> (Self, Self)

Computes the sine and cosine of self, rounding to the nearest.

The sine keeps the precision of self while the cosine keeps the precision of cos.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let (sin, cos) = c.sin_cos(Complex::new(53));
let expected_sin = Complex::with_val(53, (1.2985, 0.6350));
let expected_cos = Complex::with_val(53, (0.8337, -0.9889));
assert!((sin - expected_sin).abs() < 0.0001);
assert!((cos - expected_cos).abs() < 0.0001);

fn sin_cos_mut(&mut self, cos: &mut Self)

Computes the sine and cosine of self, rounding to the nearest.

The sine is stored in self and keeps its precision, while the cosine is stored in cos keeping its precision.

Examples

use rug::Complex;
let mut sin = Complex::with_val(53, (1, 1));
let mut cos = Complex::new(53);
sin.sin_cos_mut(&mut cos);
let expected_sin = Complex::with_val(53, (1.2985, 0.6350));
let expected_cos = Complex::with_val(53, (0.8337, -0.9889));
assert!((sin - expected_sin).abs() < 0.0001);
assert!((cos - expected_cos).abs() < 0.0001);

fn sin_cos_round(
    &mut self,
    cos: &mut Self,
    round: (Round, Round)
) -> ((Ordering, Ordering), (Ordering, Ordering))

Computes the sine and cosine of self, applying the specified rounding methods.

The sine is stored in self and keeps its precision, while the cosine is stored in cos keeping its precision.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut sin = Complex::with_val(4, (1, 1));
let mut cos = Complex::new(4);
// sin(1 + i) = (1.2985 + 0.6350)
// using 4 significant bits: (1.25 + 0.625i)
// cos(1 + i) = (0.8337 - 0.9889i)
// using 4 significant bits: (0.8125 - i)
let (dir_sin, dir_cos) =
    sin.sin_cos_round(&mut cos, (Round::Nearest, Round::Nearest));
assert_eq!(sin, (1.25, 0.625));
assert_eq!(dir_sin, (Ordering::Less, Ordering::Less));
assert_eq!(cos, (0.8125, -1));
assert_eq!(dir_cos, (Ordering::Less, Ordering::Less));

fn sin_cos_ref(&self) -> SinCosRef

Computes the sine and cosine.

AssignRound<Src> for (Complex, Complex) and AssignRound<Src> for (&mut Complex, &mut Complex) are implemented with the returned object as Src.

Examples

use rug::{Assign, Complex};
use rug::float::Round;
use rug::ops::AssignRound;
use std::cmp::Ordering;
let phase = Complex::with_val(53, (1, 1));
let sin_cos = phase.sin_cos_ref();

let (mut sin, mut cos) = (Complex::new(53), Complex::new(53));
(&mut sin, &mut cos).assign(sin_cos);
let expected_sin = Complex::with_val(53, (1.2985, 0.6350));
let expected_cos = Complex::with_val(53, (0.8337, -0.9889));
assert!((sin - expected_sin).abs() < 0.0001);
assert!((cos - expected_cos).abs() < 0.0001);

// using 4 significant bits: sin = (1.25 + 0.625i)
// using 4 significant bits: cos = (0.8125 - i)
let (mut sin_4, mut cos_4) = (Complex::new(4), Complex::new(4));
let (dir_sin, dir_cos) = (&mut sin_4, &mut cos_4)
    .assign_round(sin_cos, (Round::Nearest, Round::Nearest));
assert_eq!(sin_4, (1.25, 0.625));
assert_eq!(dir_sin, (Ordering::Less, Ordering::Less));
assert_eq!(cos_4, (0.8125, -1));
assert_eq!(dir_cos, (Ordering::Less, Ordering::Less));

fn tan(self) -> Self

Computes the tangent, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let tan = c.tan();
let expected = Complex::with_val(53, (0.2718, 1.0839));
assert!((tan - expected).abs() < 0.0001);

fn tan_mut(&mut self)

Computes the tangent, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.tan_mut();
let expected = Complex::with_val(53, (0.2718, 1.0839));
assert!((c - expected).abs() < 0.0001);

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

Computes the tangent, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// tan(1 + i) = (0.2718 + 1.0839)
// using 4 significant bits: (0.28125 + 1.125i)
let dir = c.tan_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.28125, 1.125));
assert_eq!(dir, (Ordering::Greater, Ordering::Greater));

fn tan_ref(&self) -> TanRef

Computes the tangent.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let tan = Complex::with_val(53, c.tan_ref());
let expected = Complex::with_val(53, (0.2718, 1.0839));
assert!((tan - expected).abs() < 0.0001);

fn sinh(self) -> Self

Computes the hyperbolic sine, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let sinh = c.sinh();
let expected = Complex::with_val(53, (0.6350, 1.2985));
assert!((sinh - expected).abs() < 0.0001);

fn sinh_mut(&mut self)

Computes the hyperbolic sine, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.sinh_mut();
let expected = Complex::with_val(53, (0.6350, 1.2985));
assert!((c - expected).abs() < 0.0001);

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

Computes the hyperbolic sine, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// sinh(1 + i) = (0.6350 + 1.2985i)
// using 4 significant bits: (0.625 + 1.25i)
let dir = c.sinh_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.625, 1.25));
assert_eq!(dir, (Ordering::Less, Ordering::Less));

fn sinh_ref(&self) -> SinhRef

Computes the hyperbolic sine.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let sinh = Complex::with_val(53, c.sinh_ref());
let expected = Complex::with_val(53, (0.6350, 1.2985));
assert!((sinh - expected).abs() < 0.0001);

fn cosh(self) -> Self

Computes the hyperbolic cosine, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let cosh = c.cosh();
let expected = Complex::with_val(53, (0.8337, 0.9889));
assert!((cosh - expected).abs() < 0.0001);

fn cosh_mut(&mut self)

Computes the hyperbolic cosine, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.cosh_mut();
let expected = Complex::with_val(53, (0.8337, 0.9889));
assert!((c - expected).abs() < 0.0001);

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

Computes the hyperbolic cosine, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// cosh(1 + i) = (0.8337 + 0.9889)
// using 4 significant bits: (0.8125 + i)
let dir = c.cosh_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.8125, 1));
assert_eq!(dir, (Ordering::Less, Ordering::Greater));

fn cosh_ref(&self) -> CoshRef

Computes the hyperbolic cosine.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let cosh = Complex::with_val(53, c.cosh_ref());
let expected = Complex::with_val(53, (0.8337, 0.9889));
assert!((cosh - expected).abs() < 0.0001);

fn tanh(self) -> Self

Computes the hyperbolic tangent, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let tanh = c.tanh();
let expected = Complex::with_val(53, (1.0839, 0.2718));
assert!((tanh - expected).abs() < 0.0001);

fn tanh_mut(&mut self)

Computes the hyperbolic tangent, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.tanh_mut();
let expected = Complex::with_val(53, (1.0839, 0.2718));
assert!((c - expected).abs() < 0.0001);

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

Computes the hyperbolic tangent, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// tanh(1 + i) = (1.0839 + 0.2718i)
// using 4 significant bits: (1.125 + 0.28125i)
let dir = c.tanh_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (1.125, 0.28125));
assert_eq!(dir, (Ordering::Greater, Ordering::Greater));

fn tanh_ref(&self) -> TanhRef

Computes the hyperbolic tangent.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let tanh = Complex::with_val(53, c.tanh_ref());
let expected = Complex::with_val(53, (1.0839, 0.2718));
assert!((tanh - expected).abs() < 0.0001);

fn asin(self) -> Self

Computes the inverse sine, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let asin = c.asin();
let expected = Complex::with_val(53, (0.6662, 1.0613));
assert!((asin - expected).abs() < 0.0001);

fn asin_mut(&mut self)

Computes the inverse sine, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.asin_mut();
let expected = Complex::with_val(53, (0.6662, 1.0613));
assert!((c - expected).abs() < 0.0001);

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

Computes the inverse sine, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// asin(1 + i) = (0.6662 + 1.0613i)
// using 4 significant bits: (0.6875 + i)
let dir = c.asin_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.6875, 1));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

fn asin_ref(&self) -> AsinRef

Computes the inverse sine.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let asin = Complex::with_val(53, c.asin_ref());
let expected = Complex::with_val(53, (0.6662, 1.0613));
assert!((asin - expected).abs() < 0.0001);

fn acos(self) -> Self

Computes the inverse cosine, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let acos = c.acos();
let expected = Complex::with_val(53, (0.9046, -1.0613));
assert!((acos - expected).abs() < 0.0001);

fn acos_mut(&mut self)

Computes the inverse cosine, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.acos_mut();
let expected = Complex::with_val(53, (0.9046, -1.0613));
assert!((c - expected).abs() < 0.0001);

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

Computes the inverse cosine, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// acos(1 + i) = (0.9046 - 1.0613i)
// using 4 significant bits: (0.875 - i)
let dir = c.acos_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.875, -1));
assert_eq!(dir, (Ordering::Less, Ordering::Greater));

fn acos_ref(&self) -> AcosRef

Computes the inverse cosine.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let acos = Complex::with_val(53, c.acos_ref());
let expected = Complex::with_val(53, (0.9046, -1.0613));
assert!((acos - expected).abs() < 0.0001);

fn atan(self) -> Self

Computes the inverse tangent, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let atan = c.atan();
let expected = Complex::with_val(53, (1.0172, 0.4024));
assert!((atan - expected).abs() < 0.0001);

fn atan_mut(&mut self)

Computes the inverse tangent, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.atan_mut();
let expected = Complex::with_val(53, (1.0172, 0.4024));
assert!((c - expected).abs() < 0.0001);

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

Computes the inverse tangent, applying the specified rounding method.

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// atan(1 + i) = (1.0172 + 0.4024i)
// using 4 significant bits: (1 + 0.40625i)
let dir = c.atan_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (1, 0.40625));
assert_eq!(dir, (Ordering::Less, Ordering::Greater));

fn atan_ref(&self) -> AtanRef

Computes the inverse tangent.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let atan = Complex::with_val(53, c.atan_ref());
let expected = Complex::with_val(53, (1.0172, 0.4024));
assert!((atan - expected).abs() < 0.0001);

fn asinh(self) -> Self

Computes the inverse hyperbolic sine, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let asinh = c.asinh();
let expected = Complex::with_val(53, (1.0613, 0.6662));
assert!((asinh - expected).abs() < 0.0001);

fn asinh_mut(&mut self)

Computes the inverse hyperbolic sine, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.asinh_mut();
let expected = Complex::with_val(53, (1.0613, 0.6662));
assert!((c - expected).abs() < 0.0001);

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

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

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// asinh(1 + i) = (1.0613 + 0.6662i)
// using 4 significant bits: (1 + 0.6875i)
let dir = c.asinh_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (1, 0.6875));
assert_eq!(dir, (Ordering::Less, Ordering::Greater));

fn asinh_ref(&self) -> AsinhRef

Computes the inverse hyperboic sine.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let asinh = Complex::with_val(53, c.asinh_ref());
let expected = Complex::with_val(53, (1.0613, 0.6662));
assert!((asinh - expected).abs() < 0.0001);

fn acosh(self) -> Self

Computes the inverse hyperbolic cosine, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let acosh = c.acosh();
let expected = Complex::with_val(53, (1.0613, 0.9046));
assert!((acosh - expected).abs() < 0.0001);

fn acosh_mut(&mut self)

Computes the inverse hyperbolic cosine, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.acosh_mut();
let expected = Complex::with_val(53, (1.0613, 0.9046));
assert!((c - expected).abs() < 0.0001);

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

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

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// acosh(1 + i) = (1.0613 + 0.9046i)
// using 4 significant bits: (1 + 0.875i)
let dir = c.acosh_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (1, 0.875));
assert_eq!(dir, (Ordering::Less, Ordering::Less));

fn acosh_ref(&self) -> AcoshRef

Computes the inverse hyperbolic cosine.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let acosh = Complex::with_val(53, c.acosh_ref());
let expected = Complex::with_val(53, (1.0613, 0.9046));
assert!((acosh - expected).abs() < 0.0001);

fn atanh(self) -> Self

Computes the inverse hyperbolic tangent, rounding to the nearest.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let atanh = c.atanh();
let expected = Complex::with_val(53, (0.4024, 1.0172));
assert!((atanh - expected).abs() < 0.0001);

fn atanh_mut(&mut self)

Computes the inverse hyperbolic tangent, rounding to the nearest.

Examples

use rug::Complex;
let mut c = Complex::with_val(53, (1, 1));
c.atanh_mut();
let expected = Complex::with_val(53, (0.4024, 1.0172));
assert!((c - expected).abs() < 0.0001);

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

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

Examples

use rug::Complex;
use rug::float::Round;
use std::cmp::Ordering;
// Use only 4 bits of precision to show rounding.
let mut c = Complex::with_val(4, (1, 1));
// atanh(1 + i) = (0.4024 + 1.0172i)
// using 4 significant bits: (0.40625 + i)
let dir = c.atanh_round((Round::Nearest, Round::Nearest));
assert_eq!(c, (0.40625, 1));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

fn atanh_ref(&self) -> AtanhRef

Computes the inverse hyperbolic tangent.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
let c = Complex::with_val(53, (1, 1));
let atanh = Complex::with_val(53, c.atanh_ref());
let expected = Complex::with_val(53, (0.4024, 1.0172));
assert!((atanh - expected).abs() < 0.0001);

fn random_bits<'a, 'b: 'a>(rng: &'a mut RandState<'b>) -> RandomBits<'a, 'b>

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

This is equivalent to generating a random integer in the range 0 ≤ x < 2^p for each part, where 2^p is two raised to the power of the precision, and then dividing the integer by 2^p. The smallest non-zero result will thus be 2^−p, and will only have one bit set. In the smaller possible results, many bits will be zero, and not all the precision will be used.

Assign<Src> for Result<Complex, Complex> and Assign<Src> for Result<&mut Complex, &mut Complex> are implemented with the returned object as Src.

Examples

use rug::{Assign, Complex};
use rug::rand::RandState;
let mut rand = RandState::new();
let mut c = Ok(Complex::new(2));
c.assign(Complex::random_bits(&mut rand));
let c = c.unwrap();
let (re, im) = c.into_real_imag();
assert!(re == 0.0 || re == 0.25 || re == 0.5 || re == 0.75);
assert!(im == 0.0 || im == 0.25 || im == 0.5 || im == 0.75);
println!("0.0 ≤ {} < 1.0", re);
println!("0.0 ≤ {} < 1.0", im);

Errors

In all the normal cases, the result will be exact. However, if the precision is very large, and the generated random number is very small, this may require an exponent smaller than float::exp_min(); in this case, the number is set to Nan and an error is returned. This would most likely be a programming error.

fn assign_random_bits(&mut self, rng: &mut RandState) -> Result<(), ()>

Deprecated since 0.9.2

: use random_bits instead; see documentation for an example replacement.

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

This method is deprecated. The code

use rug::Complex;
let mut c: Complex;
// ...
match c.assign_random_bits(rng) {
    Ok(()) => { /* ok */ }
    Err(()) => { /* error */ }
}

can be replaced with

use rug::{Assign, Complex};
let mut c: Complex;
// ...
let mut result = Ok(&mut c);
result.assign(Complex::random_bits(rng));
match result {
    Ok(_) => { /* ok */ }
    Err(_) => { /* error */ }
};

fn random_cont<'a, 'b: 'a>(rng: &'a mut RandState<'b>) -> RandomCont<'a, 'b>

Generates a random complex number with both the real and imaginary parts in the continous range 0 ≤ x < 1, and rounds to the nearest.

The result parts can be rounded up to be equal to one. Unlike the assign_random_bits method which generates a discrete random number at intervals depending on the precision, this method is equivalent to generating a continuous random number with infinite precision and then rounding the result. This means that even the smaller numbers will be using all the available precision bits, and rounding is performed in all cases, not in some corner case.

Rounding directions for generated random numbers cannot be Ordering::Equal, as the random numbers generated can be considered to have infinite precision before rounding.

AssignRound<Src> for Complex is implemented with the returned object as Src.

Examples

use rug::Complex;
use rug::rand::RandState;
let mut rand = RandState::new();
let c = Complex::with_val(2, Complex::random_cont(&mut rand));
let (re, im) = c.into_real_imag();
// The significand is either 0b10 or 0b11
//           10           11
assert!(re == 1.0 || re == 0.75 ||
        re == 0.5 || re == 0.375 ||
        re == 0.25 || re <= 0.1875);
assert!(im == 1.0 || im == 0.75 ||
        im == 0.5 || im == 0.375 ||
        im == 0.25 || im <= 0.1875);

fn assign_random_cont(&mut self, rng: &mut RandState)

Deprecated since 0.9.2

: use random_cont instead; c.assign_random_cont(rng) can be replaced with c.assign(Complex::random_cont(rng)).

Generates a random complex number with both the real and imaginary parts in the continous range 0 ≤ x < 1, and rounds to the nearest.

fn assign_random_cont_round(
    &mut self,
    rng: &mut RandState,
    round: (Round, Round)
) -> (Ordering, Ordering)

Deprecated since 0.9.2

: use random_cont instead; c.assign_random_cont_round(rng, round) can be replaced with c.assign_round(Complex::random_cont(rng, round)).

Generates a random complex number with both the real and imaginary parts in the continous range 0 ≤ x < 1, and applies the specified rounding method.

Trait Implementations

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: ProjRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SquareRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SqrtRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: ConjugateRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: MulIRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: RecipRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: LnRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: Log10Ref<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl AssignRound<RootOfUnity> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: RootOfUnity,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: ExpRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SinRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: CosRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: TanRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SinhRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: CoshRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: TanhRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AsinRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AcosRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AtanRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AsinhRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AcoshRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AtanhRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, 'b: 'a> AssignRound<RandomCont<'a, 'b>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: RandomCont<'a, 'b>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: ValidComplex<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Neg for Complex

type Output = Complex

The resulting type after applying the - operator.

fn neg(self) -> Complex

Performs the unary - operation.

impl NegAssign for Complex

fn neg_assign(&mut self)

Peforms the negation.

impl<'a> Neg for &'a Complex

type Output = NegRef<'a>

The resulting type after applying the - operator.

fn neg(self) -> NegRef<'a>

Performs the unary - operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: NegRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Add<Complex> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddRef<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Complex) -> AddRef<'a>

Performs the + operation.

impl AddAssign<Complex> for Complex

fn add_assign(&mut self, rhs: Complex)

Performs the += operation.

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

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

Performs the += operation.

impl AddAssignRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round(
    &mut self,
    rhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round(
    &mut self,
    rhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AddRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddFrom<Complex> for Complex

fn add_from(&mut self, lhs: Complex)

Peforms the addition.

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

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

Peforms the addition.

impl<'a> AddFromRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round(
    &mut self,
    lhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round(
    &mut self,
    lhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl Sub<Complex> for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubRef<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Complex) -> SubRef<'a>

Performs the - operation.

impl SubAssign<Complex> for Complex

fn sub_assign(&mut self, rhs: Complex)

Performs the -= operation.

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

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

Performs the -= operation.

impl SubAssignRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round(
    &mut self,
    rhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round(
    &mut self,
    rhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubFrom<Complex> for Complex

fn sub_from(&mut self, lhs: Complex)

Peforms the subtraction.

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

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

Peforms the subtraction.

impl<'a> SubFromRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round(
    &mut self,
    lhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round(
    &mut self,
    lhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl Mul<Complex> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulRef<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Complex) -> MulRef<'a>

Performs the * operation.

impl MulAssign<Complex> for Complex

fn mul_assign(&mut self, rhs: Complex)

Performs the *= operation.

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

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

Performs the *= operation.

impl MulAssignRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round(
    &mut self,
    rhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round(
    &mut self,
    rhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: MulRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulFrom<Complex> for Complex

fn mul_from(&mut self, lhs: Complex)

Peforms the multiplication.

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

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

Peforms the multiplication.

impl<'a> MulFromRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round(
    &mut self,
    lhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round(
    &mut self,
    lhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl Div<Complex> for Complex

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivRef<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Complex) -> DivRef<'a>

Performs the / operation.

impl DivAssign<Complex> for Complex

fn div_assign(&mut self, rhs: Complex)

Performs the /= operation.

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

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

Performs the /= operation.

impl DivAssignRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round(
    &mut self,
    rhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round(
    &mut self,
    rhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: DivRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

impl DivFrom<Complex> for Complex

fn div_from(&mut self, lhs: Complex)

Peforms the division.

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

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

Peforms the division.

impl<'a> DivFromRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_from_round(
    &mut self,
    lhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_from_round(
    &mut self,
    lhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl Pow<Complex> for Complex

type Output = Complex

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = Complex

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = PowRef<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Complex) -> PowRef<'a>

Performs the power operation.

impl PowAssign<Complex> for Complex

fn pow_assign(&mut self, rhs: Complex)

Peforms the power operation.

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

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

Peforms the power operation.

impl PowAssignRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: PowRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = Complex

The resulting type after the power operation.

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

Performs the power operation.

impl PowFrom<Complex> for Complex

fn pow_from(&mut self, lhs: Complex)

Peforms the power operation.

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

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

Peforms the power operation.

impl<'a> PowFromRound<Complex> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_from_round(
    &mut self,
    lhs: Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_from_round(
    &mut self,
    lhs: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

impl Add<Float> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddRefFloat<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Float) -> AddRefFloat<'a>

Performs the + operation.

impl AddAssign<Float> for Complex

fn add_assign(&mut self, rhs: Float)

Performs the += operation.

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

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

Performs the += operation.

impl AddAssignRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round(
    &mut self,
    rhs: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AddRefFloat<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = AddRefFloatOwn<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Float) -> AddRefFloatOwn<'a>

Performs the + operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AddRefFloatOwn<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, 'b> AssignRound<&'a AddRefFloatOwn<'b>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: &'a AddRefFloatOwn<'b>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl AddFrom<Float> for Complex

fn add_from(&mut self, lhs: Float)

Peforms the addition.

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

fn add_from(&mut self, lhs: &'a Float)

Peforms the addition.

impl AddFromRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round(
    &mut self,
    lhs: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

impl Sub<Float> for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubRefFloat<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubRefFloat<'a>

Performs the - operation.

impl SubAssign<Float> for Complex

fn sub_assign(&mut self, rhs: Float)

Performs the -= operation.

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

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

Performs the -= operation.

impl SubAssignRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round(
    &mut self,
    rhs: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubRefFloat<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = SubFromRefFloat<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Float) -> SubFromRefFloat<'a>

Performs the - operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubFromRefFloat<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, 'b> AssignRound<&'a SubFromRefFloat<'b>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: &'a SubFromRefFloat<'b>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl SubFrom<Float> for Complex

fn sub_from(&mut self, lhs: Float)

Peforms the subtraction.

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

fn sub_from(&mut self, lhs: &'a Float)

Peforms the subtraction.

impl SubFromRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round(
    &mut self,
    lhs: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubRefFloatOwn<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubFromRefFloatOwn<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, 'b> AssignRound<&'a SubFromRefFloatOwn<'b>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: &'a SubFromRefFloatOwn<'b>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Mul<Float> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulRefFloat<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Float) -> MulRefFloat<'a>

Performs the * operation.

impl MulAssign<Float> for Complex

fn mul_assign(&mut self, rhs: Float)

Performs the *= operation.

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

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

Performs the *= operation.

impl MulAssignRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round(
    &mut self,
    rhs: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: MulRefFloat<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = MulRefFloatOwn<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Float) -> MulRefFloatOwn<'a>

Performs the * operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: MulRefFloatOwn<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, 'b> AssignRound<&'a MulRefFloatOwn<'b>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: &'a MulRefFloatOwn<'b>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl MulFrom<Float> for Complex

fn mul_from(&mut self, lhs: Float)

Peforms the multiplication.

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

fn mul_from(&mut self, lhs: &'a Float)

Peforms the multiplication.

impl MulFromRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round(
    &mut self,
    lhs: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

impl Div<Float> for Complex

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivRefFloat<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Float) -> DivRefFloat<'a>

Performs the / operation.

impl DivAssign<Float> for Complex

fn div_assign(&mut self, rhs: Float)

Performs the /= operation.

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

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

Performs the /= operation.

impl DivAssignRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round(
    &mut self,
    rhs: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the division.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: DivRefFloat<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = DivFromRefFloat<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Float) -> DivFromRefFloat<'a>

Performs the / operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: DivFromRefFloat<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, 'b> AssignRound<&'a DivFromRefFloat<'b>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: &'a DivFromRefFloat<'b>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl DivFrom<Float> for Complex

fn div_from(&mut self, lhs: Float)

Peforms the division.

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

fn div_from(&mut self, lhs: &'a Float)

Peforms the division.

impl DivFromRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_from_round(
    &mut self,
    lhs: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the division.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: DivRefFloatOwn<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: DivFromRefFloatOwn<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, 'b> AssignRound<&'a DivFromRefFloatOwn<'b>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: &'a DivFromRefFloatOwn<'b>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Pow<Float> for Complex

type Output = Complex

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = Complex

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = PowRefFloat<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Float) -> PowRefFloat<'a>

Performs the power operation.

impl PowAssign<Float> for Complex

fn pow_assign(&mut self, rhs: Float)

Peforms the power operation.

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

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

Peforms the power operation.

impl PowAssignRound<Float> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: Float,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: PowRefFloat<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = PowRefFloatOwn<'a>

The resulting type after the power operation.

fn pow(self, rhs: Float) -> PowRefFloatOwn<'a>

Performs the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: PowRefFloatOwn<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, 'b> AssignRound<&'a PowRefFloatOwn<'b>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: &'a PowRefFloatOwn<'b>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Pow<Integer> for Complex

type Output = Complex

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = Complex

The resulting type after the power operation.

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

Performs the power operation.

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

type Output = PowRefInteger<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Integer) -> PowRefInteger<'a>

Performs the power operation.

impl PowAssign<Integer> for Complex

fn pow_assign(&mut self, rhs: Integer)

Peforms the power operation.

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

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

Peforms the power operation.

impl PowAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: PowRefInteger<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

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

type Output = PowRefIntegerOwn<'a>

The resulting type after the power operation.

fn pow(self, rhs: Integer) -> PowRefIntegerOwn<'a>

Performs the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: PowRefIntegerOwn<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, 'b> AssignRound<&'a PowRefIntegerOwn<'b>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: &'a PowRefIntegerOwn<'b>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Add<u32> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'t> Add<&'t u32> for Complex

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: &'t u32) -> Complex

Performs the + operation.

impl<'b> Add<u32> for &'b Complex

type Output = AddRefU32<'b>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> AddRefU32<'b>

Performs the + operation.

impl<'t, 'b> Add<&'t u32> for &'b Complex

type Output = AddRefU32<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'t u32) -> AddRefU32<'b>

Performs the + operation.

impl AddAssign<u32> for Complex

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<'t> AddAssign<&'t u32> for Complex

fn add_assign(&mut self, rhs: &'t u32)

Performs the += operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AddRefU32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl AddAssignRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round(
    &mut self,
    rhs: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl<'t> AddAssignRound<&'t u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round(
    &mut self,
    rhs: &'t u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl AddFrom<u32> for Complex

fn add_from(&mut self, lhs: u32)

Peforms the addition.

impl<'t> AddFrom<&'t u32> for Complex

fn add_from(&mut self, lhs: &'t u32)

Peforms the addition.

impl AddFromRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round(
    &mut self,
    lhs: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl<'t> AddFromRound<&'t u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round(
    &mut self,
    lhs: &'t u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl Sub<u32> for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'t> Sub<&'t u32> for Complex

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: &'t u32) -> Complex

Performs the - operation.

impl<'b> Sub<u32> for &'b Complex

type Output = SubRefU32<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> SubRefU32<'b>

Performs the - operation.

impl<'t, 'b> Sub<&'t u32> for &'b Complex

type Output = SubRefU32<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'t u32) -> SubRefU32<'b>

Performs the - operation.

impl SubAssign<u32> for Complex

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<'t> SubAssign<&'t u32> for Complex

fn sub_assign(&mut self, rhs: &'t u32)

Performs the -= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubRefU32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl SubAssignRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round(
    &mut self,
    rhs: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl<'t> SubAssignRound<&'t u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round(
    &mut self,
    rhs: &'t u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl SubFrom<u32> for Complex

fn sub_from(&mut self, lhs: u32)

Peforms the subtraction.

impl<'t> SubFrom<&'t u32> for Complex

fn sub_from(&mut self, lhs: &'t u32)

Peforms the subtraction.

impl SubFromRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round(
    &mut self,
    lhs: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl<'t> SubFromRound<&'t u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round(
    &mut self,
    lhs: &'t u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubFromRefU32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Mul<u32> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'t> Mul<&'t u32> for Complex

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: &'t u32) -> Complex

Performs the * operation.

impl<'b> Mul<u32> for &'b Complex

type Output = MulRefU32<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> MulRefU32<'b>

Performs the * operation.

impl<'t, 'b> Mul<&'t u32> for &'b Complex

type Output = MulRefU32<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'t u32) -> MulRefU32<'b>

Performs the * operation.

impl MulAssign<u32> for Complex

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<'t> MulAssign<&'t u32> for Complex

fn mul_assign(&mut self, rhs: &'t u32)

Performs the *= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: MulRefU32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl MulAssignRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round(
    &mut self,
    rhs: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl<'t> MulAssignRound<&'t u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round(
    &mut self,
    rhs: &'t u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl MulFrom<u32> for Complex

fn mul_from(&mut self, lhs: u32)

Peforms the multiplication.

impl<'t> MulFrom<&'t u32> for Complex

fn mul_from(&mut self, lhs: &'t u32)

Peforms the multiplication.

impl MulFromRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round(
    &mut self,
    lhs: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl<'t> MulFromRound<&'t u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round(
    &mut self,
    lhs: &'t u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl Div<u32> for Complex

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

impl<'t> Div<&'t u32> for Complex

type Output = Complex

The resulting type after applying the / operator.

fn div(self, rhs: &'t u32) -> Complex

Performs the / operation.

impl<'b> Div<u32> for &'b Complex

type Output = DivRefU32<'b>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> DivRefU32<'b>

Performs the / operation.

impl<'t, 'b> Div<&'t u32> for &'b Complex

type Output = DivRefU32<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'t u32) -> DivRefU32<'b>

Performs the / operation.

impl DivAssign<u32> for Complex

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<'t> DivAssign<&'t u32> for Complex

fn div_assign(&mut self, rhs: &'t u32)

Performs the /= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: DivRefU32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl DivAssignRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round(
    &mut self,
    rhs: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl<'t> DivAssignRound<&'t u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round(
    &mut self,
    rhs: &'t u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl DivFrom<u32> for Complex

fn div_from(&mut self, lhs: u32)

Peforms the division.

impl<'t> DivFrom<&'t u32> for Complex

fn div_from(&mut self, lhs: &'t u32)

Peforms the division.

impl DivFromRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_from_round(
    &mut self,
    lhs: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl<'t> DivFromRound<&'t u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_from_round(
    &mut self,
    lhs: &'t u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: DivFromRefU32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Add<i32> for Complex

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Complex

Performs the + operation.

impl<'t> Add<&'t i32> for Complex

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: &'t i32) -> Complex

Performs the + operation.

impl<'b> Add<i32> for &'b Complex

type Output = AddRefI32<'b>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> AddRefI32<'b>

Performs the + operation.

impl<'t, 'b> Add<&'t i32> for &'b Complex

type Output = AddRefI32<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'t i32) -> AddRefI32<'b>

Performs the + operation.

impl AddAssign<i32> for Complex

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<'t> AddAssign<&'t i32> for Complex

fn add_assign(&mut self, rhs: &'t i32)

Performs the += operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AddRefI32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl AddAssignRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round(
    &mut self,
    rhs: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl<'t> AddAssignRound<&'t i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round(
    &mut self,
    rhs: &'t i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl AddFrom<i32> for Complex

fn add_from(&mut self, lhs: i32)

Peforms the addition.

impl<'t> AddFrom<&'t i32> for Complex

fn add_from(&mut self, lhs: &'t i32)

Peforms the addition.

impl AddFromRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round(
    &mut self,
    lhs: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl<'t> AddFromRound<&'t i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round(
    &mut self,
    lhs: &'t i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl Sub<i32> for Complex

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Complex

Performs the - operation.

impl<'t> Sub<&'t i32> for Complex

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: &'t i32) -> Complex

Performs the - operation.

impl<'b> Sub<i32> for &'b Complex

type Output = SubRefI32<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> SubRefI32<'b>

Performs the - operation.

impl<'t, 'b> Sub<&'t i32> for &'b Complex

type Output = SubRefI32<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'t i32) -> SubRefI32<'b>

Performs the - operation.

impl SubAssign<i32> for Complex

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<'t> SubAssign<&'t i32> for Complex

fn sub_assign(&mut self, rhs: &'t i32)

Performs the -= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubRefI32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl SubAssignRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round(
    &mut self,
    rhs: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl<'t> SubAssignRound<&'t i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round(
    &mut self,
    rhs: &'t i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl SubFrom<i32> for Complex

fn sub_from(&mut self, lhs: i32)

Peforms the subtraction.

impl<'t> SubFrom<&'t i32> for Complex

fn sub_from(&mut self, lhs: &'t i32)

Peforms the subtraction.

impl SubFromRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round(
    &mut self,
    lhs: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl<'t> SubFromRound<&'t i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round(
    &mut self,
    lhs: &'t i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubFromRefI32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Mul<i32> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'t> Mul<&'t i32> for Complex

type Output = Complex

The resulting type after applying the * operator.

fn mul(self, rhs: &'t i32) -> Complex

Performs the * operation.

impl<'b> Mul<i32> for &'b Complex

type Output = MulRefI32<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> MulRefI32<'b>

Performs the * operation.

impl<'t, 'b> Mul<&'t i32> for &'b Complex

type Output = MulRefI32<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'t i32) -> MulRefI32<'b>

Performs the * operation.

impl MulAssign<i32> for Complex

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<'t> MulAssign<&'t i32> for Complex

fn mul_assign(&mut self, rhs: &'t i32)

Performs the *= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: MulRefI32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl MulAssignRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round(
    &mut self,
    rhs: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl<'t> MulAssignRound<&'t i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_assign_round(
    &mut self,
    rhs: &'t i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl MulFrom<i32> for Complex

fn mul_from(&mut self, lhs: i32)

Peforms the multiplication.

impl<'t> MulFrom<&'t i32> for Complex

fn mul_from(&mut self, lhs: &'t i32)

Peforms the multiplication.

impl MulFromRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round(
    &mut self,
    lhs: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl<'t> MulFromRound<&'t i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn mul_from_round(
    &mut self,
    lhs: &'t i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl Div<i32> for Complex

type Output = Complex

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Complex

Performs the / operation.

impl<'t> Div<&'t i32> for Complex

type Output = Complex

The resulting type after applying the / operator.

fn div(self, rhs: &'t i32) -> Complex

Performs the / operation.

impl<'b> Div<i32> for &'b Complex

type Output = DivRefI32<'b>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> DivRefI32<'b>

Performs the / operation.

impl<'t, 'b> Div<&'t i32> for &'b Complex

type Output = DivRefI32<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'t i32) -> DivRefI32<'b>

Performs the / operation.

impl DivAssign<i32> for Complex

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<'t> DivAssign<&'t i32> for Complex

fn div_assign(&mut self, rhs: &'t i32)

Performs the /= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: DivRefI32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl DivAssignRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round(
    &mut self,
    rhs: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl<'t> DivAssignRound<&'t i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_assign_round(
    &mut self,
    rhs: &'t i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl DivFrom<i32> for Complex

fn div_from(&mut self, lhs: i32)

Peforms the division.

impl<'t> DivFrom<&'t i32> for Complex

fn div_from(&mut self, lhs: &'t i32)

Peforms the division.

impl DivFromRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_from_round(
    &mut self,
    lhs: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl<'t> DivFromRound<&'t i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn div_from_round(
    &mut self,
    lhs: &'t i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: DivFromRefI32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Shl<u32> for Complex

type Output = Complex

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'t> Shl<&'t u32> for Complex

type Output = Complex

The resulting type after applying the << operator.

fn shl(self, rhs: &'t u32) -> Complex

Performs the << operation.

impl<'b> Shl<u32> for &'b Complex

type Output = ShlRefU32<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> ShlRefU32<'b>

Performs the << operation.

impl<'t, 'b> Shl<&'t u32> for &'b Complex

type Output = ShlRefU32<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &'t u32) -> ShlRefU32<'b>

Performs the << operation.

impl ShlAssign<u32> for Complex

fn shl_assign(&mut self, rhs: u32)

Performs the <<= operation.

impl<'t> ShlAssign<&'t u32> for Complex

fn shl_assign(&mut self, rhs: &'t u32)

Performs the <<= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: ShlRefU32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Shr<u32> for Complex

type Output = Complex

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'t> Shr<&'t u32> for Complex

type Output = Complex

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t u32) -> Complex

Performs the >> operation.

impl<'b> Shr<u32> for &'b Complex

type Output = ShrRefU32<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> ShrRefU32<'b>

Performs the >> operation.

impl<'t, 'b> Shr<&'t u32> for &'b Complex

type Output = ShrRefU32<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t u32) -> ShrRefU32<'b>

Performs the >> operation.

impl ShrAssign<u32> for Complex

fn shr_assign(&mut self, rhs: u32)

Performs the >>= operation.

impl<'t> ShrAssign<&'t u32> for Complex

fn shr_assign(&mut self, rhs: &'t u32)

Performs the >>= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: ShrRefU32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Pow<u32> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, rhs: u32) -> Complex

Performs the power operation.

impl<'t> Pow<&'t u32> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, rhs: &'t u32) -> Complex

Performs the power operation.

impl<'b> Pow<u32> for &'b Complex

type Output = PowRefU32<'b>

The resulting type after the power operation.

fn pow(self, rhs: u32) -> PowRefU32<'b>

Performs the power operation.

impl<'t, 'b> Pow<&'t u32> for &'b Complex

type Output = PowRefU32<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t u32) -> PowRefU32<'b>

Performs the power operation.

impl PowAssign<u32> for Complex

fn pow_assign(&mut self, rhs: u32)

Peforms the power operation.

impl<'t> PowAssign<&'t u32> for Complex

fn pow_assign(&mut self, rhs: &'t u32)

Peforms the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: PowRefU32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl PowAssignRound<u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

impl<'t> PowAssignRound<&'t u32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: &'t u32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

impl Shl<i32> for Complex

type Output = Complex

The resulting type after applying the << operator.

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

Performs the << operation.

impl<'t> Shl<&'t i32> for Complex

type Output = Complex

The resulting type after applying the << operator.

fn shl(self, rhs: &'t i32) -> Complex

Performs the << operation.

impl<'b> Shl<i32> for &'b Complex

type Output = ShlRefI32<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> ShlRefI32<'b>

Performs the << operation.

impl<'t, 'b> Shl<&'t i32> for &'b Complex

type Output = ShlRefI32<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &'t i32) -> ShlRefI32<'b>

Performs the << operation.

impl ShlAssign<i32> for Complex

fn shl_assign(&mut self, rhs: i32)

Performs the <<= operation.

impl<'t> ShlAssign<&'t i32> for Complex

fn shl_assign(&mut self, rhs: &'t i32)

Performs the <<= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: ShlRefI32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Shr<i32> for Complex

type Output = Complex

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<'t> Shr<&'t i32> for Complex

type Output = Complex

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t i32) -> Complex

Performs the >> operation.

impl<'b> Shr<i32> for &'b Complex

type Output = ShrRefI32<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> ShrRefI32<'b>

Performs the >> operation.

impl<'t, 'b> Shr<&'t i32> for &'b Complex

type Output = ShrRefI32<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t i32) -> ShrRefI32<'b>

Performs the >> operation.

impl ShrAssign<i32> for Complex

fn shr_assign(&mut self, rhs: i32)

Performs the >>= operation.

impl<'t> ShrAssign<&'t i32> for Complex

fn shr_assign(&mut self, rhs: &'t i32)

Performs the >>= operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: ShrRefI32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Pow<i32> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, rhs: i32) -> Complex

Performs the power operation.

impl<'t> Pow<&'t i32> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, rhs: &'t i32) -> Complex

Performs the power operation.

impl<'b> Pow<i32> for &'b Complex

type Output = PowRefI32<'b>

The resulting type after the power operation.

fn pow(self, rhs: i32) -> PowRefI32<'b>

Performs the power operation.

impl<'t, 'b> Pow<&'t i32> for &'b Complex

type Output = PowRefI32<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t i32) -> PowRefI32<'b>

Performs the power operation.

impl PowAssign<i32> for Complex

fn pow_assign(&mut self, rhs: i32)

Peforms the power operation.

impl<'t> PowAssign<&'t i32> for Complex

fn pow_assign(&mut self, rhs: &'t i32)

Peforms the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: PowRefI32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl PowAssignRound<i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

impl<'t> PowAssignRound<&'t i32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: &'t i32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

impl Pow<f64> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, rhs: f64) -> Complex

Performs the power operation.

impl<'t> Pow<&'t f64> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, rhs: &'t f64) -> Complex

Performs the power operation.

impl<'b> Pow<f64> for &'b Complex

type Output = PowRefF64<'b>

The resulting type after the power operation.

fn pow(self, rhs: f64) -> PowRefF64<'b>

Performs the power operation.

impl<'t, 'b> Pow<&'t f64> for &'b Complex

type Output = PowRefF64<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t f64) -> PowRefF64<'b>

Performs the power operation.

impl PowAssign<f64> for Complex

fn pow_assign(&mut self, rhs: f64)

Peforms the power operation.

impl<'t> PowAssign<&'t f64> for Complex

fn pow_assign(&mut self, rhs: &'t f64)

Peforms the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: PowRefF64<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl PowAssignRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

impl<'t> PowAssignRound<&'t f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: &'t f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

impl Pow<f32> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, rhs: f32) -> Complex

Performs the power operation.

impl<'t> Pow<&'t f32> for Complex

type Output = Complex

The resulting type after the power operation.

fn pow(self, rhs: &'t f32) -> Complex

Performs the power operation.

impl<'b> Pow<f32> for &'b Complex

type Output = PowRefF32<'b>

The resulting type after the power operation.

fn pow(self, rhs: f32) -> PowRefF32<'b>

Performs the power operation.

impl<'t, 'b> Pow<&'t f32> for &'b Complex

type Output = PowRefF32<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t f32) -> PowRefF32<'b>

Performs the power operation.

impl PowAssign<f32> for Complex

fn pow_assign(&mut self, rhs: f32)

Peforms the power operation.

impl<'t> PowAssign<&'t f32> for Complex

fn pow_assign(&mut self, rhs: &'t f32)

Peforms the power operation.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: PowRefF32<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl PowAssignRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

impl<'t> PowAssignRound<&'t f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn pow_assign_round(
    &mut self,
    rhs: &'t f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the power operation.

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

type Output = Complex

The resulting type after applying the + operator.

fn add(self, rhs: MulRef) -> Complex

Performs the + operation.

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

type Output = AddMulRef<'a>

The resulting type after applying the + operator.

fn add(self, rhs: MulRef<'a>) -> AddMulRef<'a>

Performs the + operation.

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

fn add_assign(&mut self, rhs: MulRef)

Performs the += operation.

impl<'a> AddAssignRound<MulRef<'a>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_assign_round(
    &mut self,
    rhs: MulRef,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: AddMulRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a> AddFrom<MulRef<'a>> for Complex

fn add_from(&mut self, lhs: MulRef)

Peforms the addition.

impl<'a> AddFromRound<MulRef<'a>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn add_from_round(
    &mut self,
    lhs: MulRef,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

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

type Output = Complex

The resulting type after applying the - operator.

fn sub(self, rhs: MulRef) -> Complex

Performs the - operation.

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

type Output = SubMulRef<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: MulRef<'a>) -> SubMulRef<'a>

Performs the - operation.

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

fn sub_assign(&mut self, rhs: MulRef)

Performs the -= operation.

impl<'a> SubAssignRound<MulRef<'a>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_assign_round(
    &mut self,
    rhs: MulRef,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubMulRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a> SubFrom<MulRef<'a>> for Complex

fn sub_from(&mut self, lhs: MulRef)

Peforms the subtraction.

impl<'a> SubFromRound<MulRef<'a>> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn sub_from_round(
    &mut self,
    lhs: MulRef,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: SubMulFromRef<'a>,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Sum for Complex

fn sum<I>(iter: I) -> Complex where
    I: Iterator<Item = Complex>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

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

fn sum<I>(iter: I) -> Complex where
    I: Iterator<Item = &'a Complex>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl Product for Complex

fn product<I>(iter: I) -> Complex where
    I: Iterator<Item = Complex>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

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

fn product<I>(iter: I) -> Complex where
    I: Iterator<Item = &'a Complex>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

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 PartialEq<(Integer, Integer)> for Complex

fn eq(&self, other: &(Integer, 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<(Integer, Rational)> for Complex

fn eq(&self, other: &(Integer, 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<(Integer, Float)> for Complex

fn eq(&self, other: &(Integer, 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<(Integer, u8)> for Complex

fn eq(&self, other: &(Integer, u8)) -> 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, i8)> for Complex

fn eq(&self, other: &(Integer, i8)) -> 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, u16)> for Complex

fn eq(&self, other: &(Integer, u16)) -> 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, i16)> for Complex

fn eq(&self, other: &(Integer, i16)) -> 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, u32)> for Complex

fn eq(&self, other: &(Integer, 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<(Integer, i32)> for Complex

fn eq(&self, other: &(Integer, 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<(Integer, u64)> for Complex

fn eq(&self, other: &(Integer, u64)) -> 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, i64)> for Complex

fn eq(&self, other: &(Integer, i64)) -> 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, usize)> for Complex

fn eq(&self, other: &(Integer, usize)) -> 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, isize)> for Complex

fn eq(&self, other: &(Integer, isize)) -> 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, f32)> for Complex

fn eq(&self, other: &(Integer, 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 PartialEq<(Integer, f64)> for Complex

fn eq(&self, other: &(Integer, 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<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, Integer)> for Complex

fn eq(&self, other: &(Rational, 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, Rational)> for Complex

fn eq(&self, other: &(Rational, 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<(Rational, Float)> for Complex

fn eq(&self, other: &(Rational, 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<(Rational, u8)> for Complex

fn eq(&self, other: &(Rational, u8)) -> 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, i8)> for Complex

fn eq(&self, other: &(Rational, i8)) -> 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, u16)> for Complex

fn eq(&self, other: &(Rational, u16)) -> 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, i16)> for Complex

fn eq(&self, other: &(Rational, i16)) -> 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, u32)> for Complex

fn eq(&self, other: &(Rational, 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<(Rational, i32)> for Complex

fn eq(&self, other: &(Rational, 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<(Rational, u64)> for Complex

fn eq(&self, other: &(Rational, u64)) -> 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, i64)> for Complex

fn eq(&self, other: &(Rational, i64)) -> 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, usize)> for Complex

fn eq(&self, other: &(Rational, usize)) -> 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, isize)> for Complex

fn eq(&self, other: &(Rational, isize)) -> 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, f32)> for Complex

fn eq(&self, other: &(Rational, 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 PartialEq<(Rational, f64)> for Complex

fn eq(&self, other: &(Rational, 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<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, Integer)> for Complex

fn eq(&self, other: &(Float, 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<(Float, Rational)> for Complex

fn eq(&self, other: &(Float, 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, Float)> for Complex

fn eq(&self, other: &(Float, 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<(Float, u8)> for Complex

fn eq(&self, other: &(Float, u8)) -> 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, i8)> for Complex

fn eq(&self, other: &(Float, i8)) -> 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, u16)> for Complex

fn eq(&self, other: &(Float, u16)) -> 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, i16)> for Complex

fn eq(&self, other: &(Float, i16)) -> 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, u32)> for Complex

fn eq(&self, other: &(Float, 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<(Float, i32)> for Complex

fn eq(&self, other: &(Float, 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<(Float, u64)> for Complex

fn eq(&self, other: &(Float, u64)) -> 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, i64)> for Complex

fn eq(&self, other: &(Float, i64)) -> 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, usize)> for Complex

fn eq(&self, other: &(Float, usize)) -> 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, isize)> for Complex

fn eq(&self, other: &(Float, isize)) -> 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, f32)> for Complex

fn eq(&self, other: &(Float, 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 PartialEq<(Float, f64)> for Complex

fn eq(&self, other: &(Float, 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<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<(u8, Integer)> for Complex

fn eq(&self, other: &(u8, 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<(u8, Rational)> for Complex

fn eq(&self, other: &(u8, 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<(u8, Float)> for Complex

fn eq(&self, other: &(u8, 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<(u8, u8)> for Complex

fn eq(&self, other: &(u8, u8)) -> 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<(u8, i8)> for Complex

fn eq(&self, other: &(u8, i8)) -> 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<(u8, u16)> for Complex

fn eq(&self, other: &(u8, u16)) -> 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<(u8, i16)> for Complex

fn eq(&self, other: &(u8, i16)) -> 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<(u8, u32)> for Complex

fn eq(&self, other: &(u8, 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<(u8, i32)> for Complex

fn eq(&self, other: &(u8, 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<(u8, u64)> for Complex

fn eq(&self, other: &(u8, u64)) -> 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<(u8, i64)> for Complex

fn eq(&self, other: &(u8, i64)) -> 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<(u8, usize)> for Complex

fn eq(&self, other: &(u8, usize)) -> 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<(u8, isize)> for Complex

fn eq(&self, other: &(u8, isize)) -> 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<(u8, f32)> for Complex

fn eq(&self, other: &(u8, 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 PartialEq<(u8, f64)> for Complex

fn eq(&self, other: &(u8, 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<u8> for Complex

fn eq(&self, other: &u8) -> 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<(i8, Integer)> for Complex

fn eq(&self, other: &(i8, 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<(i8, Rational)> for Complex

fn eq(&self, other: &(i8, 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<(i8, Float)> for Complex

fn eq(&self, other: &(i8, 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<(i8, u8)> for Complex

fn eq(&self, other: &(i8, u8)) -> 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<(i8, i8)> for Complex

fn eq(&self, other: &(i8, i8)) -> 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<(i8, u16)> for Complex

fn eq(&self, other: &(i8, u16)) -> 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<(i8, i16)> for Complex

fn eq(&self, other: &(i8, i16)) -> 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<(i8, u32)> for Complex

fn eq(&self, other: &(i8, 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<(i8, i32)> for Complex

fn eq(&self, other: &(i8, 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<(i8, u64)> for Complex

fn eq(&self, other: &(i8, u64)) -> 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<(i8, i64)> for Complex

fn eq(&self, other: &(i8, i64)) -> 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<(i8, usize)> for Complex

fn eq(&self, other: &(i8, usize)) -> 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<(i8, isize)> for Complex

fn eq(&self, other: &(i8, isize)) -> 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<(i8, f32)> for Complex

fn eq(&self, other: &(i8, 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 PartialEq<(i8, f64)> for Complex

fn eq(&self, other: &(i8, 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<i8> for Complex

fn eq(&self, other: &i8) -> 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<(u16, Integer)> for Complex

fn eq(&self, other: &(u16, 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<(u16, Rational)> for Complex

fn eq(&self, other: &(u16, 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<(u16, Float)> for Complex

fn eq(&self, other: &(u16, 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<(u16, u8)> for Complex

fn eq(&self, other: &(u16, u8)) -> 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<(u16, i8)> for Complex

fn eq(&self, other: &(u16, i8)) -> 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<(u16, u16)> for Complex

fn eq(&self, other: &(u16, u16)) -> 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<(u16, i16)> for Complex

fn eq(&self, other: &(u16, i16)) -> 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<(u16, u32)> for Complex

fn eq(&self, other: &(u16, 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<(u16, i32)> for Complex

fn eq(&self, other: &(u16, 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<(u16, u64)> for Complex

fn eq(&self, other: &(u16, u64)) -> 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<(u16, i64)> for Complex

fn eq(&self, other: &(u16, i64)) -> 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<(u16, usize)> for Complex

fn eq(&self, other: &(u16, usize)) -> 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<(u16, isize)> for Complex

fn eq(&self, other: &(u16, isize)) -> 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<(u16, f32)> for Complex

fn eq(&self, other: &(u16, 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 PartialEq<(u16, f64)> for Complex

fn eq(&self, other: &(u16, 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<u16> for Complex

fn eq(&self, other: &u16) -> 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<(i16, Integer)> for Complex

fn eq(&self, other: &(i16, 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<(i16, Rational)> for Complex

fn eq(&self, other: &(i16, 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<(i16, Float)> for Complex

fn eq(&self, other: &(i16, 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<(i16, u8)> for Complex

fn eq(&self, other: &(i16, u8)) -> 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<(i16, i8)> for Complex

fn eq(&self, other: &(i16, i8)) -> 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<(i16, u16)> for Complex

fn eq(&self, other: &(i16, u16)) -> 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<(i16, i16)> for Complex

fn eq(&self, other: &(i16, i16)) -> 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<(i16, u32)> for Complex

fn eq(&self, other: &(i16, 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<(i16, i32)> for Complex

fn eq(&self, other: &(i16, 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<(i16, u64)> for Complex

fn eq(&self, other: &(i16, u64)) -> 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<(i16, i64)> for Complex

fn eq(&self, other: &(i16, i64)) -> 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<(i16, usize)> for Complex

fn eq(&self, other: &(i16, usize)) -> 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<(i16, isize)> for Complex

fn eq(&self, other: &(i16, isize)) -> 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<(i16, f32)> for Complex

fn eq(&self, other: &(i16, 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 PartialEq<(i16, f64)> for Complex

fn eq(&self, other: &(i16, 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<i16> for Complex

fn eq(&self, other: &i16) -> 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, Integer)> for Complex

fn eq(&self, other: &(u32, 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<(u32, Rational)> for Complex

fn eq(&self, other: &(u32, 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<(u32, Float)> for Complex

fn eq(&self, other: &(u32, 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, u8)> for Complex

fn eq(&self, other: &(u32, u8)) -> 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, i8)> for Complex

fn eq(&self, other: &(u32, i8)) -> 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, u16)> for Complex

fn eq(&self, other: &(u32, u16)) -> 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, i16)> for Complex

fn eq(&self, other: &(u32, i16)) -> 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, u32)> for Complex

fn eq(&self, other: &(u32, 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<(u32, i32)> for Complex

fn eq(&self, other: &(u32, 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<(u32, u64)> for Complex

fn eq(&self, other: &(u32, u64)) -> 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, i64)> for Complex

fn eq(&self, other: &(u32, i64)) -> 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, usize)> for Complex

fn eq(&self, other: &(u32, usize)) -> 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, isize)> for Complex

fn eq(&self, other: &(u32, isize)) -> 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, f32)> for Complex

fn eq(&self, other: &(u32, 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 PartialEq<(u32, f64)> for Complex

fn eq(&self, other: &(u32, 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<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, Integer)> for Complex

fn eq(&self, other: &(i32, 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<(i32, Rational)> for Complex

fn eq(&self, other: &(i32, 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<(i32, Float)> for Complex

fn eq(&self, other: &(i32, 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<(i32, u8)> for Complex

fn eq(&self, other: &(i32, u8)) -> 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, i8)> for Complex

fn eq(&self, other: &(i32, i8)) -> 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, u16)> for Complex

fn eq(&self, other: &(i32, u16)) -> 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, i16)> for Complex

fn eq(&self, other: &(i32, i16)) -> 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, u32)> for Complex

fn eq(&self, other: &(i32, 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, i32)> for Complex

fn eq(&self, other: &(i32, 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<(i32, u64)> for Complex

fn eq(&self, other: &(i32, u64)) -> 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, i64)> for Complex

fn eq(&self, other: &(i32, i64)) -> 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, usize)> for Complex

fn eq(&self, other: &(i32, usize)) -> 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, isize)> for Complex

fn eq(&self, other: &(i32, isize)) -> 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, f32)> for Complex

fn eq(&self, other: &(i32, 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 PartialEq<(i32, f64)> for Complex

fn eq(&self, other: &(i32, 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<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<(u64, Integer)> for Complex

fn eq(&self, other: &(u64, 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<(u64, Rational)> for Complex

fn eq(&self, other: &(u64, 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<(u64, Float)> for Complex

fn eq(&self, other: &(u64, 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<(u64, u8)> for Complex

fn eq(&self, other: &(u64, u8)) -> 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<(u64, i8)> for Complex

fn eq(&self, other: &(u64, i8)) -> 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<(u64, u16)> for Complex

fn eq(&self, other: &(u64, u16)) -> 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<(u64, i16)> for Complex

fn eq(&self, other: &(u64, i16)) -> 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<(u64, u32)> for Complex

fn eq(&self, other: &(u64, 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<(u64, i32)> for Complex

fn eq(&self, other: &(u64, 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<(u64, u64)> for Complex

fn eq(&self, other: &(u64, u64)) -> 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<(u64, i64)> for Complex

fn eq(&self, other: &(u64, i64)) -> 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<(u64, usize)> for Complex

fn eq(&self, other: &(u64, usize)) -> 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<(u64, isize)> for Complex

fn eq(&self, other: &(u64, isize)) -> 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<(u64, f32)> for Complex

fn eq(&self, other: &(u64, 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 PartialEq<(u64, f64)> for Complex

fn eq(&self, other: &(u64, 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<u64> for Complex

fn eq(&self, other: &u64) -> 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<(i64, Integer)> for Complex

fn eq(&self, other: &(i64, 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<(i64, Rational)> for Complex

fn eq(&self, other: &(i64, 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<(i64, Float)> for Complex

fn eq(&self, other: &(i64, 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<(i64, u8)> for Complex

fn eq(&self, other: &(i64, u8)) -> 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<(i64, i8)> for Complex

fn eq(&self, other: &(i64, i8)) -> 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<(i64, u16)> for Complex

fn eq(&self, other: &(i64, u16)) -> 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<(i64, i16)> for Complex

fn eq(&self, other: &(i64, i16)) -> 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<(i64, u32)> for Complex

fn eq(&self, other: &(i64, 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<(i64, i32)> for Complex

fn eq(&self, other: &(i64, 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<(i64, u64)> for Complex

fn eq(&self, other: &(i64, u64)) -> 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<(i64, i64)> for Complex

fn eq(&self, other: &(i64, i64)) -> 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<(i64, usize)> for Complex

fn eq(&self, other: &(i64, usize)) -> 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<(i64, isize)> for Complex

fn eq(&self, other: &(i64, isize)) -> 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<(i64, f32)> for Complex

fn eq(&self, other: &(i64, 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 PartialEq<(i64, f64)> for Complex

fn eq(&self, other: &(i64, 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<i64> for Complex

fn eq(&self, other: &i64) -> 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<(usize, Integer)> for Complex

fn eq(&self, other: &(usize, 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<(usize, Rational)> for Complex

fn eq(&self, other: &(usize, 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<(usize, Float)> for Complex

fn eq(&self, other: &(usize, 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<(usize, u8)> for Complex

fn eq(&self, other: &(usize, u8)) -> 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<(usize, i8)> for Complex

fn eq(&self, other: &(usize, i8)) -> 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<(usize, u16)> for Complex

fn eq(&self, other: &(usize, u16)) -> 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<(usize, i16)> for Complex

fn eq(&self, other: &(usize, i16)) -> 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<(usize, u32)> for Complex

fn eq(&self, other: &(usize, 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<(usize, i32)> for Complex

fn eq(&self, other: &(usize, 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<(usize, u64)> for Complex

fn eq(&self, other: &(usize, u64)) -> 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<(usize, i64)> for Complex

fn eq(&self, other: &(usize, i64)) -> 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<(usize, usize)> for Complex

fn eq(&self, other: &(usize, usize)) -> 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<(usize, isize)> for Complex

fn eq(&self, other: &(usize, isize)) -> 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<(usize, f32)> for Complex

fn eq(&self, other: &(usize, 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 PartialEq<(usize, f64)> for Complex

fn eq(&self, other: &(usize, 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<usize> for Complex

fn eq(&self, other: &usize) -> 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<(isize, Integer)> for Complex

fn eq(&self, other: &(isize, 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<(isize, Rational)> for Complex

fn eq(&self, other: &(isize, 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<(isize, Float)> for Complex

fn eq(&self, other: &(isize, 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<(isize, u8)> for Complex

fn eq(&self, other: &(isize, u8)) -> 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<(isize, i8)> for Complex

fn eq(&self, other: &(isize, i8)) -> 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<(isize, u16)> for Complex

fn eq(&self, other: &(isize, u16)) -> 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<(isize, i16)> for Complex

fn eq(&self, other: &(isize, i16)) -> 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<(isize, u32)> for Complex

fn eq(&self, other: &(isize, 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<(isize, i32)> for Complex

fn eq(&self, other: &(isize, 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<(isize, u64)> for Complex

fn eq(&self, other: &(isize, u64)) -> 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<(isize, i64)> for Complex

fn eq(&self, other: &(isize, i64)) -> 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<(isize, usize)> for Complex

fn eq(&self, other: &(isize, usize)) -> 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<(isize, isize)> for Complex

fn eq(&self, other: &(isize, isize)) -> 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<(isize, f32)> for Complex

fn eq(&self, other: &(isize, 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 PartialEq<(isize, f64)> for Complex

fn eq(&self, other: &(isize, 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<isize> for Complex

fn eq(&self, other: &isize) -> 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, Integer)> for Complex

fn eq(&self, other: &(f32, 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<(f32, Rational)> for Complex

fn eq(&self, other: &(f32, 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<(f32, Float)> for Complex

fn eq(&self, other: &(f32, 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<(f32, u8)> for Complex

fn eq(&self, other: &(f32, u8)) -> 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, i8)> for Complex

fn eq(&self, other: &(f32, i8)) -> 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, u16)> for Complex

fn eq(&self, other: &(f32, u16)) -> 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, i16)> for Complex

fn eq(&self, other: &(f32, i16)) -> 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, u32)> for Complex

fn eq(&self, other: &(f32, 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<(f32, i32)> for Complex

fn eq(&self, other: &(f32, 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<(f32, u64)> for Complex

fn eq(&self, other: &(f32, u64)) -> 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, i64)> for Complex

fn eq(&self, other: &(f32, i64)) -> 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, usize)> for Complex

fn eq(&self, other: &(f32, usize)) -> 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, isize)> for Complex

fn eq(&self, other: &(f32, isize)) -> 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, f32)> for Complex

fn eq(&self, other: &(f32, 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 PartialEq<(f32, f64)> for Complex

fn eq(&self, other: &(f32, 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 PartialEq<(f64, Integer)> for Complex

fn eq(&self, other: &(f64, 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<(f64, Rational)> for Complex

fn eq(&self, other: &(f64, 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<(f64, Float)> for Complex

fn eq(&self, other: &(f64, 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<(f64, u8)> for Complex

fn eq(&self, other: &(f64, u8)) -> 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, i8)> for Complex

fn eq(&self, other: &(f64, i8)) -> 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, u16)> for Complex

fn eq(&self, other: &(f64, u16)) -> 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, i16)> for Complex

fn eq(&self, other: &(f64, i16)) -> 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, u32)> for Complex

fn eq(&self, other: &(f64, 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<(f64, i32)> for Complex

fn eq(&self, other: &(f64, 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, u64)> for Complex

fn eq(&self, other: &(f64, u64)) -> 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, i64)> for Complex

fn eq(&self, other: &(f64, i64)) -> 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, usize)> for Complex

fn eq(&self, other: &(f64, usize)) -> 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, isize)> for Complex

fn eq(&self, other: &(f64, isize)) -> 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, f32)> for Complex

fn eq(&self, other: &(f64, 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 PartialEq<(f64, f64)> for Complex

fn eq(&self, other: &(f64, 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<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 Serialize for Complex

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de> Deserialize<'de> for Complex

fn deserialize<D>(deserializer: D) -> Result<Complex, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

fn deserialize_in_place<D>(
    deserializer: D,
    place: &mut Complex
) -> Result<(), D::Error> where
    D: Deserializer<'de>, 

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 Default for Complex

fn default() -> Complex

Returns the "default value" for a type.

impl Drop for Complex

fn drop(&mut self)

Executes the destructor for this type.

impl<Re> From<Re> for Complex where
    Float: From<Re>, 

fn from(re: Re) -> Self

Performs the conversion.

impl<Re, Im> From<(Re, Im)> for Complex where
    Float: From<Re> + From<Im>, 

fn from((re, im): (Re, Im)) -> Self

Performs the conversion.

impl From<OrdComplex> for Complex

fn from(ord: OrdComplex) -> Self

Performs the conversion.

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.

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

fn assign(&mut self, src: T)

Peforms the assignement.

impl AssignRound for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Peforms the assignment.

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,
    src: &'a Complex,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<Re> AssignRound<Re> for Complex where
    Float: AssignRound<Re, Round = Round, Ordering = Ordering>, 

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: Re,
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<Re, Im> AssignRound<(Re, Im)> for Complex where
    Float: AssignRound<Re, Round = Round, Ordering = Ordering> + AssignRound<Im, Round = Round, Ordering = Ordering>, 

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: (Re, Im),
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl<'a, Re, Im> AssignRound<&'a (Re, Im)> for Complex where
    Float: AssignRound<&'a Re, Round = Round, Ordering = Ordering> + AssignRound<&'a Im, Round = Round, Ordering = Ordering>, 

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

fn assign_round(
    &mut self,
    src: &'a (Re, Im),
    round: (Round, Round)
) -> (Ordering, Ordering)

Peforms the assignment.

impl Send for Complex

impl Sync for Complex