Struct rug::Complex [−] [src]

pub struct Complex { /* fields omitted */ }

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

There are two versions of most methods:

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.

Methods

`impl Complex`
[src]

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

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

Examples

use rug::Complex;
let r1 = Complex::new(32);
assert_eq!(r1.prec(), (32, 32));
let r2 = Complex::new((32, 64));
assert_eq!(r2.prec(), (32, 64));

Panics

Panics if the precision is out of the allowed range.

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

Returns the precision of the real and imaginary parts.

Examples

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

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

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

Examples

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

Panics

Panics if the precision is out of the allowed range.

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

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

Examples

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

Panics

Panics if the precision is out of the allowed range.

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

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

Examples

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

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

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

Examples

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

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

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

Examples

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

Panics

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

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

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

Examples

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

Panics

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

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

Checks if a Complex number can be parsed.

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

Examples

use rug::Complex;

let valid1 = Complex::valid_str_radix("(1.2e-1 2.3e+2)", 4);
let c1 = Complex::from((valid1.unwrap(), 53));
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::from((valid2.unwrap(), 53));
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());

Panics

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

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

Returns a string representation of self 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::from((0, 53));
assert_eq!(c1.to_string_radix(10, None), "(0.0 0.0)");
let c2 = Complex::from(((15, 5), 12));
assert_eq!(c2.to_string_radix(16, None), "(f.000@0 5.000@0)");
let c3 = Complex::from(((10, -4), 53));
assert_eq!(c3.to_string_radix(10, Some(3)), "(1.00e1 -4.00e0)");
assert_eq!(c3.to_string_radix(5, Some(3)), "(2.00e1 -4.00e0)");

Panics

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

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

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

The exponent is encoded in decimal. 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::from((10.4, 10));
let down = (Round::Down, Round::Down);
let nearest = (Round::Nearest, Round::Nearest);
let up = (Round::Up, Round::Up);
let nd = c.to_string_radix_round(10, None, down);
assert_eq!(nd, "(1.0406e1 0.0)");
let nu = c.to_string_radix_round(10, None, up);
assert_eq!(nu, "(1.0407e1 0.0)");
let sd = c.to_string_radix_round(10, Some(2), down);
assert_eq!(sd, "(1.0e1 0.0)");
let sn = c.to_string_radix_round(10, Some(2), nearest);
assert_eq!(sn, "(1.0e1 0.0)");
let su = c.to_string_radix_round(10, Some(2), up);
assert_eq!(su, "(1.1e1 0.0)");

Panics

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

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

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

Examples

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

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

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

Examples

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

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

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

Examples

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

Panics

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

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

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

Examples

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

Panics

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

`fn real(&self) -> &Float`

Borrows the real part as a Float.

Examples

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

`fn imag(&self) -> &Float`

Borrows the imaginary part as a Float.

Examples

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

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

Borrows the real part mutably.

Examples

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

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

Borrows the imaginary part mutably.

Examples

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

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

Borrows the real and imaginary parts.

Examples

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

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

Borrows the real and imaginary parts mutably.

Examples

use rug::Complex;

