Struct rug::Complex
[−]
[src]
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.
There are two versions of most methods:
- The first rounds the returned or stored
Complex
number to the nearest representable value. - The second applies the specified rounding
methods for the real and imaginary
parts, and returns the rounding directions for both:
Ordering::Less
if the returned/stored part is less than the exact result,Ordering::Equal
if the returned/stored part is equal to the exact result,Ordering::Greater
if the returned/stored part is greater than the exact result,
Note on Round::AwayFromZero
For Complex
numbers, Round::AwayFromZero
is not
implemented, and trying to use it will panic.
Examples
use rug::{Assign, Complex, Float}; let c = Complex::with_val(53, (40, 30)); assert_eq!(format!("{:.3}", c), "(4.00e1 3.00e1)"); let mut f = Float::with_val(53, c.abs_ref()); assert_eq!(f, 50); f.assign(c.arg_ref()); assert_eq!(f, 0.75_f64.atan());
Operations on two borrowed Complex
numbers result in an
intermediate value that has to be assigned to a new Complex
value.
use rug::Complex; let a = Complex::with_val(53, (10.5, -11)); let b = Complex::with_val(53, (-1.25, -1.5)); let a_b_ref = &a + &b; let a_b = Complex::with_val(53, a_b_ref); assert_eq!(a_b, (9.25, -12.5));
As a special case, when an intermediate value is obtained from
multiplying two Complex
references, it can be added to or
subtracted from another Complex
(or reference). This will result
in a fused multiply-accumulate operation, with only one rounding
operation taking place.
use rug::Complex; let mut acc = Complex::with_val(53, (1000, 1000)); let m1 = Complex::with_val(53, (10, 0)); let m2 = Complex::with_val(53, (1, -1)); // (1000 + 1000i) - (10 + 0i) * (1 - i) = (990 + 1010i) acc -= &m1 * &m2; assert_eq!(acc, (990, 1010));
Methods
impl Complex
[src]
fn new<P: Prec>(prec: P) -> Complex
[src]
Create a new complex number with the specified precisions for the real and imaginary parts and with value 0.
Examples
use rug::Complex; let c1 = Complex::new(32); assert_eq!(c1.prec(), (32, 32)); assert_eq!(c1, 0); let c2 = Complex::new((32, 64)); assert_eq!(c2.prec(), (32, 64)); assert_eq!(c2, 0);
Panics
Panics if the precision is out of the allowed range.
fn with_val<P: Prec, T>(prec: P, val: T) -> Complex where
Complex: Assign<T>,
[src]
Complex: Assign<T>,
Create a new complex number with the specified precision and with the given value, rounding to the nearest.
Examples
use rug::Complex; let c1 = Complex::with_val(53, (1.3f64, -12)); assert_eq!(c1.prec(), (53, 53)); assert_eq!(c1, (1.3f64, -12)); let c2 = Complex::with_val(53, 42.0); assert_eq!(c2.prec(), (53, 53)); assert_eq!(c2, 42); assert_eq!(c2, (42, 0));
Panics
Panics if prec
is out of the allowed range.
fn with_val_round<P: Prec, T>(
prec: P,
val: T,
round: (Round, Round)
) -> (Complex, (Ordering, Ordering)) where
Complex: AssignRound<T, Round = (Round, Round), Ordering = (Ordering, Ordering)>,
[src]
prec: P,
val: T,
round: (Round, Round)
) -> (Complex, (Ordering, Ordering)) where
Complex: AssignRound<T, Round = (Round, Round), Ordering = (Ordering, Ordering)>,
Create a new floating-point number with the specified precision and with the given value, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let round = (Round::Down, Round::Up); let (c, dir) = Complex::with_val_round(4, (3.3, 2.3), round); // 3.3 is rounded down to 3.25, 2.3 is rounded up to 2.5 assert_eq!(c.prec(), (4, 4)); assert_eq!(c, (3.25, 2.5)); assert_eq!(dir, (Ordering::Less, Ordering::Greater));
Panics
Panics if prec
is out of the allowed range.
fn prec(&self) -> (u32, u32)
[src]
Returns the precision of the real and imaginary parts.
Examples
use rug::Complex; let r = Complex::new((24, 53)); assert_eq!(r.prec(), (24, 53));
fn set_prec<P: Prec>(&mut self, prec: P)
[src]
Sets the precision of the real and imaginary parts, rounding to the nearest.
Examples
use rug::Complex; let mut r = Complex::with_val(6, (4.875, 4.625)); assert_eq!(r, (4.875, 4.625)); r.set_prec(4); assert_eq!(r, (5.0, 4.5));
Panics
Panics if the precision is out of the allowed range.
fn set_prec_round<P: Prec>(
&mut self,
prec: P,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
prec: P,
round: (Round, Round)
) -> (Ordering, Ordering)
Sets the precision of the real and imaginary parts, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let mut r = Complex::with_val(6, (4.875, 4.625)); assert_eq!(r, (4.875, 4.625)); let dir = r.set_prec_round(4, (Round::Down, Round::Up)); assert_eq!(r, (4.5, 5.0)); assert_eq!(dir, (Ordering::Less, Ordering::Greater));
Panics
Panics if the precision is out of the allowed range.
fn from_str<P: Prec>(src: &str, prec: P) -> Result<Complex, ParseComplexError>
[src]
Parses a Complex
number with the specified precision,
rounding to the nearest.
Examples
use rug::Complex; let c = Complex::from_str("(12.5e2 2.5e-1)", 53).unwrap(); assert_eq!(*c.real(), 12.5e2); assert_eq!(*c.imag(), 2.5e-1); let bad = Complex::from_str("bad", 53); assert!(bad.is_err());
Errors
If the string is not correctly formatted, a
ParseComplexError
is returned.
fn from_str_round<P: Prec>(
src: &str,
prec: P,
round: (Round, Round)
) -> Result<(Complex, (Ordering, Ordering)), ParseComplexError>
[src]
src: &str,
prec: P,
round: (Round, Round)
) -> Result<(Complex, (Ordering, Ordering)), ParseComplexError>
Parses a Complex
number with the specified precision,
applying the specified rounding.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let round = (Round::Down, Round::Up); let res = Complex::from_str_round("(14.1 14.2)", 4, round); let (c, dir) = res.unwrap(); assert_eq!(*c.real(), 14); assert_eq!(*c.imag(), 15); assert_eq!(dir, (Ordering::Less, Ordering::Greater));
Errors
If the string is not correctly formatted, a
ParseComplexError
is returned.
fn from_str_radix<P: Prec>(
src: &str,
radix: i32,
prec: P
) -> Result<Complex, ParseComplexError>
[src]
src: &str,
radix: i32,
prec: P
) -> Result<Complex, ParseComplexError>
Parses a Complex
number with the specified radix and
precision, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::from_str_radix("f.f", 16, 53).unwrap(); assert_eq!(*c.real(), 15.9375); assert_eq!(*c.imag(), 0);
Errors
If the string is not correctly formatted, a
ParseComplexError
is returned.
Panics
Panics if radix
is less than 2 or greater than 36.
fn from_str_radix_round<P: Prec>(
src: &str,
radix: i32,
prec: P,
round: (Round, Round)
) -> Result<(Complex, (Ordering, Ordering)), ParseComplexError>
[src]
src: &str,
radix: i32,
prec: P,
round: (Round, Round)
) -> Result<(Complex, (Ordering, Ordering)), ParseComplexError>
Parses a Complex
number with the specified radix and
precision, applying the specified rounding.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let round = (Round::Nearest, Round::Nearest); let res = Complex::from_str_radix_round("(c.c c.1)", 16, 4, round); let (c, dir) = res.unwrap(); assert_eq!(*c.real(), 13); assert_eq!(*c.imag(), 12); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
Errors
If the string is not correctly formatted, a
ParseComplexError
is returned.
Panics
Panics if radix
is less than 2 or greater than 36.
fn valid_str_radix(
src: &str,
radix: i32
) -> Result<ValidComplex, ParseComplexError>
[src]
src: &str,
radix: i32
) -> Result<ValidComplex, ParseComplexError>
Checks if a Complex
number can be parsed.
If this method does not return an error, neither will any
other function that parses a Complex
number. If this method
returns an error, the other functions will return the same
error.
Examples
use rug::Complex; let valid1 = Complex::valid_str_radix("(1.2e-1 2.3e+2)", 4); let c1 = Complex::with_val(53, valid1.unwrap()); assert_eq!(c1, (0.25 * (1.0 + 0.25 * 2.0), 4.0 * (3.0 + 4.0 * 2.0))); let valid2 = Complex::valid_str_radix("(12 yz)", 36); let c2 = Complex::with_val(53, valid2.unwrap()); assert_eq!(c2, (2.0 + 36.0 * 1.0, 35.0 + 36.0 * 34.0)); let invalid = Complex::valid_str_radix("(0, 0)", 3); let invalid_f = Complex::from_str_radix("(0, 0)", 3, 53); assert_eq!(invalid.unwrap_err(), invalid_f.unwrap_err());
Errors
If the string is not correctly formatted, a
ParseComplexError
is returned.
Panics
Panics if radix
is less than 2 or greater than 36.
fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
[src]
Returns a string representation of the value for the specified
radix
rounding to the nearest.
The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Examples
use rug::Complex; let c1 = Complex::with_val(53, 0); assert_eq!(c1.to_string_radix(10, None), "(0.0 0.0)"); let c2 = Complex::with_val(12, (15, 5)); assert_eq!(c2.to_string_radix(16, None), "(f.000 5.000)"); let c3 = Complex::with_val(53, (10, -4)); assert_eq!(c3.to_string_radix(10, Some(3)), "(1.00e1 -4.00)"); assert_eq!(c3.to_string_radix(5, Some(3)), "(2.00e1 -4.00)");
Panics
Panics if radix
is less than 2 or greater than 36.
fn to_string_radix_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: (Round, Round)
) -> String
[src]
&self,
radix: i32,
num_digits: Option<usize>,
round: (Round, Round)
) -> String
Returns a string representation of the value for the specified
radix
applying the specified rounding method.
The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Examples
use rug::Complex; use rug::float::Round; let c = Complex::with_val(10, 10.4); let down = (Round::Down, Round::Down); let nearest = (Round::Nearest, Round::Nearest); let up = (Round::Up, Round::Up); let nd = c.to_string_radix_round(10, None, down); assert_eq!(nd, "(1.0406e1 0.0)"); let nu = c.to_string_radix_round(10, None, up); assert_eq!(nu, "(1.0407e1 0.0)"); let sd = c.to_string_radix_round(10, Some(2), down); assert_eq!(sd, "(1.0e1 0.0)"); let sn = c.to_string_radix_round(10, Some(2), nearest); assert_eq!(sn, "(1.0e1 0.0)"); let su = c.to_string_radix_round(10, Some(2), up); assert_eq!(su, "(1.1e1 0.0)");
Panics
Panics if radix
is less than 2 or greater than 36.
fn assign_str(&mut self, src: &str) -> Result<(), ParseComplexError>
[src]
Parses a Complex
number from a string, rounding to the
nearest.
Examples
use rug::Complex; let mut c = Complex::new(53); c.assign_str("(12.5e2 2.5e-1)").unwrap(); assert_eq!(*c.real(), 12.5e2); assert_eq!(*c.imag(), 2.5e-1); let ret = c.assign_str("bad"); assert!(ret.is_err());
Errors
If the string is not correctly formatted, a
ParseComplexError
is returned.
fn assign_str_round(
&mut self,
src: &str,
round: (Round, Round)
) -> Result<(Ordering, Ordering), ParseComplexError>
[src]
&mut self,
src: &str,
round: (Round, Round)
) -> Result<(Ordering, Ordering), ParseComplexError>
Parses a Complex
number from a string, applying the specified
rounding.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let mut c = Complex::new((4, 4)); let round = (Round::Down, Round::Up); let dir = c.assign_str_round("(14.1 14.2)", round).unwrap(); assert_eq!(*c.real(), 14); assert_eq!(*c.imag(), 15); assert_eq!(dir, (Ordering::Less, Ordering::Greater));
Errors
If the string is not correctly formatted, a
ParseComplexError
is returned.
fn assign_str_radix(
&mut self,
src: &str,
radix: i32
) -> Result<(), ParseComplexError>
[src]
&mut self,
src: &str,
radix: i32
) -> Result<(), ParseComplexError>
Parses a Complex
number from a string with the specified
radix, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::new(53); c.assign_str_radix("f.f", 16).unwrap(); assert_eq!(*c.real(), 15.9375); assert_eq!(*c.imag(), 0);
Errors
If the string is not correctly formatted, a
ParseComplexError
is returned.
Panics
Panics if radix
is less than 2 or greater than 36.
fn assign_str_radix_round(
&mut self,
src: &str,
radix: i32,
round: (Round, Round)
) -> Result<(Ordering, Ordering), ParseComplexError>
[src]
&mut self,
src: &str,
radix: i32,
round: (Round, Round)
) -> Result<(Ordering, Ordering), ParseComplexError>
Parses a Complex
number from a string with the specified
radix, applying the specified rounding.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let mut c = Complex::new((4, 4)); let round = (Round::Nearest, Round::Nearest); let dir = c.assign_str_radix_round("(c.c c.1)", 16, round).unwrap(); assert_eq!(*c.real(), 13); assert_eq!(*c.imag(), 12); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
Errors
If the string is not correctly formatted, a
ParseComplexError
is returned.
Panics
Panics if radix
is less than 2 or greater than 36.
fn real(&self) -> &Float
[src]
Borrows the real part as a Float
.
Examples
use rug::Complex; let c = Complex::with_val(53, (12.5, -20.75)); assert_eq!(*c.real(), 12.5)
fn imag(&self) -> &Float
[src]
Borrows the imaginary part as a Float
.
Examples
use rug::Complex; let c = Complex::with_val(53, (12.5, -20.75)); assert_eq!(*c.imag(), -20.75)
fn mut_real(&mut self) -> &mut Float
[src]
Borrows the real part mutably.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (12.5, -20.75)); assert_eq!(c, (12.5, -20.75)); *c.mut_real() /= 2; assert_eq!(c, (6.25, -20.75));
fn mut_imag(&mut self) -> &mut Float
[src]
Borrows the imaginary part mutably.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (12.5, -20.75)); assert_eq!(c, (12.5, -20.75)); *c.mut_imag() *= 4; assert_eq!(c, (12.5, -83));
fn as_real_imag(&self) -> (&Float, &Float)
[src]
Borrows the real and imaginary parts.
Examples
use rug::Complex; let c = Complex::with_val(53, (12.5, -20.75)); assert_eq!(c, (12.5, -20.75)); let (re, im) = c.as_real_imag(); assert_eq!(*re, 12.5); assert_eq!(*im, -20.75);
fn as_mut_real_imag(&mut self) -> (&mut Float, &mut Float)
[src]
Borrows the real and imaginary parts mutably.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (12.5, -20.75)); { let (real, imag) = c.as_mut_real_imag(); *real /= 2; *imag *= 4; // borrow ends here } assert_eq!(c, (6.25, -83));
fn into_real_imag(self) -> (Float, Float)
[src]
Consumes and converts the value into real and imaginary
Float
values.
This function reuses the allocated memory and does not allocate any new memory.
use rug::Complex; let c = Complex::with_val(53, (12.5, -20.75)); let (real, imag) = c.into_real_imag(); assert_eq!(real, 12.5); assert_eq!(imag, -20.75);
fn as_neg(&self) -> BorrowComplex
[src]
Borrows a negated copy of the Complex
number.
The returned object implements Deref
with a Complex
target. This method performs a shallow copy and negates it,
and negation does not change the allocated data.
Examples
use rug::Complex; let c = Complex::with_val(53, (4.2, -2.3)); let neg_c = c.as_neg(); assert_eq!(*neg_c, (-4.2, 2.3)); // methods taking &self can be used on the returned object let reneg_c = neg_c.as_neg(); assert_eq!(*reneg_c, (4.2, -2.3)); assert_eq!(*reneg_c, c);
fn as_conj(&self) -> BorrowComplex
[src]
Borrows a conjugate copy of the Complex
number.
The returned object implements Deref
with a Complex
target. This method performs a shallow copy and negates its
imaginary part, and negation does not change the allocated
data.
Examples
use rug::Complex; let c = Complex::with_val(53, (4.2, -2.3)); let conj_c = c.as_conj(); assert_eq!(*conj_c, (4.2, 2.3)); // methods taking &self can be used on the returned object let reconj_c = conj_c.as_conj(); assert_eq!(*reconj_c, (4.2, -2.3)); assert_eq!(*reconj_c, c);
fn as_mul_i(&self, negative: bool) -> BorrowComplex
[src]
Borrows a rotated copy of the Complex
number.
The returned object implements Deref
with a Complex
target. This method operates by performing some shallow
copying; unlike the mul_i
method and
friends, this method swaps the precision of the real and
imaginary parts if they have unequal precisions.
Examples
use rug::Complex; let c = Complex::with_val(53, (4.2, -2.3)); let mul_i_c = c.as_mul_i(false); assert_eq!(*mul_i_c, (2.3, 4.2)); // methods taking &self can be used on the returned object let mul_ii_c = mul_i_c.as_mul_i(false); assert_eq!(*mul_ii_c, (-4.2, 2.3)); let mul_1_c = mul_i_c.as_mul_i(true); assert_eq!(*mul_1_c, (4.2, -2.3)); assert_eq!(*mul_1_c, c);
fn as_ord(&self) -> &OrdComplex
[src]
Borrows the Complex
as an ordered complex number of type
OrdComplex
.
Examples
use rug::Complex; use rug::float::Special; use std::cmp::Ordering; let nan_c = Complex::with_val(53, (Special::Nan, Special::Nan)); let nan = nan_c.as_ord(); assert_eq!(nan.cmp(nan), Ordering::Equal); let one_neg0_c = Complex::with_val(53, (1, Special::NegZero)); let one_neg0 = one_neg0_c.as_ord(); let one_pos0_c = Complex::with_val(53, (1, Special::Zero)); let one_pos0 = one_pos0_c.as_ord(); assert_eq!(one_neg0.cmp(one_pos0), Ordering::Less); let zero_inf_s = (Special::Zero, Special::Infinity); let zero_inf_c = Complex::with_val(53, zero_inf_s); let zero_inf = zero_inf_c.as_ord(); assert_eq!(one_pos0.cmp(zero_inf), Ordering::Greater);
fn proj(self) -> Complex
[src]
Computes a projection onto the Riemann sphere, rounding to the nearest.
If no parts of the number are infinite, the result is unchanged. If any part is infinite, the real part of the result is set to +∞ and the imaginary part of the result is set to 0 with the same sign as the imaginary part of the input.
Examples
use rug::Complex; use std::f64; let c1 = Complex::with_val(53, (1.5, 2.5)); let proj1 = c1.proj(); assert_eq!(proj1, (1.5, 2.5)); let c2 = Complex::with_val(53, (f64::NAN, f64::NEG_INFINITY)); let proj2 = c2.proj(); assert_eq!(proj2, (f64::INFINITY, 0.0)); // imaginary was negative, so now it is minus zero assert!(proj2.imag().is_sign_negative());
fn proj_mut(&mut self)
[src]
Computes a projection onto the Riemann sphere, rounding to the nearest.
If no parts of the number are infinite, the result is unchanged. If any part is infinite, the real part of the result is set to +∞ and the imaginary part of the result is set to 0 with the same sign as the imaginary part of the input.
Examples
use rug::Complex; use std::f64; let mut c1 = Complex::with_val(53, (1.5, 2.5)); c1.proj_mut(); assert_eq!(c1, (1.5, 2.5)); let mut c2 = Complex::with_val(53, (f64::NAN, f64::NEG_INFINITY)); c2.proj_mut(); assert_eq!(c2, (f64::INFINITY, 0.0)); // imaginary was negative, so now it is minus zero assert!(c2.imag().is_sign_negative());
fn proj_ref(&self) -> ProjRef
[src]
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.
Examples
use rug::Complex; use std::f64; let c1 = Complex::with_val(53, (f64::INFINITY, 50)); let proj1 = Complex::with_val(53, c1.proj_ref()); assert_eq!(proj1, (f64::INFINITY, 0.0)); let c2 = Complex::with_val(53, (f64::NAN, f64::NEG_INFINITY)); let proj2 = Complex::with_val(53, c2.proj_ref()); assert_eq!(proj2, (f64::INFINITY, 0.0)); // imaginary was negative, so now it is minus zero assert!(proj2.imag().is_sign_negative());
fn square(self) -> Complex
[src]
Computes the square, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, -2)); // (1 - 2i) squared is (-3 - 4i) let square = c.square(); assert_eq!(square, (-3, -4));
fn square_mut(&mut self)
[src]
Computes the square, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, -2)); // (1 - 2i) squared is (-3 - 4i) c.square_mut(); assert_eq!(c, (-3, -4));
fn square_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the square, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let mut c = Complex::with_val(4, (1.25, 1.25)); // (1.25 + 1.25i) squared is (0 + 3.125i). // With 4 bits of precision, 3.125 is rounded down to 3. let dir = c.square_round((Round::Down, Round::Down)); assert_eq!(c, (0, 3)); assert_eq!(dir, (Ordering::Equal, Ordering::Less));
fn square_ref(&self) -> SquareRef
[src]
Computes the square.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let c = Complex::with_val(53, (1.25, 1.25)); // (1.25 + 1.25i) squared is (0 + 3.125i). let r = c.square_ref(); // With 4 bits of precision, 3.125 is rounded down to 3. let round = (Round::Down, Round::Down); let (square, dir) = Complex::with_val_round(4, r, round); assert_eq!(square, (0, 3)); assert_eq!(dir, (Ordering::Equal, Ordering::Less));
fn sqrt(self) -> Complex
[src]
Computes the square root, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (-1, 0)); // square root of (-1 + 0i) is (0 + i) let sqrt = c.sqrt(); assert_eq!(sqrt, (0, 1));
fn sqrt_mut(&mut self)
[src]
Computes the square root, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (-1, 0)); // square root of (-1 + 0i) is (0 + i) c.sqrt_mut(); assert_eq!(c, (0, 1));
fn sqrt_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the square root, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let mut c = Complex::with_val(4, (2, 2.25)); // Square root of (2 + 2.25i) is (1.5828 + 0.7108i). // Nearest with 4 bits of precision: (1.625 + 0.6875i) let dir = c.sqrt_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (1.625, 0.6875)); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
fn sqrt_ref(&self) -> SqrtRef
[src]
Computes the square root.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let c = Complex::with_val(53, (2, 2.25)); // Square root of (2 + 2.25i) is (1.5828 + 0.7108i). let r = c.sqrt_ref(); // Nearest with 4 bits of precision: (1.625 + 0.6875i) let nearest = (Round::Nearest, Round::Nearest); let (sqrt, dir) = Complex::with_val_round(4, r, nearest); assert_eq!(sqrt, (1.625, 0.6875)); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
fn conj(self) -> Complex
[src]
Computes the complex conjugate.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, 2.5)); let conj = c.conj(); assert_eq!(conj, (1.5, -2.5));
fn conj_mut(&mut self)
[src]
Computes the complex conjugate.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1.5, 2.5)); c.conj_mut(); assert_eq!(c, (1.5, -2.5));
fn conj_ref(&self) -> ConjugateRef
[src]
Computes the complex conjugate.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, 2.5)); let conj = Complex::with_val(53, c.conj_ref()); assert_eq!(conj, (1.5, -2.5));
fn abs(self) -> Float
[src]
Computes the absolute value and returns it as a
Float
with the precision of the real
part.
Examples
use rug::Complex; let c = Complex::with_val(53, (30, 40)); let f = c.abs(); assert_eq!(f, 50);
fn abs_mut(&mut self)
[src]
Computes the absolute value.
The real part is set to the absolute value and the imaginary part is set to zero.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (30, 40)); c.abs_mut(); assert_eq!(c, (50, 0));
fn abs_ref(&self) -> AbsRef
[src]
Computes the absolute value.
Examples
use rug::{Complex, Float}; let c = Complex::with_val(53, (30, 40)); let f = Float::with_val(53, c.abs_ref()); assert_eq!(f, 50);
fn arg(self) -> Float
[src]
Computes the argument, rounding to the nearest.
The argument is returned as a Float
with the precision of the real part.
Examples
use rug::Complex; let c = Complex::with_val(53, (4, 3)); let f = c.arg(); assert_eq!(f, 0.75_f64.atan());
Special values are handled like atan2 in IEEE 754-2008.
use rug::{Assign, Complex, Float}; use rug::float::Special; use std::f64; // f has precision 53, just like f64, so PI constants match. let mut arg = Float::new(53); let mut zero = Complex::new(53); zero.assign((Special::Zero, Special::Zero)); arg.assign(zero.arg_ref()); assert!(arg.is_zero() && arg.is_sign_positive()); zero.assign((Special::Zero, Special::NegZero)); arg.assign(zero.arg_ref()); assert!(arg.is_zero() && arg.is_sign_negative()); zero.assign((Special::NegZero, Special::Zero)); arg.assign(zero.arg_ref()); assert_eq!(arg, f64::consts::PI); zero.assign((Special::NegZero, Special::NegZero)); arg.assign(zero.arg_ref()); assert_eq!(arg, -f64::consts::PI);
fn arg_mut(&mut self)
[src]
Computes the argument, rounding to the nearest.
The real part is set to the argument and the imaginary part is set to zero.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (40, 30)); c.arg_mut(); assert_eq!(c, (0.75_f64.atan(), 0));
fn arg_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the argument, applying the specified rounding method.
The real part is set to the argument and the imaginary part is set to zero.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // use only 4 bits of precision let mut c = Complex::with_val(4, (3, 4)); // arg(3 + 4i) = 0.9316. // 0.9316 rounded to the nearest is 0.9375. let dir = c.arg_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.9375, 0)); assert_eq!(dir, (Ordering::Greater, Ordering::Equal));
fn arg_ref(&self) -> ArgRef
[src]
Computes the argument.
Examples
use rug::{Assign, Complex, Float}; use std::f64; // f has precision 53, just like f64, so PI constants match. let mut arg = Float::new(53); let c_pos = Complex::with_val(53, 1); arg.assign(c_pos.arg_ref()); assert!(arg.is_zero()); let c_neg = Complex::with_val(53, -1.3); arg.assign(c_neg.arg_ref()); assert_eq!(arg, f64::consts::PI); let c_pi_4 = Complex::with_val(53, (1.333, 1.333)); arg.assign(c_pi_4.arg_ref()); assert_eq!(arg, f64::consts::FRAC_PI_4);
fn mul_i(self, negative: bool) -> Complex
[src]
Multiplies the complex number by ±i, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (13, 24)); let rot1 = c.mul_i(false); assert_eq!(rot1, (-24, 13)); let rot2 = rot1.mul_i(false); assert_eq!(rot2, (-13, -24)); let rot2_less1 = rot2.mul_i(true); assert_eq!(rot2_less1, (-24, 13));
fn mul_i_mut(&mut self, negative: bool)
[src]
Multiplies the complex number by ±i, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (13, 24)); c.mul_i_mut(false); assert_eq!(c, (-24, 13)); c.mul_i_mut(false); assert_eq!(c, (-13, -24)); c.mul_i_mut(true); assert_eq!(c, (-24, 13));
fn mul_i_round(
&mut self,
negative: bool,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
negative: bool,
round: (Round, Round)
) -> (Ordering, Ordering)
Multiplies the complex number by ±i, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // only 4 bits of precision for imaginary part let mut c = Complex::with_val((53, 4), (127, 15)); assert_eq!(c, (127, 15)); let dir = c.mul_i_round(false, (Round::Down, Round::Down)); assert_eq!(c, (-15, 120)); assert_eq!(dir, (Ordering::Equal, Ordering::Less)); let dir = c.mul_i_round(true, (Round::Down, Round::Down)); assert_eq!(c, (120, 15)); assert_eq!(dir, (Ordering::Equal, Ordering::Equal));
fn mul_i_ref(&self, negative: bool) -> MulIRef
[src]
Multiplies the complex number by ±i.
Examples
use rug::Complex; let c = Complex::with_val(53, (13, 24)); let rotated = Complex::with_val(53, c.mul_i_ref(false)); assert_eq!(rotated, (-24, 13));
fn recip(self) -> Complex
[src]
Computes the reciprocal, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); // 1/(1 + i) = (0.5 - 0.5i) let recip = c.recip(); assert_eq!(recip, (0.5, -0.5));
fn recip_mut(&mut self)
[src]
Computes the reciprocal, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); // 1/(1 + i) = (0.5 - 0.5i) c.recip_mut(); assert_eq!(c, (0.5, -0.5));
fn recip_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the reciprocal, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let mut c = Complex::with_val(4, (1, 2)); // 1/(1 + 2i) = (0.2 - 0.4i), binary (0.00110011..., -0.01100110...) // 4 bits of precision: (0.001101, -0.01101) = (13/64, -13/32) let dir = c.recip_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (13.0/64.0, -13.0/32.0)); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
fn recip_ref(&self) -> RecipRef
[src]
Computes the reciprocal.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); // 1/(1 + i) = (0.5 - 0.5i) let recip = Complex::with_val(53, c.recip_ref()); assert_eq!(recip, (0.5, -0.5));
fn norm(self) -> Float
[src]
Computes the norm, that is the square of the absolute value, rounding it to the nearest.
The norm is returned as a Float
with
the precision of the real part.
Examples
use rug::Complex; let c = Complex::with_val(53, (3, 4)); let f = c.norm(); assert_eq!(f, 25);
fn norm_mut(&mut self)
[src]
Computes the norm, that is the square of the absolute value, rounding to the nearest.
The real part is set to the norm and the imaginary part is set to zero.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (3, 4)); c.norm_mut(); assert_eq!(c, (25, 0));
fn norm_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the norm, that is the square of the absolute value, applying the specified rounding method.
The real part is set to the norm and the imaginary part is set to zero.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // use only 4 bits of precision let mut c = Complex::with_val(4, (3, 4)); // 25 rounded up using 4 bits is 26 let dir = c.norm_round((Round::Up, Round::Up)); assert_eq!(c, (26, 0)); assert_eq!(dir, (Ordering::Greater, Ordering::Equal));
fn norm_ref(&self) -> NormRef
[src]
Computes the norm, that is the square of the absolute value.
Examples
use rug::{Complex, Float}; let c = Complex::with_val(53, (3, 4)); let f = Float::with_val(53, c.norm_ref()); assert_eq!(f, 25);
fn ln(self) -> Complex
[src]
Computes the natural logarithm, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, -0.5)); let ln = c.ln(); let expected = Complex::with_val(53, (0.4581, -0.3218)); assert!((ln - expected).abs() < 0.001);
fn ln_mut(&mut self)
[src]
Computes the natural logarithm, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1.5, -0.5)); c.ln_mut(); let expected = Complex::with_val(53, (0.4581, -0.3218)); assert!((c - expected).abs() < 0.001);
fn ln_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the natural logarithm, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1.5, -0.5)); // ln(1.5 - 0.5i) = (0.4581 - 0.3218i) // using 4 significant bits: (0.46875 - 0.3125i) let dir = c.ln_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.46875, -0.3125)); assert_eq!(dir, (Ordering::Greater, Ordering::Greater));
fn ln_ref(&self) -> LnRef
[src]
Computes the natural logarithm;
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, -0.5)); let ln = Complex::with_val(53, c.ln_ref()); let expected = Complex::with_val(53, (0.4581, -0.3218)); assert!((ln - expected).abs() < 0.001);
fn log10(self) -> Complex
[src]
Computes the logarithm to base 10, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, -0.5)); let log10 = c.log10(); let expected = Complex::with_val(53, (0.1990, -0.1397)); assert!((log10 - expected).abs() < 0.001);
fn log10_mut(&mut self)
[src]
Computes the logarithm to base 10, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1.5, -0.5)); c.log10_mut(); let expected = Complex::with_val(53, (0.1990, -0.1397)); assert!((c - expected).abs() < 0.001);
fn log10_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the logarithm to base 10, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1.5, -0.5)); // log10(1.5 - 0.5i) = (0.1990 - 0.1397i) // using 4 significant bits: (0.203125 - 0.140625i) let dir = c.log10_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.203125, -0.140625)); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
fn log10_ref(&self) -> Log10Ref
[src]
Computes the logarithm to base 10.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, -0.5)); let log10 = Complex::with_val(53, c.log10_ref()); let expected = Complex::with_val(53, (0.1990, -0.1397)); assert!((log10 - expected).abs() < 0.001);
fn exp(self) -> Complex
[src]
Computes the exponential, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (0.5, -0.75)); let exp = c.exp(); let expected = Complex::with_val(53, (1.2064, -1.1238)); assert!((exp - expected).abs() < 0.001);
fn exp_mut(&mut self)
[src]
Computes the exponential, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (0.5, -0.75)); c.exp_mut(); let expected = Complex::with_val(53, (1.2064, -1.1238)); assert!((c - expected).abs() < 0.001);
fn exp_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the exponential, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (0.5, -0.75)); // exp(0.5 - 0.75i) = (1.2064 - 1.1238i) // using 4 significant bits: (1.25 - 1.125) let dir = c.exp_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (1.25, -1.125)); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
fn exp_ref(&self) -> ExpRef
[src]
Computes the exponential.
Examples
use rug::Complex; let c = Complex::with_val(53, (0.5, -0.75)); let exp = Complex::with_val(53, c.exp_ref()); let expected = Complex::with_val(53, (1.2064, -1.1238)); assert!((exp - expected).abs() < 0.001);
fn sin(self) -> Complex
[src]
Computes the sine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let sin = c.sin(); let expected = Complex::with_val(53, (1.2985, 0.6350)); assert!((sin - expected).abs() < 0.001);
fn sin_mut(&mut self)
[src]
Computes the sine, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.sin_mut(); let expected = Complex::with_val(53, (1.2985, 0.6350)); assert!((c - expected).abs() < 0.001);
fn sin_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the sine, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // sin(1 + i) = (1.2985 + 0.6350i) // using 4 significant bits: (1.25 + 0.625i) let dir = c.sin_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (1.25, 0.625)); assert_eq!(dir, (Ordering::Less, Ordering::Less));
fn sin_ref(&self) -> SinRef
[src]
Computes the sine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let sin = Complex::with_val(53, c.sin_ref()); let expected = Complex::with_val(53, (1.2985, 0.6350)); assert!((sin - expected).abs() < 0.001);
fn cos(self) -> Complex
[src]
Computes the cosine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let cos = c.cos(); let expected = Complex::with_val(53, (0.8337, -0.9889)); assert!((cos - expected).abs() < 0.001);
fn cos_mut(&mut self)
[src]
Computes the cosine, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.cos_mut(); let expected = Complex::with_val(53, (0.8337, -0.9889)); assert!((c - expected).abs() < 0.001);
fn cos_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the cosine, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // cos(1 + i) = (0.8337 - 0.9889i) // using 4 significant bits: (0.8125 - i) let dir = c.cos_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.8125, -1)); assert_eq!(dir, (Ordering::Less, Ordering::Less));
fn cos_ref(&self) -> CosRef
[src]
Computes the cosine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let cos = Complex::with_val(53, c.cos_ref()); let expected = Complex::with_val(53, (0.8337, -0.9889)); assert!((cos - expected).abs() < 0.001);
fn sin_cos(self, cos: Complex) -> (Complex, Complex)
[src]
Computes the sine and cosine of self
, rounding to the
nearest.
The sine keeps the precision of self
while the cosine
keeps the precision of cos
.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let (sin, cos) = c.sin_cos(Complex::new(53)); let expected_sin = Complex::with_val(53, (1.2985, 0.6350)); let expected_cos = Complex::with_val(53, (0.8337, -0.9889)); assert!((sin - expected_sin).abs() < 0.001); assert!((cos - expected_cos).abs() < 0.001);
fn sin_cos_mut(&mut self, cos: &mut Complex)
[src]
Computes the sine and cosine of self
, rounding to the
nearest.
The sine is stored in self
and keeps its precision,
while the cosine is stored in cos
keeping its precision.
Examples
use rug::Complex; let mut sin = Complex::with_val(53, (1, 1)); let mut cos = Complex::new(53); sin.sin_cos_mut(&mut cos); let expected_sin = Complex::with_val(53, (1.2985, 0.6350)); let expected_cos = Complex::with_val(53, (0.8337, -0.9889)); assert!((sin - expected_sin).abs() < 0.001); assert!((cos - expected_cos).abs() < 0.001);
fn sin_cos_round(
&mut self,
cos: &mut Complex,
round: (Round, Round)
) -> ((Ordering, Ordering), (Ordering, Ordering))
[src]
&mut self,
cos: &mut Complex,
round: (Round, Round)
) -> ((Ordering, Ordering), (Ordering, Ordering))
Computes the sine and cosine of self
, applying the
specified rounding methods.
The sine is stored in self
and keeps its precision,
while the cosine is stored in cos
keeping its precision.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut sin = Complex::with_val(4, (1, 1)); let mut cos = Complex::new(4); // sin(1 + i) = (1.2985 + 0.6350) // using 4 significant bits: (1.25 + 0.625i) // cos(1 + i) = (0.8337 - 0.9889i) // using 4 significant bits: (0.8125 - i) let (dir_sin, dir_cos) = sin.sin_cos_round(&mut cos, (Round::Nearest, Round::Nearest)); assert_eq!(sin, (1.25, 0.625)); assert_eq!(dir_sin, (Ordering::Less, Ordering::Less)); assert_eq!(cos, (0.8125, -1)); assert_eq!(dir_cos, (Ordering::Less, Ordering::Less));
fn sin_cos_ref(&self) -> SinCosRef
[src]
Computes the sine and cosine.
Examples
use rug::{Assign, AssignRound, Complex}; use rug::float::Round; use std::cmp::Ordering; let phase = Complex::with_val(53, (1, 1)); let sin_cos = phase.sin_cos_ref(); let (mut sin, mut cos) = (Complex::new(53), Complex::new(53)); (&mut sin, &mut cos).assign(sin_cos); let expected_sin = Complex::with_val(53, (1.2985, 0.6350)); let expected_cos = Complex::with_val(53, (0.8337, -0.9889)); assert!((sin - expected_sin).abs() < 0.001); assert!((cos - expected_cos).abs() < 0.001); // using 4 significant bits: sin = (1.25 + 0.625i) // using 4 significant bits: cos = (0.8125 - i) let (mut sin_4, mut cos_4) = (Complex::new(4), Complex::new(4)); let (dir_sin, dir_cos) = (&mut sin_4, &mut cos_4) .assign_round(sin_cos, (Round::Nearest, Round::Nearest)); assert_eq!(sin_4, (1.25, 0.625)); assert_eq!(dir_sin, (Ordering::Less, Ordering::Less)); assert_eq!(cos_4, (0.8125, -1)); assert_eq!(dir_cos, (Ordering::Less, Ordering::Less));
fn tan(self) -> Complex
[src]
Computes the tangent, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let tan = c.tan(); let expected = Complex::with_val(53, (0.2718, 1.0839)); assert!((tan - expected).abs() < 0.001);
fn tan_mut(&mut self)
[src]
Computes the tangent, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.tan_mut(); let expected = Complex::with_val(53, (0.2718, 1.0839)); assert!((c - expected).abs() < 0.001);
fn tan_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the tangent, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // tan(1 + i) = (0.2718 + 1.0839) // using 4 significant bits: (0.28125 + 1.125i) let dir = c.tan_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.28125, 1.125)); assert_eq!(dir, (Ordering::Greater, Ordering::Greater));
fn tan_ref(&self) -> TanRef
[src]
Computes the tangent.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let tan = Complex::with_val(53, c.tan_ref()); let expected = Complex::with_val(53, (0.2718, 1.0839)); assert!((tan - expected).abs() < 0.001);
fn sinh(self) -> Complex
[src]
Computes the hyperbolic sine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let sinh = c.sinh(); let expected = Complex::with_val(53, (0.6350, 1.2985)); assert!((sinh - expected).abs() < 0.001);
fn sinh_mut(&mut self)
[src]
Computes the hyperbolic sine, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.sinh_mut(); let expected = Complex::with_val(53, (0.6350, 1.2985)); assert!((c - expected).abs() < 0.001);
fn sinh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the hyperbolic sine, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // sinh(1 + i) = (0.6350 + 1.2985i) // using 4 significant bits: (0.625 + 1.25i) let dir = c.sinh_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.625, 1.25)); assert_eq!(dir, (Ordering::Less, Ordering::Less));
fn sinh_ref(&self) -> SinhRef
[src]
Computes the hyperbolic sine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let sinh = Complex::with_val(53, c.sinh_ref()); let expected = Complex::with_val(53, (0.6350, 1.2985)); assert!((sinh - expected).abs() < 0.001);
fn cosh(self) -> Complex
[src]
Computes the hyperbolic cosine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let cosh = c.cosh(); let expected = Complex::with_val(53, (0.8337, 0.9889)); assert!((cosh - expected).abs() < 0.001);
fn cosh_mut(&mut self)
[src]
Computes the hyperbolic cosine, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.cosh_mut(); let expected = Complex::with_val(53, (0.8337, 0.9889)); assert!((c - expected).abs() < 0.001);
fn cosh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the hyperbolic cosine, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // cosh(1 + i) = (0.8337 + 0.9889) // using 4 significant bits: (0.8125 + i) let dir = c.cosh_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.8125, 1)); assert_eq!(dir, (Ordering::Less, Ordering::Greater));
fn cosh_ref(&self) -> CoshRef
[src]
Computes the hyperbolic cosine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let cosh = Complex::with_val(53, c.cosh_ref()); let expected = Complex::with_val(53, (0.8337, 0.9889)); assert!((cosh - expected).abs() < 0.001);
fn tanh(self) -> Complex
[src]
Computes the hyperbolic tangent, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let tanh = c.tanh(); let expected = Complex::with_val(53, (1.0839, 0.2718)); assert!((tanh - expected).abs() < 0.001);
fn tanh_mut(&mut self)
[src]
Computes the hyperbolic tangent, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.tanh_mut(); let expected = Complex::with_val(53, (1.0839, 0.2718)); assert!((c - expected).abs() < 0.001);
fn tanh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the hyperbolic tangent, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // tanh(1 + i) = (1.0839 + 0.2718i) // using 4 significant bits: (1.125 + 0.28125i) let dir = c.tanh_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (1.125, 0.28125)); assert_eq!(dir, (Ordering::Greater, Ordering::Greater));
fn tanh_ref(&self) -> TanhRef
[src]
Computes the hyperbolic tangent.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let tanh = Complex::with_val(53, c.tanh_ref()); let expected = Complex::with_val(53, (1.0839, 0.2718)); assert!((tanh - expected).abs() < 0.001);
fn asin(self) -> Complex
[src]
Computes the inverse sine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let asin = c.asin(); let expected = Complex::with_val(53, (0.6662, 1.0613)); assert!((asin - expected).abs() < 0.001);
fn asin_mut(&mut self)
[src]
Computes the inverse sine, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.asin_mut(); let expected = Complex::with_val(53, (0.6662, 1.0613)); assert!((c - expected).abs() < 0.001);
fn asin_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the inverse sine, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // asin(1 + i) = (0.6662 + 1.0613i) // using 4 significant bits: (0.6875 + i) let dir = c.asin_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.6875, 1)); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
fn asin_ref(&self) -> AsinRef
[src]
Computes the inverse sine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let asin = Complex::with_val(53, c.asin_ref()); let expected = Complex::with_val(53, (0.6662, 1.0613)); assert!((asin - expected).abs() < 0.001);
fn acos(self) -> Complex
[src]
Computes the inverse cosine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let acos = c.acos(); let expected = Complex::with_val(53, (0.9046, -1.0613)); assert!((acos - expected).abs() < 0.001);
fn acos_mut(&mut self)
[src]
Computes the inverse cosine, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.acos_mut(); let expected = Complex::with_val(53, (0.9046, -1.0613)); assert!((c - expected).abs() < 0.001);
fn acos_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the inverse cosine, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // acos(1 + i) = (0.9046 - 1.0613i) // using 4 significant bits: (0.875 - i) let dir = c.acos_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.875, -1)); assert_eq!(dir, (Ordering::Less, Ordering::Greater));
fn acos_ref(&self) -> AcosRef
[src]
Computes the inverse cosine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let acos = Complex::with_val(53, c.acos_ref()); let expected = Complex::with_val(53, (0.9046, -1.0613)); assert!((acos - expected).abs() < 0.001);
fn atan(self) -> Complex
[src]
Computes the inverse tangent, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let atan = c.atan(); let expected = Complex::with_val(53, (1.0172, 0.4024)); assert!((atan - expected).abs() < 0.001);
fn atan_mut(&mut self)
[src]
Computes the inverse tangent, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.atan_mut(); let expected = Complex::with_val(53, (1.0172, 0.4024)); assert!((c - expected).abs() < 0.001);
fn atan_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the inverse tangent, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // atan(1 + i) = (1.0172 + 0.4024i) // using 4 significant bits: (1 + 0.40625i) let dir = c.atan_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (1, 0.40625)); assert_eq!(dir, (Ordering::Less, Ordering::Greater));
fn atan_ref(&self) -> AtanRef
[src]
Computes the inverse tangent.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let atan = Complex::with_val(53, c.atan_ref()); let expected = Complex::with_val(53, (1.0172, 0.4024)); assert!((atan - expected).abs() < 0.001);
fn asinh(self) -> Complex
[src]
Computes the inverse hyperbolic sine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let asinh = c.asinh(); let expected = Complex::with_val(53, (1.0613, 0.6662)); assert!((asinh - expected).abs() < 0.001);
fn asinh_mut(&mut self)
[src]
Computes the inverse hyperbolic sine, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.asinh_mut(); let expected = Complex::with_val(53, (1.0613, 0.6662)); assert!((c - expected).abs() < 0.001);
fn asinh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the inverse hyperbolic sine, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // asinh(1 + i) = (1.0613 + 0.6662i) // using 4 significant bits: (1 + 0.6875i) let dir = c.asinh_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (1, 0.6875)); assert_eq!(dir, (Ordering::Less, Ordering::Greater));
fn asinh_ref(&self) -> AsinhRef
[src]
Computes the inverse hyperboic sine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let asinh = Complex::with_val(53, c.asinh_ref()); let expected = Complex::with_val(53, (1.0613, 0.6662)); assert!((asinh - expected).abs() < 0.001);
fn acosh(self) -> Complex
[src]
Computes the inverse hyperbolic cosine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let acosh = c.acosh(); let expected = Complex::with_val(53, (1.0613, 0.9046)); assert!((acosh - expected).abs() < 0.001);
fn acosh_mut(&mut self)
[src]
Computes the inverse hyperbolic cosine, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.acosh_mut(); let expected = Complex::with_val(53, (1.0613, 0.9046)); assert!((c - expected).abs() < 0.001);
fn acosh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the inverse hyperbolic cosine, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // acosh(1 + i) = (1.0613 + 0.9046i) // using 4 significant bits: (1 + 0.875i) let dir = c.acosh_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (1, 0.875)); assert_eq!(dir, (Ordering::Less, Ordering::Less));
fn acosh_ref(&self) -> AcoshRef
[src]
Computes the inverse hyperbolic cosine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let acosh = Complex::with_val(53, c.acosh_ref()); let expected = Complex::with_val(53, (1.0613, 0.9046)); assert!((acosh - expected).abs() < 0.001);
fn atanh(self) -> Complex
[src]
Computes the inverse hyperbolic tangent, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let atanh = c.atanh(); let expected = Complex::with_val(53, (0.4024, 1.0172)); assert!((atanh - expected).abs() < 0.001);
fn atanh_mut(&mut self)
[src]
Computes the inverse hyperbolic tangent, rounding to the nearest.
Examples
use rug::Complex; let mut c = Complex::with_val(53, (1, 1)); c.atanh_mut(); let expected = Complex::with_val(53, (0.4024, 1.0172)); assert!((c - expected).abs() < 0.001);
fn atanh_round(&mut self, round: (Round, Round)) -> (Ordering, Ordering)
[src]
Computes the inverse hyperbolic tangent, applying the specified rounding method.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; // Use only 4 bits of precision to show rounding. let mut c = Complex::with_val(4, (1, 1)); // atanh(1 + i) = (0.4024 + 1.0172i) // using 4 significant bits: (0.40625 + i) let dir = c.atanh_round((Round::Nearest, Round::Nearest)); assert_eq!(c, (0.40625, 1)); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
fn atanh_ref(&self) -> AtanhRef
[src]
Computes the inverse hyperbolic tangent.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let atanh = Complex::with_val(53, c.atanh_ref()); let expected = Complex::with_val(53, (0.4024, 1.0172)); assert!((atanh - expected).abs() < 0.001);
fn assign_random_bits(&mut self, rng: &mut RandState) -> Result<(), ()>
[src]
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 < 2p for each part, where 2p is two raised to the power of the precision, and then dividing the integer by 2p. 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.
Examples
use rug::Complex; use rug::rand::RandState; let mut rand = RandState::new(); let mut c = Complex::new(2); c.assign_random_bits(&mut rand).unwrap(); let (re, im) = c.into_real_imag(); assert!(re == 0.0 || re == 0.25 || re == 0.5 || re == 0.75); assert!(im == 0.0 || im == 0.25 || im == 0.5 || im == 0.75); println!("0.0 <= {} < 1.0", re); println!("0.0 <= {} < 1.0", im);
Errors
In all the normal cases, the result will be exact. However, if
the precision is very large, and the generated random number
is very small, this may require an exponent smaller than
float::exp_min()
; in this case, the
number is set to Nan and an error is returned. This would most
likely be a programming error.
fn assign_random_cont(&mut self, rng: &mut RandState)
[src]
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 eual to one. This is
equivalent to calling
assign_random_cont_round(rng, (Round::Nearest, Round::Nearest))
.
Examples
use rug::Complex; use rug::rand::RandState; let mut rand = RandState::new(); let mut c = Complex::new(2); c.assign_random_cont(&mut rand); let (re, im) = c.into_real_imag(); // The significand is either 0b10 or 0b11 // 10 11 assert!(re == 1.0 || re == 0.75 || re == 0.5 || re == 0.375 || re == 0.25 || re <= 0.1875); assert!(im == 1.0 || im == 0.75 || im == 0.5 || im == 0.375 || im == 0.25 || im <= 0.1875);
fn assign_random_cont_round(
&mut self,
rng: &mut RandState,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
rng: &mut RandState,
round: (Round, Round)
) -> (Ordering, Ordering)
Generates a random complex number with both the real and imaginary parts in the continous range 0 ≤ x < 1, and applies the specified rounding method.
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.
Examples
use rug::Complex; use rug::float::Round; use rug::rand::RandState; use std::cmp::Ordering; let mut rand = RandState::new(); let mut c = Complex::new(2); let round = (Round::Down, Round::Down); let dir = c.assign_random_cont_round(&mut rand, round); // We cannot have an exact part without rounding. assert_eq!(dir, (Ordering::Less, Ordering::Less)); let (re, im) = c.into_real_imag(); // The significand is either 0b11 or 0b10 // 11 10 assert!(re == 0.75 || re == 0.5 || re == 0.375 || re == 0.25 || re <= 0.1875); assert!(im == 0.75 || im == 0.5 || im == 0.375 || im == 0.25 || im <= 0.1875);
Trait Implementations
impl Clone for Complex
[src]
fn clone(&self) -> Complex
[src]
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Complex)
[src]
Performs copy-assignment from source
. Read more
impl Default for Complex
[src]
impl Drop for Complex
[src]
impl From<(Float, Float)> for Complex
[src]
impl From<OrdComplex> for Complex
[src]
fn from(ord: OrdComplex) -> Complex
[src]
Performs the conversion.
impl Display for Complex
[src]
fn fmt(&self, f: &mut Formatter) -> Result
[src]
Formats the value using the given formatter. Read more
impl Debug for Complex
[src]
impl LowerExp for Complex
[src]
impl UpperExp for Complex
[src]
impl Binary for Complex
[src]
impl Octal for Complex
[src]
impl LowerHex for Complex
[src]
impl UpperHex for Complex
[src]
impl<T> Assign<T> for Complex where
Complex: AssignRound<T, Round = (Round, Round), Ordering = (Ordering, Ordering)>,
[src]
Complex: AssignRound<T, Round = (Round, Round), Ordering = (Ordering, Ordering)>,
impl AssignRound<Complex> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<&'a Complex> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: &Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: &Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<&'a Integer> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: &'a Integer,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: &'a Integer,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<&'a Rational> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: &'a Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: &'a Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<&'a Float> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<Integer> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: Integer,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: Integer,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<Rational> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: Rational,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<Float> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<Special> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: Special,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: Special,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<Constant> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: Constant,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: Constant,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<i32> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<i64> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: i64,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: i64,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<u32> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<u64> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: u64,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: u64,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<f32> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: f32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: f32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AssignRound<f64> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: f64,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: f64,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<T, U> AssignRound<(T, U)> for Complex where
Float: AssignRound<T, Round = Round, Ordering = Ordering>,
Float: AssignRound<U, Round = Round, Ordering = Ordering>,
[src]
Float: AssignRound<T, Round = Round, Ordering = Ordering>,
Float: AssignRound<U, Round = Round, Ordering = Ordering>,
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
other: (T, U),
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
other: (T, U),
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<ProjRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: ProjRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: ProjRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<SquareRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SquareRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SquareRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<SqrtRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SqrtRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SqrtRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<ConjugateRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: ConjugateRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: ConjugateRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<MulIRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: MulIRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: MulIRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<RecipRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: RecipRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: RecipRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<LnRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: LnRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: LnRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<Log10Ref<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: Log10Ref<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: Log10Ref<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<ExpRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: ExpRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: ExpRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<SinRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SinRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SinRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<CosRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: CosRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: CosRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<TanRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: TanRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: TanRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<SinhRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SinhRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SinhRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<CoshRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: CoshRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: CoshRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<TanhRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: TanhRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: TanhRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<AsinRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AsinRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AsinRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<AcosRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AcosRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AcosRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<AtanRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AtanRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AtanRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<AsinhRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AsinhRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AsinhRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<AcoshRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AcoshRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AcoshRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<AtanhRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AtanhRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AtanhRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Neg for Complex
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn neg(self) -> Complex
[src]
Performs the unary -
operation.
impl NegAssign for Complex
[src]
fn neg_assign(&mut self)
[src]
Peforms the negation. Read more
impl<'a> Neg for &'a Complex
[src]
type Output = NegRef<'a>
The resulting type after applying the -
operator.
fn neg(self) -> NegRef<'a>
[src]
Performs the unary -
operation.
impl<'a> AssignRound<NegRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: NegRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: NegRef<'a>,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Add<Complex> for Complex
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex
[src]
Performs the +
operation.
impl<'a> Add<&'a Complex> for Complex
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Complex) -> Complex
[src]
Performs the +
operation.
impl AddAssign<Complex> for Complex
[src]
fn add_assign(&mut self, rhs: Complex)
[src]
Performs the +=
operation.
impl<'a> AddAssign<&'a Complex> for Complex
[src]
fn add_assign(&mut self, rhs: &'a Complex)
[src]
Performs the +=
operation.
impl AddAssignRound<Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> AddAssignRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> Add<&'a Complex> for &'a Complex
[src]
type Output = AddRef<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Complex) -> AddRef<'a>
[src]
Performs the +
operation.
impl<'a> AssignRound<AddRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AddRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AddRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Add<Complex> for &'a Complex
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Complex) -> Complex
[src]
Performs the +
operation.
impl AddFrom<Complex> for Complex
[src]
impl<'a> AddFrom<&'a Complex> for Complex
[src]
impl<'a> AddFromRound<Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> AddFromRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl Sub<Complex> for Complex
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex
[src]
Performs the -
operation.
impl<'a> Sub<&'a Complex> for Complex
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Complex) -> Complex
[src]
Performs the -
operation.
impl SubAssign<Complex> for Complex
[src]
fn sub_assign(&mut self, rhs: Complex)
[src]
Performs the -=
operation.
impl<'a> SubAssign<&'a Complex> for Complex
[src]
fn sub_assign(&mut self, rhs: &'a Complex)
[src]
Performs the -=
operation.
impl SubAssignRound<Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubAssignRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> Sub<&'a Complex> for &'a Complex
[src]
type Output = SubRef<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Complex) -> SubRef<'a>
[src]
Performs the -
operation.
impl<'a> AssignRound<SubRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Sub<Complex> for &'a Complex
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Complex) -> Complex
[src]
Performs the -
operation.
impl SubFrom<Complex> for Complex
[src]
impl<'a> SubFrom<&'a Complex> for Complex
[src]
impl<'a> SubFromRound<Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubFromRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl Mul<Complex> for Complex
[src]
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex
[src]
Performs the *
operation.
impl<'a> Mul<&'a Complex> for Complex
[src]
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Complex) -> Complex
[src]
Performs the *
operation.
impl MulAssign<Complex> for Complex
[src]
fn mul_assign(&mut self, rhs: Complex)
[src]
Performs the *=
operation.
impl<'a> MulAssign<&'a Complex> for Complex
[src]
fn mul_assign(&mut self, rhs: &'a Complex)
[src]
Performs the *=
operation.
impl MulAssignRound<Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> MulAssignRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> Mul<&'a Complex> for &'a Complex
[src]
type Output = MulRef<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Complex) -> MulRef<'a>
[src]
Performs the *
operation.
impl<'a> AssignRound<MulRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Mul<Complex> for &'a Complex
[src]
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Complex) -> Complex
[src]
Performs the *
operation.
impl MulFrom<Complex> for Complex
[src]
impl<'a> MulFrom<&'a Complex> for Complex
[src]
impl<'a> MulFromRound<Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> MulFromRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl Div<Complex> for Complex
[src]
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: Complex) -> Complex
[src]
Performs the /
operation.
impl<'a> Div<&'a Complex> for Complex
[src]
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Complex) -> Complex
[src]
Performs the /
operation.
impl DivAssign<Complex> for Complex
[src]
fn div_assign(&mut self, rhs: Complex)
[src]
Performs the /=
operation.
impl<'a> DivAssign<&'a Complex> for Complex
[src]
fn div_assign(&mut self, rhs: &'a Complex)
[src]
Performs the /=
operation.
impl DivAssignRound<Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> DivAssignRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> Div<&'a Complex> for &'a Complex
[src]
type Output = DivRef<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Complex) -> DivRef<'a>
[src]
Performs the /
operation.
impl<'a> AssignRound<DivRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: DivRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: DivRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Div<Complex> for &'a Complex
[src]
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: Complex) -> Complex
[src]
Performs the /
operation.
impl DivFrom<Complex> for Complex
[src]
impl<'a> DivFrom<&'a Complex> for Complex
[src]
impl<'a> DivFromRound<Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> DivFromRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl Pow<Complex> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: Complex) -> Complex
[src]
Performs the power operation. Read more
impl<'a> Pow<&'a Complex> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: &'a Complex) -> Complex
[src]
Performs the power operation. Read more
impl PowAssign<Complex> for Complex
[src]
fn pow_assign(&mut self, rhs: Complex)
[src]
Peforms the power operation. Read more
impl<'a> PowAssign<&'a Complex> for Complex
[src]
fn pow_assign(&mut self, rhs: &'a Complex)
[src]
Peforms the power operation. Read more
impl PowAssignRound<Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> PowAssignRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> Pow<&'a Complex> for &'a Complex
[src]
type Output = PowRef<'a>
The resulting type after the power operation.
fn pow(self, rhs: &'a Complex) -> PowRef<'a>
[src]
Performs the power operation. Read more
impl<'a> AssignRound<PowRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: PowRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: PowRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Pow<Complex> for &'a Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: Complex) -> Complex
[src]
Performs the power operation. Read more
impl PowFrom<Complex> for Complex
[src]
impl<'a> PowFrom<&'a Complex> for Complex
[src]
impl<'a> PowFromRound<Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> PowFromRound<&'a Complex> for Complex
[src]
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)
[src]
&mut self,
lhs: &'a Complex,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl Add<Float> for Complex
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> Complex
[src]
Performs the +
operation.
impl<'a> Add<&'a Float> for Complex
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> Complex
[src]
Performs the +
operation.
impl AddAssign<Float> for Complex
[src]
fn add_assign(&mut self, rhs: Float)
[src]
Performs the +=
operation.
impl<'a> AddAssign<&'a Float> for Complex
[src]
fn add_assign(&mut self, rhs: &'a Float)
[src]
Performs the +=
operation.
impl AddAssignRound<Float> for Complex
[src]
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)
[src]
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> AddAssignRound<&'a Float> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> Add<&'a Float> for &'a Complex
[src]
type Output = AddRefFloat<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: &'a Float) -> AddRefFloat<'a>
[src]
Performs the +
operation.
impl<'a> AssignRound<AddRefFloat<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AddRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AddRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Add<Float> for &'a Complex
[src]
type Output = AddRefFloatOwn<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: Float) -> AddRefFloatOwn<'a>
[src]
Performs the +
operation.
impl<'a> AssignRound<AddRefFloatOwn<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AddRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AddRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AddFrom<Float> for Complex
[src]
impl<'a> AddFrom<&'a Float> for Complex
[src]
impl AddFromRound<Float> for Complex
[src]
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)
[src]
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> AddFromRound<&'a Float> for Complex
[src]
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)
[src]
&mut self,
lhs: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl Sub<Float> for Complex
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> Complex
[src]
Performs the -
operation.
impl<'a> Sub<&'a Float> for Complex
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> Complex
[src]
Performs the -
operation.
impl SubAssign<Float> for Complex
[src]
fn sub_assign(&mut self, rhs: Float)
[src]
Performs the -=
operation.
impl<'a> SubAssign<&'a Float> for Complex
[src]
fn sub_assign(&mut self, rhs: &'a Float)
[src]
Performs the -=
operation.
impl SubAssignRound<Float> for Complex
[src]
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)
[src]
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubAssignRound<&'a Float> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> Sub<&'a Float> for &'a Complex
[src]
type Output = SubRefFloat<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: &'a Float) -> SubRefFloat<'a>
[src]
Performs the -
operation.
impl<'a> AssignRound<SubRefFloat<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Sub<Float> for &'a Complex
[src]
type Output = SubFromRefFloat<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: Float) -> SubFromRefFloat<'a>
[src]
Performs the -
operation.
impl<'a> AssignRound<SubFromRefFloat<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubFromRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubFromRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl SubFrom<Float> for Complex
[src]
impl<'a> SubFrom<&'a Float> for Complex
[src]
impl SubFromRound<Float> for Complex
[src]
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)
[src]
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubFromRound<&'a Float> for Complex
[src]
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)
[src]
&mut self,
lhs: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> AssignRound<SubRefFloatOwn<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<SubFromRefFloatOwn<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubFromRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubFromRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Mul<Float> for Complex
[src]
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> Complex
[src]
Performs the *
operation.
impl<'a> Mul<&'a Float> for Complex
[src]
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> Complex
[src]
Performs the *
operation.
impl MulAssign<Float> for Complex
[src]
fn mul_assign(&mut self, rhs: Float)
[src]
Performs the *=
operation.
impl<'a> MulAssign<&'a Float> for Complex
[src]
fn mul_assign(&mut self, rhs: &'a Float)
[src]
Performs the *=
operation.
impl MulAssignRound<Float> for Complex
[src]
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)
[src]
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> MulAssignRound<&'a Float> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> Mul<&'a Float> for &'a Complex
[src]
type Output = MulRefFloat<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: &'a Float) -> MulRefFloat<'a>
[src]
Performs the *
operation.
impl<'a> AssignRound<MulRefFloat<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: MulRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: MulRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Mul<Float> for &'a Complex
[src]
type Output = MulRefFloatOwn<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: Float) -> MulRefFloatOwn<'a>
[src]
Performs the *
operation.
impl<'a> AssignRound<MulRefFloatOwn<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: MulRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: MulRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl MulFrom<Float> for Complex
[src]
impl<'a> MulFrom<&'a Float> for Complex
[src]
impl MulFromRound<Float> for Complex
[src]
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)
[src]
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl<'a> MulFromRound<&'a Float> for Complex
[src]
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)
[src]
&mut self,
lhs: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl Div<Float> for Complex
[src]
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> Complex
[src]
Performs the /
operation.
impl<'a> Div<&'a Float> for Complex
[src]
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> Complex
[src]
Performs the /
operation.
impl DivAssign<Float> for Complex
[src]
fn div_assign(&mut self, rhs: Float)
[src]
Performs the /=
operation.
impl<'a> DivAssign<&'a Float> for Complex
[src]
fn div_assign(&mut self, rhs: &'a Float)
[src]
Performs the /=
operation.
impl DivAssignRound<Float> for Complex
[src]
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)
[src]
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> DivAssignRound<&'a Float> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> Div<&'a Float> for &'a Complex
[src]
type Output = DivRefFloat<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: &'a Float) -> DivRefFloat<'a>
[src]
Performs the /
operation.
impl<'a> AssignRound<DivRefFloat<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: DivRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: DivRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Div<Float> for &'a Complex
[src]
type Output = DivFromRefFloat<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: Float) -> DivFromRefFloat<'a>
[src]
Performs the /
operation.
impl<'a> AssignRound<DivFromRefFloat<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: DivFromRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: DivFromRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl DivFrom<Float> for Complex
[src]
impl<'a> DivFrom<&'a Float> for Complex
[src]
impl DivFromRound<Float> for Complex
[src]
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)
[src]
&mut self,
lhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> DivFromRound<&'a Float> for Complex
[src]
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)
[src]
&mut self,
lhs: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> AssignRound<DivRefFloatOwn<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: DivRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: DivRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AssignRound<DivFromRefFloatOwn<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: DivFromRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: DivFromRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Pow<Float> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: Float) -> Complex
[src]
Performs the power operation. Read more
impl<'a> Pow<&'a Float> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: &'a Float) -> Complex
[src]
Performs the power operation. Read more
impl PowAssign<Float> for Complex
[src]
fn pow_assign(&mut self, rhs: Float)
[src]
Peforms the power operation. Read more
impl<'a> PowAssign<&'a Float> for Complex
[src]
fn pow_assign(&mut self, rhs: &'a Float)
[src]
Peforms the power operation. Read more
impl PowAssignRound<Float> for Complex
[src]
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)
[src]
&mut self,
rhs: Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> PowAssignRound<&'a Float> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Float,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> Pow<&'a Float> for &'a Complex
[src]
type Output = PowRefFloat<'a>
The resulting type after the power operation.
fn pow(self, rhs: &'a Float) -> PowRefFloat<'a>
[src]
Performs the power operation. Read more
impl<'a> AssignRound<PowRefFloat<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: PowRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: PowRefFloat,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Pow<Float> for &'a Complex
[src]
type Output = PowRefFloatOwn<'a>
The resulting type after the power operation.
fn pow(self, rhs: Float) -> PowRefFloatOwn<'a>
[src]
Performs the power operation. Read more
impl<'a> AssignRound<PowRefFloatOwn<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: PowRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: PowRefFloatOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Pow<Integer> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: Integer) -> Complex
[src]
Performs the power operation. Read more
impl<'a> Pow<&'a Integer> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: &'a Integer) -> Complex
[src]
Performs the power operation. Read more
impl PowAssign<Integer> for Complex
[src]
fn pow_assign(&mut self, rhs: Integer)
[src]
Peforms the power operation. Read more
impl<'a> PowAssign<&'a Integer> for Complex
[src]
fn pow_assign(&mut self, rhs: &'a Integer)
[src]
Peforms the power operation. Read more
impl PowAssignRound<Integer> for Complex
[src]
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)
[src]
&mut self,
rhs: Integer,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> PowAssignRound<&'a Integer> for Complex
[src]
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)
[src]
&mut self,
rhs: &'a Integer,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> Pow<&'a Integer> for &'a Complex
[src]
type Output = PowRefInteger<'a>
The resulting type after the power operation.
fn pow(self, rhs: &'a Integer) -> PowRefInteger<'a>
[src]
Performs the power operation. Read more
impl<'a> AssignRound<PowRefInteger<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: PowRefInteger,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: PowRefInteger,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> Pow<Integer> for &'a Complex
[src]
type Output = PowRefIntegerOwn<'a>
The resulting type after the power operation.
fn pow(self, rhs: Integer) -> PowRefIntegerOwn<'a>
[src]
Performs the power operation. Read more
impl<'a> AssignRound<PowRefIntegerOwn<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: PowRefIntegerOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: PowRefIntegerOwn,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Add<u32> for Complex
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: u32) -> Complex
[src]
Performs the +
operation.
impl AddAssign<u32> for Complex
[src]
fn add_assign(&mut self, rhs: u32)
[src]
Performs the +=
operation.
impl<'a> Add<u32> for &'a Complex
[src]
type Output = AddRefU32<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: u32) -> AddRefU32<'a>
[src]
Performs the +
operation.
impl<'a> AssignRound<AddRefU32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AddRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AddRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AddAssignRound<u32> for Complex
[src]
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)
[src]
&mut self,
rhs: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl AddFrom<u32> for Complex
[src]
impl<'a> AddFromRound<u32> for Complex
[src]
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)
[src]
&mut self,
lhs: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl Sub<u32> for Complex
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: u32) -> Complex
[src]
Performs the -
operation.
impl SubAssign<u32> for Complex
[src]
fn sub_assign(&mut self, rhs: u32)
[src]
Performs the -=
operation.
impl<'a> Sub<u32> for &'a Complex
[src]
type Output = SubRefU32<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: u32) -> SubRefU32<'a>
[src]
Performs the -
operation.
impl<'a> AssignRound<SubRefU32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl SubAssignRound<u32> for Complex
[src]
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)
[src]
&mut self,
rhs: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubFrom<u32> for Complex
[src]
impl SubFromRound<u32> for Complex
[src]
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)
[src]
&mut self,
lhs: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> AssignRound<SubFromRefU32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubFromRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubFromRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Mul<u32> for Complex
[src]
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> Complex
[src]
Performs the *
operation.
impl MulAssign<u32> for Complex
[src]
fn mul_assign(&mut self, rhs: u32)
[src]
Performs the *=
operation.
impl<'a> Mul<u32> for &'a Complex
[src]
type Output = MulRefU32<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: u32) -> MulRefU32<'a>
[src]
Performs the *
operation.
impl<'a> AssignRound<MulRefU32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: MulRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: MulRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl MulAssignRound<u32> for Complex
[src]
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)
[src]
&mut self,
rhs: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl MulFrom<u32> for Complex
[src]
impl<'a> MulFromRound<u32> for Complex
[src]
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)
[src]
&mut self,
lhs: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl Div<u32> for Complex
[src]
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> Complex
[src]
Performs the /
operation.
impl DivAssign<u32> for Complex
[src]
fn div_assign(&mut self, rhs: u32)
[src]
Performs the /=
operation.
impl<'a> Div<u32> for &'a Complex
[src]
type Output = DivRefU32<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: u32) -> DivRefU32<'a>
[src]
Performs the /
operation.
impl<'a> AssignRound<DivRefU32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: DivRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: DivRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl DivAssignRound<u32> for Complex
[src]
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)
[src]
&mut self,
rhs: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> DivFrom<u32> for Complex
[src]
impl DivFromRound<u32> for Complex
[src]
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)
[src]
&mut self,
lhs: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> AssignRound<DivFromRefU32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: DivFromRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: DivFromRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Add<i32> for Complex
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: i32) -> Complex
[src]
Performs the +
operation.
impl AddAssign<i32> for Complex
[src]
fn add_assign(&mut self, rhs: i32)
[src]
Performs the +=
operation.
impl<'a> Add<i32> for &'a Complex
[src]
type Output = AddRefI32<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: i32) -> AddRefI32<'a>
[src]
Performs the +
operation.
impl<'a> AssignRound<AddRefI32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AddRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AddRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl AddAssignRound<i32> for Complex
[src]
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)
[src]
&mut self,
rhs: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl AddFrom<i32> for Complex
[src]
impl<'a> AddFromRound<i32> for Complex
[src]
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)
[src]
&mut self,
lhs: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl Sub<i32> for Complex
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: i32) -> Complex
[src]
Performs the -
operation.
impl SubAssign<i32> for Complex
[src]
fn sub_assign(&mut self, rhs: i32)
[src]
Performs the -=
operation.
impl<'a> Sub<i32> for &'a Complex
[src]
type Output = SubRefI32<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: i32) -> SubRefI32<'a>
[src]
Performs the -
operation.
impl<'a> AssignRound<SubRefI32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl SubAssignRound<i32> for Complex
[src]
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)
[src]
&mut self,
rhs: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> SubFrom<i32> for Complex
[src]
impl SubFromRound<i32> for Complex
[src]
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)
[src]
&mut self,
lhs: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> AssignRound<SubFromRefI32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubFromRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubFromRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Mul<i32> for Complex
[src]
type Output = Complex
The resulting type after applying the *
operator.
fn mul(self, rhs: i32) -> Complex
[src]
Performs the *
operation.
impl MulAssign<i32> for Complex
[src]
fn mul_assign(&mut self, rhs: i32)
[src]
Performs the *=
operation.
impl<'a> Mul<i32> for &'a Complex
[src]
type Output = MulRefI32<'a>
The resulting type after applying the *
operator.
fn mul(self, rhs: i32) -> MulRefI32<'a>
[src]
Performs the *
operation.
impl<'a> AssignRound<MulRefI32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: MulRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: MulRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl MulAssignRound<i32> for Complex
[src]
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)
[src]
&mut self,
rhs: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl MulFrom<i32> for Complex
[src]
impl<'a> MulFromRound<i32> for Complex
[src]
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)
[src]
&mut self,
lhs: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the multiplication. Read more
impl Div<i32> for Complex
[src]
type Output = Complex
The resulting type after applying the /
operator.
fn div(self, rhs: i32) -> Complex
[src]
Performs the /
operation.
impl DivAssign<i32> for Complex
[src]
fn div_assign(&mut self, rhs: i32)
[src]
Performs the /=
operation.
impl<'a> Div<i32> for &'a Complex
[src]
type Output = DivRefI32<'a>
The resulting type after applying the /
operator.
fn div(self, rhs: i32) -> DivRefI32<'a>
[src]
Performs the /
operation.
impl<'a> AssignRound<DivRefI32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: DivRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: DivRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl DivAssignRound<i32> for Complex
[src]
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)
[src]
&mut self,
rhs: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> DivFrom<i32> for Complex
[src]
impl DivFromRound<i32> for Complex
[src]
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)
[src]
&mut self,
lhs: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the division. Read more
impl<'a> AssignRound<DivFromRefI32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: DivFromRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: DivFromRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Shl<u32> for Complex
[src]
type Output = Complex
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> Complex
[src]
Performs the <<
operation.
impl ShlAssign<u32> for Complex
[src]
fn shl_assign(&mut self, rhs: u32)
[src]
Performs the <<=
operation.
impl<'a> Shl<u32> for &'a Complex
[src]
type Output = ShlRefU32<'a>
The resulting type after applying the <<
operator.
fn shl(self, rhs: u32) -> ShlRefU32<'a>
[src]
Performs the <<
operation.
impl<'a> AssignRound<ShlRefU32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: ShlRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: ShlRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Shr<u32> for Complex
[src]
type Output = Complex
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> Complex
[src]
Performs the >>
operation.
impl ShrAssign<u32> for Complex
[src]
fn shr_assign(&mut self, rhs: u32)
[src]
Performs the >>=
operation.
impl<'a> Shr<u32> for &'a Complex
[src]
type Output = ShrRefU32<'a>
The resulting type after applying the >>
operator.
fn shr(self, rhs: u32) -> ShrRefU32<'a>
[src]
Performs the >>
operation.
impl<'a> AssignRound<ShrRefU32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: ShrRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: ShrRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Pow<u32> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: u32) -> Complex
[src]
Performs the power operation. Read more
impl PowAssign<u32> for Complex
[src]
fn pow_assign(&mut self, rhs: u32)
[src]
Peforms the power operation. Read more
impl<'a> Pow<u32> for &'a Complex
[src]
type Output = PowRefU32<'a>
The resulting type after the power operation.
fn pow(self, rhs: u32) -> PowRefU32<'a>
[src]
Performs the power operation. Read more
impl<'a> AssignRound<PowRefU32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: PowRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: PowRefU32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl PowAssignRound<u32> for Complex
[src]
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)
[src]
&mut self,
rhs: u32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl Shl<i32> for Complex
[src]
type Output = Complex
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> Complex
[src]
Performs the <<
operation.
impl ShlAssign<i32> for Complex
[src]
fn shl_assign(&mut self, rhs: i32)
[src]
Performs the <<=
operation.
impl<'a> Shl<i32> for &'a Complex
[src]
type Output = ShlRefI32<'a>
The resulting type after applying the <<
operator.
fn shl(self, rhs: i32) -> ShlRefI32<'a>
[src]
Performs the <<
operation.
impl<'a> AssignRound<ShlRefI32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: ShlRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: ShlRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Shr<i32> for Complex
[src]
type Output = Complex
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> Complex
[src]
Performs the >>
operation.
impl ShrAssign<i32> for Complex
[src]
fn shr_assign(&mut self, rhs: i32)
[src]
Performs the >>=
operation.
impl<'a> Shr<i32> for &'a Complex
[src]
type Output = ShrRefI32<'a>
The resulting type after applying the >>
operator.
fn shr(self, rhs: i32) -> ShrRefI32<'a>
[src]
Performs the >>
operation.
impl<'a> AssignRound<ShrRefI32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: ShrRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: ShrRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl Pow<i32> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: i32) -> Complex
[src]
Performs the power operation. Read more
impl PowAssign<i32> for Complex
[src]
fn pow_assign(&mut self, rhs: i32)
[src]
Peforms the power operation. Read more
impl<'a> Pow<i32> for &'a Complex
[src]
type Output = PowRefI32<'a>
The resulting type after the power operation.
fn pow(self, rhs: i32) -> PowRefI32<'a>
[src]
Performs the power operation. Read more
impl<'a> AssignRound<PowRefI32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: PowRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: PowRefI32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl PowAssignRound<i32> for Complex
[src]
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)
[src]
&mut self,
rhs: i32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl Pow<f64> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: f64) -> Complex
[src]
Performs the power operation. Read more
impl PowAssign<f64> for Complex
[src]
fn pow_assign(&mut self, rhs: f64)
[src]
Peforms the power operation. Read more
impl<'a> Pow<f64> for &'a Complex
[src]
type Output = PowRefF64<'a>
The resulting type after the power operation.
fn pow(self, rhs: f64) -> PowRefF64<'a>
[src]
Performs the power operation. Read more
impl<'a> AssignRound<PowRefF64<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: PowRefF64,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: PowRefF64,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl PowAssignRound<f64> for Complex
[src]
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)
[src]
&mut self,
rhs: f64,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl Pow<f32> for Complex
[src]
type Output = Complex
The resulting type after the power operation.
fn pow(self, rhs: f32) -> Complex
[src]
Performs the power operation. Read more
impl PowAssign<f32> for Complex
[src]
fn pow_assign(&mut self, rhs: f32)
[src]
Peforms the power operation. Read more
impl<'a> Pow<f32> for &'a Complex
[src]
type Output = PowRefF32<'a>
The resulting type after the power operation.
fn pow(self, rhs: f32) -> PowRefF32<'a>
[src]
Performs the power operation. Read more
impl<'a> AssignRound<PowRefF32<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: PowRefF32,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: PowRefF32,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl PowAssignRound<f32> for Complex
[src]
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)
[src]
&mut self,
rhs: f32,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the power operation. Read more
impl<'a> Add<MulRef<'a>> for Complex
[src]
type Output = Complex
The resulting type after applying the +
operator.
fn add(self, rhs: MulRef) -> Complex
[src]
Performs the +
operation.
impl<'a> AddAssign<MulRef<'a>> for Complex
[src]
fn add_assign(&mut self, rhs: MulRef)
[src]
Performs the +=
operation.
impl<'a> AddAssignRound<MulRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_assign_round(
&mut self,
rhs: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
rhs: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> Add<MulRef<'a>> for &'a Complex
[src]
type Output = AddMulRef<'a>
The resulting type after applying the +
operator.
fn add(self, rhs: MulRef<'a>) -> AddMulRef<'a>
[src]
Performs the +
operation.
impl<'a> AssignRound<AddMulRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: AddMulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: AddMulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> AddFrom<MulRef<'a>> for Complex
[src]
impl<'a> AddFromRound<MulRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn add_from_round(
&mut self,
lhs: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
lhs: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the addition. Read more
impl<'a> Sub<MulRef<'a>> for Complex
[src]
type Output = Complex
The resulting type after applying the -
operator.
fn sub(self, rhs: MulRef) -> Complex
[src]
Performs the -
operation.
impl<'a> SubAssign<MulRef<'a>> for Complex
[src]
fn sub_assign(&mut self, rhs: MulRef)
[src]
Performs the -=
operation.
impl<'a> SubAssignRound<MulRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_assign_round(
&mut self,
rhs: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
rhs: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> Sub<MulRef<'a>> for &'a Complex
[src]
type Output = SubMulRef<'a>
The resulting type after applying the -
operator.
fn sub(self, rhs: MulRef<'a>) -> SubMulRef<'a>
[src]
Performs the -
operation.
impl<'a> AssignRound<SubMulRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubMulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubMulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl<'a> SubFrom<MulRef<'a>> for Complex
[src]
impl<'a> SubFromRound<MulRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn sub_from_round(
&mut self,
lhs: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
lhs: MulRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Performs the subtraction. Read more
impl<'a> AssignRound<SubMulFromRef<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
src: SubMulFromRef,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
src: SubMulFromRef,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more
impl PartialEq for Complex
[src]
fn eq(&self, other: &Complex) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl<T, U> PartialEq<(T, U)> for Complex where
Float: PartialEq<T>,
Float: PartialEq<U>,
[src]
Float: PartialEq<T>,
Float: PartialEq<U>,
fn eq(&self, other: &(T, U)) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialEq<Integer> for Complex
[src]
fn eq(&self, other: &Integer) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialEq<Rational> for Complex
[src]
fn eq(&self, other: &Rational) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialEq<Float> for Complex
[src]
fn eq(&self, other: &Float) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialEq<u32> for Complex
[src]
fn eq(&self, other: &u32) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialEq<i32> for Complex
[src]
fn eq(&self, other: &i32) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialEq<f64> for Complex
[src]
fn eq(&self, other: &f64) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl PartialEq<f32> for Complex
[src]
fn eq(&self, other: &f32) -> bool
[src]
This method tests for self
and other
values to be equal, and is used by ==
. Read more
fn ne(&self, other: &Rhs) -> bool
1.0.0[src]
This method tests for !=
.
impl Sum for Complex
[src]
fn sum<I>(iter: I) -> Complex where
I: Iterator<Item = Complex>,
[src]
I: Iterator<Item = Complex>,
Method which takes an iterator and generates Self
from the elements by "summing up" the items. Read more
impl<'a> Sum<&'a Complex> for Complex
[src]
fn sum<I>(iter: I) -> Complex where
I: Iterator<Item = &'a Complex>,
[src]
I: Iterator<Item = &'a Complex>,
Method which takes an iterator and generates Self
from the elements by "summing up" the items. Read more
impl Product for Complex
[src]
fn product<I>(iter: I) -> Complex where
I: Iterator<Item = Complex>,
[src]
I: Iterator<Item = Complex>,
Method which takes an iterator and generates Self
from the elements by multiplying the items. Read more
impl<'a> Product<&'a Complex> for Complex
[src]
fn product<I>(iter: I) -> Complex where
I: Iterator<Item = &'a Complex>,
[src]
I: Iterator<Item = &'a Complex>,
Method which takes an iterator and generates Self
from the elements by multiplying the items. Read more
impl<'a> AssignRound<ValidComplex<'a>> for Complex
[src]
type Round = (Round, Round)
The rounding method.
type Ordering = (Ordering, Ordering)
The direction from rounding.
fn assign_round(
&mut self,
rhs: ValidComplex,
round: (Round, Round)
) -> (Ordering, Ordering)
[src]
&mut self,
rhs: ValidComplex,
round: (Round, Round)
) -> (Ordering, Ordering)
Peforms the assignment. Read more