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 incomplete-computation value that has to be assigned to a new Complex number.

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 incomplete-computation value is obtained from multiplying two Complex number references, it can be added to or subtracted from another Complex number (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 number type supports various functions. Most methods have four versions:

1. The first method consumes the operand and rounds the returned Complex number 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 is an incomplete-computation value that can be assigned to a Complex number; 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().real() < 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().real() < 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().real() < 0.0001);
// d was not consumed
assert_eq!(d, (1, 1));

Methods

impl Complex

pub fn new<P: Prec>(prec: P) -> Self

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

Panics

Panics if the precision is out of the allowed range.

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);

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

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

Panics

Panics if prec is out of the allowed range.

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));

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

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

Panics

Panics if prec is out of the allowed range.

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));

pub 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));

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

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

Panics

Panics if the precision is out of the allowed range.

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));

pub 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.

Panics

Panics if the precision is out of the allowed range.

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));

pub fn parse<S: AsRef<[u8]>>(
    src: S
) -> Result<ParseIncomplete, ParseComplexError>

Parses a decimal string slice (&str) or byte slice (&[u8]) into a Complex number.

AssignRound<Src> for Complex is implemented with the unwrapped returned incomplete-computation value as Src.

The string can contain either of the following three:

1. One floating-point number that can be parsed by Float::parse. ASCII whitespace is treated in the same way as well.
2. Two floating-point numbers inside round brackets separated by one comma. ASCII whitespace is treated in the same way as 1 above, and is also allowed around the brackets and the comma.
3. Two floating-point numbers inside round brackets separated by ASCII whitespace. Since the real and imaginary parts are separated by whitespace, they themselves cannot contain whitespace. ASCII whitespace is still allowed around the brackets and between the two parts.

Examples

use rug::Complex;
use std::f64;

let valid1 = Complex::parse("(12.5, -13.5)");
let c1 = Complex::with_val(53, valid1.unwrap());
assert_eq!(c1, (12.5, -13.5));
let valid2 = Complex::parse("(inf 0.0)");
let c2 = Complex::with_val(53, valid2.unwrap());
assert_eq!(c2, (f64::INFINITY, 0.0));

let invalid = Complex::parse("(1 2 3)");
assert!(invalid.is_err());

pub fn parse_radix<S: AsRef<[u8]>>(
    src: S,
    radix: i32
) -> Result<ParseIncomplete, ParseComplexError>

Parses a string slice (&str) or byte slice (&[u8]) into a Complex number.

AssignRound<Src> for Complex is implemented with the unwrapped returned incomplete-computation value as Src.

The string can contain either of the following three:

1. One floating-point number that can be parsed by Float::parse_radix. ASCII whitespace is treated in the same way as well.
2. Two floating-point numbers inside round brackets separated by one comma. ASCII whitespace is treated in the same way as 1 above, and is also allowed around the brackets and the comma.
3. Two floating-point numbers inside round brackets separated by ASCII whitespace. Since the real and imaginary parts are separated by whitespace, they themselves cannot contain whitespace. ASCII whitespace is still allowed around the brackets and between the two parts.

Panics

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

Examples

use rug::Complex;
use std::f64;

let valid1 = Complex::parse_radix("(12, 1a)", 16);
let c1 = Complex::with_val(53, valid1.unwrap());
assert_eq!(c1, (0x12, 0x1a));
let valid2 = Complex::parse_radix("(@inf@ zz)", 36);
let c2 = Complex::with_val(53, valid2.unwrap());
assert_eq!(c2, (f64::INFINITY, 35 * 36 + 35));

let invalid = Complex::parse_radix("(1 2 3)", 10);
assert!(invalid.is_err());

pub 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.

Panics

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

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)");

pub 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.

Panics

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

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)");

pub unsafe fn from_raw(raw: mpc_t) -> Self

Creates a Complex number 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 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
}

pub fn into_raw(self) -> mpc_t

Converts a Complex number 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);
    }
}

pub fn as_raw(&self) -> *const mpc_t

Returns a pointer to the inner 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));
}

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

Returns an unsafe mutable pointer to the inner 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));
}

pub 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)

pub 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)

pub 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));

pub 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));

pub 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));

pub 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);

pub 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);

pub 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);

pub 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);

pub fn as_ord(&self) -> &OrdComplex

Borrows the Complex number 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);

pub fn eq0(&self) -> bool

Returns the same result as self.eq(&0), but is faster.

Examples

use rug::{Assign, Complex};
use rug::float::Special;
let mut c = Complex::with_val(53, (Special::NegZero, Special::Zero));
assert!(c.eq0());
c += 5.2;
assert!(!c.eq0());
c.mut_real().assign(Special::Nan);
assert!(!c.eq0());

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

Compares the absolute values of self and other.

Examples

use rug::Complex;
use std::cmp::Ordering;
let five = Complex::with_val(53, (5, 0));
let five_rotated = Complex::with_val(53, (3, -4));
let greater_than_five = Complex::with_val(53, (-4, -4));
let has_nan = Complex::with_val(53, (5, 0.0/0.0));
assert_eq!(five.cmp_abs(&five_rotated), Some(Ordering::Equal));
assert_eq!(five.cmp_abs(&greater_than_five), Some(Ordering::Less));
assert_eq!(five.cmp_abs(&has_nan), None);