let mut c = Complex::from(((12.5, -20.75), 53));
{
    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)`

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

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

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

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

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

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

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

`fn proj_ref(&self) -> ProjRef`

Computes the projection onto the Riemann sphere.

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

Computes the square, rounding to the nearest.

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

Computes the square, applying the specified rounding method.

`fn square_ref(&self) -> SquareRef`

Computes the square.

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

Computes the square root, rounding to the nearest.

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

Computes the square root, applying the specified rounding method.

`fn sqrt_ref(&self) -> SqrtRef`

Computes the square root.

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

Computes the complex conjugate, rounding to the nearest.

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

Computes the complex conjugate, applying the specified rounding method.

`fn conjugate_ref(&self) -> ConjugateRef`

Computes the complex conjugate.

`fn abs_ref(&self) -> AbsRef`

Computes the absolute value.

Examples

use rug::{Complex, Float};
use rug::float::Special;

let c1 = Complex::from(((30, 40), 53));
assert_eq!(Float::from((c1.abs_ref(), 53)), 50);
let c2 = Complex::from(((12, Special::Infinity), 53));
assert!(Float::from((c2.abs_ref(), 53)).is_infinite());

`fn arg_ref(&self) -> ArgRef`

Computes the argument.

Examples

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 c_pos = Complex::from((1, 53));
arg.assign(c_pos.arg_ref());
assert!(arg.is_zero());
let c_neg = Complex::from((-1.3, 53));
arg.assign(c_neg.arg_ref());
assert_eq!(arg, f64::consts::PI);
let c_pi_4 = Complex::from(((1.333, 1.333), 53));
arg.assign(c_pi_4.arg_ref());
assert_eq!(arg, f64::consts::FRAC_PI_4);

// Special values are handled like atan2 in IEEE 754-2008.
// Examples for real, imag set to plus, minus zero below:
let mut zero = Complex::new(53);
zero.assign((Special::Zero, Special::Zero));
arg.assign(zero.arg_ref());
assert!(arg.is_zero() && !arg.get_sign());
zero.assign((Special::Zero, Special::MinusZero));
arg.assign(zero.arg_ref());
assert!(arg.is_zero() && arg.get_sign());
zero.assign((Special::MinusZero, Special::Zero));
arg.assign(zero.arg_ref());
assert_eq!(arg, f64::consts::PI);
zero.assign((Special::MinusZero, Special::MinusZero));
arg.assign(zero.arg_ref());
assert_eq!(arg, -f64::consts::PI);

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

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

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

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

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

Multiplies the complex number by i.

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

Computes the reciprocal, rounding to the nearest.

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

Computes the reciprocal, applying the specified rounding method.

`fn recip_ref(&self) -> RecipRef`

Computes the reciprocal.

`fn norm_ref(&self) -> NormRef`

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

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

Computes the natural logarithm, rounding to the nearest.

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

Computes the natural logarithm, applying the specified rounding method.

`fn ln_ref(&self) -> LnRef`

Computes the natural logarithm;

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

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

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

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

`fn log10_ref(&self) -> Log10Ref`

Computes the logarithm to base 10.

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

Computes the exponential, rounding to the nearest.

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

Computes the exponential, applying the specified rounding method.

`fn exp_ref(&self) -> ExpRef`

Computes the exponential.

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

Computes the sine, rounding to the nearest.

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

Computes the sine, applying the specified rounding method.

`fn sin_ref(&self) -> SinRef`

Computes the sine.

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

Computes the cosine, rounding to the nearest.

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

Computes the cosine, applying the specified rounding method.

`fn cos_ref(&self) -> CosRef`

Computes the cosine.

`fn sin_cos(&mut self, cos: &mut Complex)`

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.

`fn sin_cos_round( &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.

`fn sin_cos_ref(&self) -> SinCosRef`

Computes the sine and cosine.

Examples

use rug::{Assign, Complex};
// sin(0.5 + 0.2i) = 0.48905 + 0.17669i
// cos(0.5 + 0.2i) = 0.89519 - 0.096526i
let angle = Complex::from(((0.5, 0.2), 53));
let r = angle.sin_cos_ref();
// use only 10 bits of precision here to
// make comparison easier
let (mut sin, mut cos) = (Complex::new(10), Complex::new(10));
(&mut sin, &mut cos).assign(r);
assert_eq!(sin, Complex::from(((0.48905, 0.17669), 10)));
assert_eq!(cos, Complex::from(((0.89519, -0.096526), 10)));

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

Computes the tangent, rounding to the nearest.

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

Computes the tangent, applying the specified rounding method.

`fn tan_ref(&self) -> TanRef`

Computes the tangent.

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

Computes the hyperbolic sine, rounding to the nearest.

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

Computes the hyperbolic sine, applying the specified rounding method.

`fn sinh_ref(&self) -> SinhRef`

Computes the hyperbolic sine.

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

Computes the hyperbolic cosine, rounding to the nearest.

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

Computes the hyperbolic cosine, applying the specified rounding method.

`fn cosh_ref(&self) -> CoshRef`

Computes the hyperbolic cosine.

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

Computes the hyperbolic tangent, rounding to the nearest.

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

Computes the hyperbolic tangent, applying the specified rounding method.

`fn tanh_ref(&self) -> TanhRef`

Computes the hyperbolic tangent.

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

Computes the inverse sine, rounding to the nearest.

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

Computes the inverse sine, applying the specified rounding method.

`fn asin_ref(&self) -> AsinRef`

Computes the inverse sine.

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

Computes the inverse cosine, rounding to the nearest.

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

Computes the inverse cosine, applying the specified rounding method.

`fn acos_ref(&self) -> AcosRef`

Computes the inverse cosine.

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

Computes the inverse tangent, rounding to the nearest.

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

Computes the inverse tangent, applying the specified rounding method.

`fn atan_ref(&self) -> AtanRef`

Computes the inverse tangent.

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

Computes the inverse hyperbolic sine, rounding to the nearest.

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

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

`fn asinh_ref(&self) -> AsinhRef`

Computes the inverse hyperboic sine.

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

Computes the inverse hyperbolic cosine, rounding to the nearest.

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

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

`fn acosh_ref(&self) -> AcoshRef`

Computes the inverse hyperbolic cosine.

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

Computes the inverse hyperbolic tangent, rounding to the nearest.

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

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

`fn atanh_ref(&self) -> AtanhRef`

Computes the inverse hyperbolic tangent.

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

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

This is equivalent to calling assign_random_bits(rng) on the real part, and the same on the imaginary part.

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

Generates a random complex number, rounding to the nearest.

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

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

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

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

Trait Implementations

`impl Clone for Complex`
[src]

`fn clone(&self) -> Complex`

Returns a copy of the value. Read more

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

Performs copy-assignment from source. Read more

`impl Drop for Complex`
[src]

`fn drop(&mut self)`

A method called when the value goes out of scope. Read more

`impl From<(Float, Float)> for Complex`
[src]

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

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

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

`impl<T, P: Prec> From<(T, P)> for Complex where Complex: FromRound<T, P, Round = (Round, Round)>,`
[src]

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

Performs the conversion.

Struct rug::Complex [−] [src]

Methods

impl Complex[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn real(&self) -> &Float

fn imag(&self) -> &Float

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

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

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

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

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

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

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

fn proj_ref(&self) -> ProjRef

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

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

fn square_ref(&self) -> SquareRef

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

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

fn sqrt_ref(&self) -> SqrtRef

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

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

fn conjugate_ref(&self) -> ConjugateRef

fn abs_ref(&self) -> AbsRef

fn arg_ref(&self) -> ArgRef

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

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

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

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

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

fn recip_ref(&self) -> RecipRef

fn norm_ref(&self) -> NormRef

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

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

fn ln_ref(&self) -> LnRef

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

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

fn log10_ref(&self) -> Log10Ref

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

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

fn exp_ref(&self) -> ExpRef

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

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

fn sin_ref(&self) -> SinRef

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

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

fn cos_ref(&self) -> CosRef

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

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

fn sin_cos_ref(&self) -> SinCosRef

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

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

fn tan_ref(&self) -> TanRef

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

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

fn sinh_ref(&self) -> SinhRef

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

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

fn cosh_ref(&self) -> CoshRef

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

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

fn tanh_ref(&self) -> TanhRef

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

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

fn asin_ref(&self) -> AsinRef

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

`impl Complex`
[src]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn real(&self) -> &Float`

`fn imag(&self) -> &Float`

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

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

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

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

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

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

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

`fn proj_ref(&self) -> ProjRef`

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

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

`fn square_ref(&self) -> SquareRef`

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

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

`fn sqrt_ref(&self) -> SqrtRef`

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

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

`fn conjugate_ref(&self) -> ConjugateRef`

`fn abs_ref(&self) -> AbsRef`

`fn arg_ref(&self) -> ArgRef`

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

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

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

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

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

`fn recip_ref(&self) -> RecipRef`

`fn norm_ref(&self) -> NormRef`

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

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

`fn ln_ref(&self) -> LnRef`

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

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

`fn log10_ref(&self) -> Log10Ref`

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

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

`fn exp_ref(&self) -> ExpRef`

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

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

`fn sin_ref(&self) -> SinRef`

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

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

`fn cos_ref(&self) -> CosRef`

`fn sin_cos(&mut self, cos: &mut Complex)`

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

`fn sin_cos_ref(&self) -> SinCosRef`

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

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

`fn tan_ref(&self) -> TanRef`

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

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

`fn sinh_ref(&self) -> SinhRef`

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

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

`fn cosh_ref(&self) -> CoshRef`

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

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

`fn tanh_ref(&self) -> TanhRef`

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

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

`fn asin_ref(&self) -> AsinRef`

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

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

`fn acos_ref(&self) -> AcosRef`