pub fn sum<'a, I>(values: I) -> SumIncomplete<'a, I> where
    I: Iterator<Item = &'a Self>, 

Adds a list of Complex numbers with correct rounding.

Assign<Src> for Complex, AssignRound<Src> for Complex, AddAssign<Src> for Complex, AddAssignRound<Src> for Complex and Add<Src> for Complex are implemented with the returned incomplete-computation value as Src.

Examples

use rug::Complex;

// Give each value only 4 bits of precision for example purposes.
let values = [
    Complex::with_val(4, (5.0, 1024.0)),
    Complex::with_val(4, (1024.0, 15.0)),
    Complex::with_val(4, (-1024.0, -1024.0)),
    Complex::with_val(4, (-4.5, -16.0)),
];

// The result should still be exact if it fits.
let r1 = Complex::sum(values.iter());
let sum1 = Complex::with_val(4, r1);
assert_eq!(sum1, (0.5, -1.0));

let r2 = Complex::sum(values.iter());
let sum2 = Complex::with_val(4, (1.0, -1.0)) + r2;
assert_eq!(sum2, (1.5, -2.0));

let r3 = Complex::sum(values.iter());
let mut sum3 = Complex::with_val(4, (16, 16));
sum3 += r3;
// (16.5, 15) rounded to (16, 15)
assert_eq!(sum3, (16, 15));

pub 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));

pub 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));

pub 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 number 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));

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

Multiplies and adds in one fused operation.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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));

pub 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));

pub 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));

pub 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 number 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));

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

Multiplies and subtracts in one fused operation.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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));

pub 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());

pub 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());

pub fn proj_ref(&self) -> ProjIncomplete

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.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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());

pub 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));

pub 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));

pub 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));

pub fn square_ref(&self) -> SquareIncomplete

Computes the square.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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));

pub 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));

pub 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));

pub 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));

pub fn sqrt_ref(&self) -> SqrtIncomplete

Computes the square root.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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));

pub 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));

pub 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));

pub fn conj_ref(&self) -> ConjIncomplete

Computes the complex conjugate.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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));

pub fn abs(self) -> Complex

Computes the absolute value.

Examples

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

pub 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));

pub fn abs_ref(&self) -> AbsIncomplete

Computes the absolute value.

Assign<Src> for Float, Assign<Src> for Complex, AssignRound<Src> for Float and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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);

pub fn arg(self) -> Complex

Computes the argument, rounding to the nearest.

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::Complex;
let c = Complex::with_val(53, (40, 30));
let arg = c.arg();
assert_eq!(arg, (0.75_f64.atan(), 0));

pub 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));

pub 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));

pub fn arg_ref(&self) -> ArgIncomplete

Computes the argument.

Assign<Src> for Float, Assign<Src> for Complex, AssignRound<Src> for Float and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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);

pub 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));

pub 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));

pub 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));

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

Multiplies the complex number by ±i.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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));

pub 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));

pub 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));

pub 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));

pub fn recip_ref(&self) -> RecipIncomplete

Computes the reciprocal.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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));

pub fn norm(self) -> Complex

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

Examples

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

pub 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));

pub 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));

pub fn norm_ref(&self) -> NormIncomplete

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

Assign<Src> for Float, Assign<Src> for Complex, AssignRound<Src> for Float and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn ln_ref(&self) -> LnIncomplete

Computes the natural logarithm;

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn log10_ref(&self) -> Log10Incomplete

Computes the logarithm to base 10.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub fn root_of_unity(n: u32, k: u32) -> RootOfUnityIncomplete

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.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn exp_ref(&self) -> ExpIncomplete

Computes the exponential.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn sin_ref(&self) -> SinIncomplete

Computes the sine.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn cos_ref(&self) -> CosIncomplete

Computes the cosine.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);
assert!(*(cos - expected_cos).abs().real() < 0.0001);

pub 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().real() < 0.0001);
assert!(*(cos - expected_cos).abs().real() < 0.0001);

pub 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));

pub fn sin_cos_ref(&self) -> SinCosIncomplete

Computes the sine and cosine.

Assign<Src> for (Complex, Complex), Assign<Src> for (&mut Complex, &mut Complex), AssignRound<Src> for (Complex, Complex) and AssignRound<Src> for (&mut Complex, &mut Complex) are implemented with the returned incomplete-computation value 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 (mut sin, mut cos) = (Complex::new(53), Complex::new(53));
let sin_cos = phase.sin_cos_ref();
(&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().real() < 0.0001);
assert!(*(cos - expected_cos).abs().real() < 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 sin_cos = phase.sin_cos_ref();
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));

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn tan_ref(&self) -> TanIncomplete

Computes the tangent.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn sinh_ref(&self) -> SinhIncomplete

Computes the hyperbolic sine.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn cosh_ref(&self) -> CoshIncomplete

Computes the hyperbolic cosine.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn tanh_ref(&self) -> TanhIncomplete

Computes the hyperbolic tangent.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn asin_ref(&self) -> AsinIncomplete

Computes the inverse sine.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn acos_ref(&self) -> AcosIncomplete

Computes the inverse cosine.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn atan_ref(&self) -> AtanIncomplete

Computes the inverse tangent.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn asinh_ref(&self) -> AsinhIncomplete

Computes the inverse hyperboic sine.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn acosh_ref(&self) -> AcoshIncomplete

Computes the inverse hyperbolic cosine.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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().real() < 0.0001);

pub 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));

pub fn atanh_ref(&self) -> AtanhIncomplete

Computes the inverse hyperbolic tangent.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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().real() < 0.0001);

pub fn random_bits<'a, 'b: 'a>(
    rng: &'a mut RandState<'b>
) -> RandomBitsIncomplete<'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.

There is a corner case where the generated random number part is converted to NaN: if the precision is very large, the generated random number could have an exponent less than the allowed minimum exponent, and NaN is used to indicate this. For this to occur in practice, the minimum exponent has to be set to have a very small magnitude using the low-level MPFR interface, or the random number generator has to be designed specifically to trigger this case.

Assign<Src> for Complex is implemented with the returned incomplete-computation value as Src.

Examples

use rug::{Assign, Complex};
use rug::rand::RandState;
let mut rand = RandState::new();
let mut c = Complex::new(2);
c.assign(Complex::random_bits(&mut rand));
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);

pub 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.

Assign<Src> for Complex and AssignRound<Src> for Complex are implemented with the returned incomplete-computation value 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
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
);

Trait Implementations

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 = NegIncomplete<'a>

The resulting type after applying the - operator.

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

Performs the unary - operation.

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 = AddIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Complex) -> AddIncomplete<'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> 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 = SubIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Complex) -> SubIncomplete<'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> 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 = MulIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Complex) -> MulIncomplete<'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> 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 = DivIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Complex) -> DivIncomplete<'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> 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 = PowIncomplete<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Complex) -> PowIncomplete<'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> 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 = AddFloatIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Float) -> AddFloatIncomplete<'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> Add<Float> for &'a Complex

type Output = AddOwnedFloatIncomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

impl Add<Complex> for Float

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 Float

type Output = AddOwnedFloatIncomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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 &'a Float

type Output = AddFloatIncomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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 = SubFloatIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Float) -> SubFloatIncomplete<'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> Sub<Float> for &'a Complex

type Output = SubFromFloatIncomplete<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

impl Sub<Complex> for Float

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 Float

type Output = SubFromOwnedFloatIncomplete<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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 &'a Float

type Output = SubOwnedFloatIncomplete<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

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 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 = MulFloatIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Float) -> MulFloatIncomplete<'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> Mul<Float> for &'a Complex

type Output = MulOwnedFloatIncomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Complex> for Float

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 Float

type Output = MulOwnedFloatIncomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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 &'a Float

type Output = MulFloatIncomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

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 = DivFloatIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Float) -> DivFloatIncomplete<'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> Div<Float> for &'a Complex

type Output = DivFromFloatIncomplete<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

impl Div<Complex> for Float

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 Float

type Output = DivFromOwnedFloatIncomplete<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

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

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 &'a Float

type Output = DivOwnedFloatIncomplete<'a>

The resulting type after applying the / operator.

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

Performs the / operation.

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 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 = PowFloatIncomplete<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Float) -> PowFloatIncomplete<'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> Pow<Float> for &'a Complex

type Output = PowOwnedFloatIncomplete<'a>

The resulting type after the power operation.

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

Performs the power operation.

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 = PowIntegerIncomplete<'a>

The resulting type after the power operation.

fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete<'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> Pow<Integer> for &'a Complex

type Output = PowOwnedIntegerIncomplete<'a>

The resulting type after the power operation.

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

Performs the power operation.

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 = AddU32Incomplete<'b>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'t u32) -> AddU32Incomplete<'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 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 Add<Complex> for u32

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 u32

type Output = AddU32Incomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddU32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Complex) -> AddU32Incomplete<'b>

Performs the + operation.

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 = SubU32Incomplete<'b>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'t u32) -> SubU32Incomplete<'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 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 Sub<Complex> for u32

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubFromU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Complex) -> SubFromU32Incomplete<'b>

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubFromU32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Complex) -> SubFromU32Incomplete<'b>

Performs the - operation.

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 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 = MulU32Incomplete<'b>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'t u32) -> MulU32Incomplete<'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 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 Mul<Complex> for u32

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 u32

type Output = MulU32Incomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulU32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Complex) -> MulU32Incomplete<'b>

Performs the * operation.

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 = DivU32Incomplete<'b>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'t u32) -> DivU32Incomplete<'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 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 Div<Complex> for u32

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivFromU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Complex) -> DivFromU32Incomplete<'b>

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivFromU32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Complex) -> DivFromU32Incomplete<'b>

Performs the / operation.

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 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 = AddI32Incomplete<'b>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'t i32) -> AddI32Incomplete<'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 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 Add<Complex> for i32

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 i32

type Output = AddI32Incomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddI32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Complex) -> AddI32Incomplete<'b>

Performs the + operation.

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 = SubI32Incomplete<'b>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'t i32) -> SubI32Incomplete<'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 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 Sub<Complex> for i32

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubFromI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Complex) -> SubFromI32Incomplete<'b>

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubFromI32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Complex) -> SubFromI32Incomplete<'b>

Performs the - operation.

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 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 = MulI32Incomplete<'b>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'t i32) -> MulI32Incomplete<'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 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 Mul<Complex> for i32

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 i32

type Output = MulI32Incomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulI32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Complex) -> MulI32Incomplete<'b>

Performs the * operation.

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 = DivI32Incomplete<'b>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'t i32) -> DivI32Incomplete<'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 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 Div<Complex> for i32

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivFromI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Complex) -> DivFromI32Incomplete<'b>

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivFromI32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Complex) -> DivFromI32Incomplete<'b>

Performs the / operation.

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 Add<f32> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddF32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> AddF32Incomplete<'b>

Performs the + operation.

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

type Output = AddF32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'t f32) -> AddF32Incomplete<'b>

Performs the + operation.

impl AddAssign<f32> for Complex

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

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

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

Performs the += operation.

impl AddAssignRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

impl<'t> AddAssignRound<&'t f32> 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 f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl Add<Complex> for f32

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 f32

type Output = AddF32Incomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddF32Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Complex) -> AddF32Incomplete<'b>

Performs the + operation.

impl AddFrom<f32> for Complex

fn add_from(&mut self, lhs: f32)

Peforms the addition.

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

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

Peforms the addition.

impl AddFromRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

impl<'t> AddFromRound<&'t f32> 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 f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl Sub<f32> for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubF32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> SubF32Incomplete<'b>

Performs the - operation.

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

type Output = SubF32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'t f32) -> SubF32Incomplete<'b>

Performs the - operation.

impl SubAssign<f32> for Complex

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

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

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

Performs the -= operation.

impl SubAssignRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

impl<'t> SubAssignRound<&'t f32> 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 f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl Sub<Complex> for f32

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubFromF32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Complex) -> SubFromF32Incomplete<'b>

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubFromF32Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Complex) -> SubFromF32Incomplete<'b>

Performs the - operation.

impl SubFrom<f32> for Complex

fn sub_from(&mut self, lhs: f32)

Peforms the subtraction.

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

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

Peforms the subtraction.

impl SubFromRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

impl<'t> SubFromRound<&'t f32> 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 f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl Mul<f32> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulF32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> MulF32Incomplete<'b>

Performs the * operation.

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

type Output = MulF32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'t f32) -> MulF32Incomplete<'b>

Performs the * operation.

impl MulAssign<f32> for Complex

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

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

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

Performs the *= operation.

impl MulAssignRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

impl<'t> MulAssignRound<&'t f32> 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 f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl Mul<Complex> for f32

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 f32

type Output = MulF32Incomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulF32Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Complex) -> MulF32Incomplete<'b>

Performs the * operation.

impl MulFrom<f32> for Complex

fn mul_from(&mut self, lhs: f32)

Peforms the multiplication.

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

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

Peforms the multiplication.

impl MulFromRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

impl<'t> MulFromRound<&'t f32> 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 f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl Div<f32> for Complex

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivF32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> DivF32Incomplete<'b>

Performs the / operation.

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

type Output = DivF32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'t f32) -> DivF32Incomplete<'b>

Performs the / operation.

impl DivAssign<f32> for Complex

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

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

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

Performs the /= operation.

impl DivAssignRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the division.

impl<'t> DivAssignRound<&'t f32> 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 f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl Div<Complex> for f32

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivFromF32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Complex) -> DivFromF32Incomplete<'b>

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivFromF32Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Complex) -> DivFromF32Incomplete<'b>

Performs the / operation.

impl DivFrom<f32> for Complex

fn div_from(&mut self, lhs: f32)

Peforms the division.

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

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

Peforms the division.

impl DivFromRound<f32> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the division.

impl<'t> DivFromRound<&'t f32> 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 f32,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl Add<f64> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddF64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> AddF64Incomplete<'b>

Performs the + operation.

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

type Output = AddF64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'t f64) -> AddF64Incomplete<'b>

Performs the + operation.

impl AddAssign<f64> for Complex

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

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

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

Performs the += operation.

impl AddAssignRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

impl<'t> AddAssignRound<&'t f64> 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 f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl Add<Complex> for f64

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 f64

type Output = AddF64Incomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddF64Incomplete<'b>

The resulting type after applying the + operator.

fn add(self, rhs: &'b Complex) -> AddF64Incomplete<'b>

Performs the + operation.

impl AddFrom<f64> for Complex

fn add_from(&mut self, lhs: f64)

Peforms the addition.

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

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

Peforms the addition.

impl AddFromRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

impl<'t> AddFromRound<&'t f64> 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 f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl Sub<f64> for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubF64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> SubF64Incomplete<'b>

Performs the - operation.

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

type Output = SubF64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'t f64) -> SubF64Incomplete<'b>

Performs the - operation.

impl SubAssign<f64> for Complex

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

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

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

Performs the -= operation.

impl SubAssignRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

impl<'t> SubAssignRound<&'t f64> 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 f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl Sub<Complex> for f64

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubFromF64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Complex) -> SubFromF64Incomplete<'b>

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubFromF64Incomplete<'b>

The resulting type after applying the - operator.

fn sub(self, rhs: &'b Complex) -> SubFromF64Incomplete<'b>

Performs the - operation.

impl SubFrom<f64> for Complex

fn sub_from(&mut self, lhs: f64)

Peforms the subtraction.

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

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

Peforms the subtraction.

impl SubFromRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

impl<'t> SubFromRound<&'t f64> 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 f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl Mul<f64> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulF64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> MulF64Incomplete<'b>

Performs the * operation.

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

type Output = MulF64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'t f64) -> MulF64Incomplete<'b>

Performs the * operation.

impl MulAssign<f64> for Complex

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

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

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

Performs the *= operation.

impl MulAssignRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

impl<'t> MulAssignRound<&'t f64> 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 f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl Mul<Complex> for f64

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 f64

type Output = MulF64Incomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulF64Incomplete<'b>

The resulting type after applying the * operator.

fn mul(self, rhs: &'b Complex) -> MulF64Incomplete<'b>

Performs the * operation.

impl MulFrom<f64> for Complex

fn mul_from(&mut self, lhs: f64)

Peforms the multiplication.

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

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

Peforms the multiplication.

impl MulFromRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

impl<'t> MulFromRound<&'t f64> 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 f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl Div<f64> for Complex

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivF64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> DivF64Incomplete<'b>

Performs the / operation.

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

type Output = DivF64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'t f64) -> DivF64Incomplete<'b>

Performs the / operation.

impl DivAssign<f64> for Complex

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

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

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

Performs the /= operation.

impl DivAssignRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the division.

impl<'t> DivAssignRound<&'t f64> 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 f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl Div<Complex> for f64

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivFromF64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Complex) -> DivFromF64Incomplete<'b>

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivFromF64Incomplete<'b>

The resulting type after applying the / operator.

fn div(self, rhs: &'b Complex) -> DivFromF64Incomplete<'b>

Performs the / operation.

impl DivFrom<f64> for Complex

fn div_from(&mut self, lhs: f64)

Peforms the division.

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

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

Peforms the division.

impl DivFromRound<f64> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the division.

impl<'t> DivFromRound<&'t f64> 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 f64,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

impl Add<Integer> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Integer) -> AddIntegerIncomplete<'a>

Performs the + operation.

impl AddAssign<Integer> for Complex

fn add_assign(&mut self, rhs: Integer)

Performs the += operation.

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

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

Performs the += operation.

impl AddAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

impl<'a> AddAssignRound<&'a Integer> 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 Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

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

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Integer) -> AddOwnedIntegerIncomplete<'a>

Performs the + operation.

impl Add<Complex> for Integer

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 Integer

type Output = AddOwnedIntegerIncomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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 &'a Integer

type Output = AddIntegerIncomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddFrom<Integer> for Complex

fn add_from(&mut self, lhs: Integer)

Peforms the addition.

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

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

Peforms the addition.

impl AddFromRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

impl<'a> AddFromRound<&'a Integer> 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 Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl Sub<Integer> for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Integer) -> SubIntegerIncomplete<'a>

Performs the - operation.

impl SubAssign<Integer> for Complex

fn sub_assign(&mut self, rhs: Integer)

Performs the -= operation.

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

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

Performs the -= operation.

impl SubAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

impl<'a> SubAssignRound<&'a Integer> 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 Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Output = SubFromIntegerIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Integer) -> SubFromIntegerIncomplete<'a>

Performs the - operation.

impl Sub<Complex> for Integer

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 Integer

type Output = SubFromOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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 &'a Integer

type Output = SubOwnedIntegerIncomplete<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubFrom<Integer> for Complex

fn sub_from(&mut self, lhs: Integer)

Peforms the subtraction.

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

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

Peforms the subtraction.

impl SubFromRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

impl<'a> SubFromRound<&'a Integer> 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 Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl Mul<Integer> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Integer) -> MulIntegerIncomplete<'a>

Performs the * operation.

impl MulAssign<Integer> for Complex

fn mul_assign(&mut self, rhs: Integer)

Performs the *= operation.

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

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

Performs the *= operation.

impl MulAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

impl<'a> MulAssignRound<&'a Integer> 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 Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

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

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Integer) -> MulOwnedIntegerIncomplete<'a>

Performs the * operation.

impl Mul<Complex> for Integer

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 Integer

type Output = MulOwnedIntegerIncomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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 &'a Integer

type Output = MulIntegerIncomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulFrom<Integer> for Complex

fn mul_from(&mut self, lhs: Integer)

Peforms the multiplication.

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

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

Peforms the multiplication.

impl MulFromRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

impl<'a> MulFromRound<&'a Integer> 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 Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl Div<Integer> for Complex

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Integer) -> DivIntegerIncomplete<'a>

Performs the / operation.

impl DivAssign<Integer> for Complex

fn div_assign(&mut self, rhs: Integer)

Performs the /= operation.

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

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

Performs the /= operation.

impl DivAssignRound<Integer> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the division.

impl<'a> DivAssignRound<&'a Integer> 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 Integer,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

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

type Output = DivOwnedIntegerIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Integer) -> DivOwnedIntegerIncomplete<'a>

Performs the / operation.

impl Add<Rational> for Complex

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Complex

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = AddRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Rational) -> AddRationalIncomplete<'a>

Performs the + operation.

impl AddAssign<Rational> for Complex

fn add_assign(&mut self, rhs: Rational)

Performs the += operation.

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

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

Performs the += operation.

impl AddAssignRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

impl<'a> AddAssignRound<&'a Rational> 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 Rational,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

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

type Output = AddOwnedRationalIncomplete<'a>

The resulting type after applying the + operator.

fn add(self, rhs: Rational) -> AddOwnedRationalIncomplete<'a>

Performs the + operation.

impl Add<Complex> for Rational

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 Rational

type Output = AddOwnedRationalIncomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

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

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 &'a Rational

type Output = AddRationalIncomplete<'a>

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddFrom<Rational> for Complex

fn add_from(&mut self, lhs: Rational)

Peforms the addition.

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

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

Peforms the addition.

impl AddFromRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the addition.

impl<'a> AddFromRound<&'a Rational> 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 Rational,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the addition.

impl Sub<Rational> for Complex

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Complex

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = SubRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Rational) -> SubRationalIncomplete<'a>

Performs the - operation.

impl SubAssign<Rational> for Complex

fn sub_assign(&mut self, rhs: Rational)

Performs the -= operation.

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

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

Performs the -= operation.

impl SubAssignRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

impl<'a> SubAssignRound<&'a Rational> 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 Rational,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

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

type Output = SubFromRationalIncomplete<'a>

The resulting type after applying the - operator.

fn sub(self, rhs: Rational) -> SubFromRationalIncomplete<'a>

Performs the - operation.

impl Sub<Complex> for Rational

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 Rational

type Output = SubFromOwnedRationalIncomplete<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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 &'a Rational

type Output = SubOwnedRationalIncomplete<'a>

The resulting type after applying the - operator.

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

Performs the - operation.

impl SubFrom<Rational> for Complex

fn sub_from(&mut self, lhs: Rational)

Peforms the subtraction.

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

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

Peforms the subtraction.

impl SubFromRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the subtraction.

impl<'a> SubFromRound<&'a Rational> 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 Rational,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the subtraction.

impl Mul<Rational> for Complex

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Complex

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = MulRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a Rational) -> MulRationalIncomplete<'a>

Performs the * operation.

impl MulAssign<Rational> for Complex

fn mul_assign(&mut self, rhs: Rational)

Performs the *= operation.

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

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

Performs the *= operation.

impl MulAssignRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

impl<'a> MulAssignRound<&'a Rational> 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 Rational,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

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

type Output = MulOwnedRationalIncomplete<'a>

The resulting type after applying the * operator.

fn mul(self, rhs: Rational) -> MulOwnedRationalIncomplete<'a>

Performs the * operation.

impl Mul<Complex> for Rational

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 Rational

type Output = MulOwnedRationalIncomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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 &'a Rational

type Output = MulRationalIncomplete<'a>

The resulting type after applying the * operator.

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

Performs the * operation.

impl MulFrom<Rational> for Complex

fn mul_from(&mut self, lhs: Rational)

Peforms the multiplication.

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

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

Peforms the multiplication.

impl MulFromRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the multiplication.

impl<'a> MulFromRound<&'a Rational> 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 Rational,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the multiplication.

impl Div<Rational> for Complex

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Complex

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = DivRationalIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: &'a Rational) -> DivRationalIncomplete<'a>

Performs the / operation.

impl DivAssign<Rational> for Complex

fn div_assign(&mut self, rhs: Rational)

Performs the /= operation.

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

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

Performs the /= operation.

impl DivAssignRound<Rational> for Complex

type Round = (Round, Round)

The rounding method.

type Ordering = (Ordering, Ordering)

The direction from rounding.

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

Performs the division.

impl<'a> DivAssignRound<&'a Rational> 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 Rational,
    round: (Round, Round)
) -> (Ordering, Ordering)

Performs the division.

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

type Output = DivOwnedRationalIncomplete<'a>

The resulting type after applying the / operator.

fn div(self, rhs: Rational) -> DivOwnedRationalIncomplete<'a>

Performs the / operation.

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 = ShlU32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> ShlU32Incomplete<'b>

Performs the << operation.

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

type Output = ShlU32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &'t u32) -> ShlU32Incomplete<'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 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 = ShrU32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> ShrU32Incomplete<'b>

Performs the >> operation.

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

type Output = ShrU32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t u32) -> ShrU32Incomplete<'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 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 = PowU32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: u32) -> PowU32Incomplete<'b>

Performs the power operation.

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

type Output = PowU32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t u32) -> PowU32Incomplete<'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 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 = ShlI32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> ShlI32Incomplete<'b>

Performs the << operation.

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

type Output = ShlI32Incomplete<'b>

The resulting type after applying the << operator.

fn shl(self, rhs: &'t i32) -> ShlI32Incomplete<'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 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 = ShrI32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> ShrI32Incomplete<'b>

Performs the >> operation.

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

type Output = ShrI32Incomplete<'b>

The resulting type after applying the >> operator.

fn shr(self, rhs: &'t i32) -> ShrI32Incomplete<'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 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 = PowI32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: i32) -> PowI32Incomplete<'b>

Performs the power operation.

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

type Output = PowI32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t i32) -> PowI32Incomplete<'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 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 = PowF64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: f64) -> PowF64Incomplete<'b>

Performs the power operation.

impl<'t, 'b> Pow<&'t f64> for &'b Complex

type Output = PowF64Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t f64) -> PowF64Incomplete<'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 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 = PowF32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: f32) -> PowF32Incomplete<'b>

Performs the power operation.

impl<'t, 'b> Pow<&'t f32> for &'b Complex

type Output = PowF32Incomplete<'b>

The resulting type after the power operation.

fn pow(self, rhs: &'t f32) -> PowF32Incomplete<'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 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 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> 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<Complex> for Integer

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<Complex> for (Integer, Integer)

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, 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<Complex> for (Integer, Rational)

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, 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<Complex> for (Integer, Float)

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, 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<Complex> for (Integer, i8)

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, 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<Complex> for (Integer, i16)

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, 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<Complex> for (Integer, i32)

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, 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<Complex> for (Integer, i64)

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, 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<Complex> for (Integer, isize)

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, 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<Complex> for (Integer, u8)

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, 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<Complex> for (Integer, u16)

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, 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<Complex> for (Integer, u32)

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, 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<Complex> for (Integer, u64)

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, 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<Complex> for (Integer, usize)

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, 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<Complex> for (Integer, f32)

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, 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<Complex> for (Integer, f64)

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<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<Complex> for Rational

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<(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<Complex> for (Rational, Integer)

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<(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<Complex> for (Rational, Rational)

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<(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<Complex> for (Rational, Float)

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<(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<Complex> for (Rational, i8)

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<(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<Complex> for (Rational, i16)

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<(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<Complex> for (Rational, i32)

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<(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<Complex> for (Rational, i64)

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<(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<Complex> for (Rational, isize)

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<(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<Complex> for (Rational, u8)

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<(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<Complex> for (Rational, u16)

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<(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<Complex> for (Rational, u32)

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<(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<Complex> for (Rational, u64)

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<(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<Complex> for (Rational, usize)

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<(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<Complex> for (Rational, f32)

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<(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<Complex> for (Rational, f64)

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<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<Complex> for Float

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<(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<Complex> for (Float, Integer)

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<(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<Complex> for (Float, Rational)

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<(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<Complex> for (Float, Float)

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<(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<Complex> for (Float, i8)

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<(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<Complex> for (Float, i16)

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<(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<Complex> for (Float, i32)

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<(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<Complex> for (Float, i64)

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<(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<Complex> for (Float, isize)

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<(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<Complex> for (Float, u8)

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<(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<Complex> for (Float, u16)

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<(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<Complex> for (Float, u32)

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<(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<Complex> for (Float, u64)

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<(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<Complex> for (Float, usize)

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<(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<Complex> for (Float, f32)

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<(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<Complex> for (Float, f64)

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<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<Complex> for i8

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<(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<Complex> for (i8, Integer)

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<(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<Complex> for (i8, Rational)

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<(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<Complex> for (i8, Float)

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<(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<Complex> for (i8, i8)

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<(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<Complex> for (i8, i16)

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<(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<Complex> for (i8, i32)

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<(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<Complex> for (i8, i64)

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<(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<Complex> for (i8, isize)

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<(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<Complex> for (i8, u8)

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<(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<Complex> for (i8, u16)

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<(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<Complex> for (i8, u32)

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<(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<Complex> for (i8, u64)

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<(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<Complex> for (i8, usize)

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<(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<Complex> for (i8, f32)

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<(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<Complex> for (i8, f64)

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<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<Complex> for i16

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<(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<Complex> for (i16, Integer)

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<(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<Complex> for (i16, Rational)

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<(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<Complex> for (i16, Float)

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<(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<Complex> for (i16, i8)

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<(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<Complex> for (i16, i16)

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<(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<Complex> for (i16, i32)

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<(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<Complex> for (i16, i64)

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<(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<Complex> for (i16, isize)

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<(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<Complex> for (i16, u8)

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<(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<Complex> for (i16, u16)

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<(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<Complex> for (i16, u32)

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<(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<Complex> for (i16, u64)

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<(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<Complex> for (i16, usize)

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<(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<Complex> for (i16, f32)

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<(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<Complex> for (i16, f64)

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<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<Complex> for i32

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<(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<Complex> for (i32, Integer)

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<(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<Complex> for (i32, Rational)

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<(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<Complex> for (i32, Float)

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<(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<Complex> for (i32, i8)

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<(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<Complex> for (i32, i16)

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<(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<Complex> for (i32, i32)

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<(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<Complex> for (i32, i64)

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<(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<Complex> for (i32, isize)

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<(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<Complex> for (i32, u8)

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<(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<Complex> for (i32, u16)

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<(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<Complex> for (i32, u32)

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<(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<Complex> for (i32, u64)

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<(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<Complex> for (i32, usize)

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<(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<Complex> for (i32, f32)

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<(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<Complex> for (i32, f64)

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<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<Complex> for i64

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<(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<Complex> for (i64, Integer)

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<(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<Complex> for (i64, Rational)

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<(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<Complex> for (i64, Float)

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<(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<Complex> for (i64, i8)

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<(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<Complex> for (i64, i16)

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<(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<Complex> for (i64, i32)

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<(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<Complex> for (i64, i64)

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<(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<Complex> for (i64, isize)

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<(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<Complex> for (i64, u8)

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<(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<Complex> for (i64, u16)

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<(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<Complex> for (i64, u32)

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<(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<Complex> for (i64, u64)

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<(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<Complex> for (i64, usize)

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<(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<Complex> for (i64, f32)

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<(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<Complex> for (i64, f64)

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<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<Complex> for isize

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<(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<Complex> for (isize, Integer)

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<(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<Complex> for (isize, Rational)

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<(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<Complex> for (isize, Float)

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<(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<Complex> for (isize, i8)

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<(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<Complex> for (isize, i16)

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<(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<Complex> for (isize, i32)

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<(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<Complex> for (isize, i64)

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<(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<Complex> for (isize, isize)

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<(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<Complex> for (isize, u8)

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<(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<Complex> for (isize, u16)

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<(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<Complex> for (isize, u32)

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<(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<Complex> for (isize, u64)

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<(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<Complex> for (isize, usize)

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<(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<Complex> for (isize, f32)

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<(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<Complex> for (isize, f64)

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<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<Complex> for u8

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<(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<Complex> for (u8, Integer)

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<(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<Complex> for (u8, Rational)

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<(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<Complex> for (u8, Float)

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<(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<Complex> for (u8, i8)

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<(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<Complex> for (u8, i16)

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<(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<Complex> for (u8, i32)

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<(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<Complex> for (u8, i64)

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<(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<Complex> for (u8, isize)

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<(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<Complex> for (u8, u8)

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<(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<Complex> for (u8, u16)

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<(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<Complex> for (u8, u32)

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<(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<Complex> for (u8, u64)

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<(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<Complex> for (u8, usize)

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<(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<Complex> for (u8, f32)

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<(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<Complex> for (u8, f64)

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<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<Complex> for u16

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<(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<Complex> for (u16, Integer)

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<(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<Complex> for (u16, Rational)

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<(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<Complex> for (u16, Float)

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<(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<Complex> for (u16, i8)

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<(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<Complex> for (u16, i16)

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<(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<Complex> for (u16, i32)

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<(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<Complex> for (u16, i64)

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<(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<Complex> for (u16, isize)

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<(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<Complex> for (u16, u8)

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<(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<Complex> for (u16, u16)

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<(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<Complex> for (u16, u32)

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<(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<Complex> for (u16, u64)

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<(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<Complex> for (u16, usize)

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<(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<Complex> for (u16, f32)

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<(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<Complex> for (u16, f64)

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<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<Complex> for u32

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<(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<Complex> for (u32, Integer)

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<(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<Complex> for (u32, Rational)

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<(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<Complex> for (u32, Float)

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<(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<Complex> for (u32, i8)

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<(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<Complex> for (u32, i16)

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<(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<Complex> for (u32, i32)

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<(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<Complex> for (u32, i64)

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<(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<Complex> for (u32, isize)

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<(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<Complex> for (u32, u8)

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<(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<Complex> for (u32, u16)

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<(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<Complex> for (u32, u32)

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<(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<Complex> for (u32, u64)

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<(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<Complex> for (u32, usize)

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<(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<Complex> for (u32, f32)

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<(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<Complex> for (u32, f64)

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<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<Complex> for u64

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<(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<Complex> for (u64, Integer)

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<(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<Complex> for (u64, Rational)

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<(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<Complex> for (u64, Float)

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<(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<Complex> for (u64, i8)

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<(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<Complex> for (u64, i16)

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<(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<Complex> for (u64, i32)

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<(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<Complex> for (u64, i64)

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<(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<Complex> for (u64, isize)

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<(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<Complex> for (u64, u8)

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<(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<Complex> for (u64, u16)

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<(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<Complex> for (u64, u32)

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<(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<Complex> for (u64, u64)

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<(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<Complex> for (u64, usize)

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<(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<Complex> for (u64, f32)

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<(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<Complex> for (u64, f64)

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<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<Complex> for usize

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<(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<Complex> for (usize, Integer)

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<(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<Complex> for (usize, Rational)

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<(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<Complex> for (usize, Float)

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<(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<Complex> for (usize, i8)

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<(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<Complex> for (usize, i16)

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<(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<Complex> for (usize, i32)

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<(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<Complex> for (usize, i64)

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<(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<Complex> for (usize, isize)

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<(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<Complex> for (usize, u8)

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<(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<Complex> for (usize, u16)

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<(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<Complex> for (usize, u32)

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<(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<Complex> for (usize, u64)

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<(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<Complex> for (usize, usize)

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<(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<Complex> for (usize, f32)

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<(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<Complex> for (usize, f64)

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<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<Complex> for f32

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<(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<Complex> for (f32, Integer)

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<(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<Complex> for (f32, Rational)

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<(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<Complex> for (f32, Float)

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<(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<Complex> for (f32, i8)

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<(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<Complex> for (f32, i16)

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<(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<Complex> for (f32, i32)

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<(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<Complex> for (f32, i64)

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<(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<Complex> for (f32, isize)

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<(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<Complex> for (f32, u8)

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<(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<Complex> for (f32, u16)

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<(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<Complex> for (f32, u32)

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<(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<Complex> for (f32, u64)

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<(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<Complex> for (f32, usize)

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<(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<Complex> for (f32, f32)

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<(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<Complex> for (f32, f64)

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<f64> for Complex

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

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

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

This method tests for !=.

impl PartialEq<Complex> for f64

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<(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<Complex> for (f64, Integer)

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<(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<Complex> for (f64, Rational)

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<(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<Complex> for (f64, Float)

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<(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<Complex> for (f64, i8)

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<(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<Complex> for (f64, i16)

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<(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<Complex> for (f64, i32)

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<(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<Complex> for (f64, i64)

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<(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<Complex> for (f64, isize)

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<(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<Complex> for (f64, u8)

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<(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<Complex> for (f64, u16)

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<(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<Complex> for (f64, u32)

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<(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<Complex> for (f64, u64)

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<(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<Complex> for (f64, usize)

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<(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<Complex> for (f64, f32)

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<(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<Complex> for (f64, f64)

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 From<Complex> for OrdComplex

fn from(src: Complex) -> Self

Performs the conversion.

impl From<OrdComplex> for Complex

fn from(src: OrdComplex) -> Self

Performs the conversion.

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 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 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