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

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 c1 = Complex::new(32);
assert_eq!(c1.prec(), (32, 32));
assert_eq!(c1, 0);
let c2 = Complex::new((32, 64));
assert_eq!(c2.prec(), (32, 64));
assert_eq!(c2, 0);

Panics

Panics if the precision is out of the allowed range.

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

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

Examples

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

Panics

Panics if prec is out of the allowed range.

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

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

Examples

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

Panics

Panics if prec is out of the allowed range.

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

Returns the precision of the real and imaginary parts.

Examples

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

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

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

Examples

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

Panics

Panics if the precision is out of the allowed range.

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

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

Examples

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

Panics

Panics if the precision is out of the allowed range.

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

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

Examples

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

Errors

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

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

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

Examples

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

Errors

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

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

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

Examples

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

Errors

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

Panics

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

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

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

Examples

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

Errors

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

Panics

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

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

Checks if a Complex number can be parsed.

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

Examples

use rug::Complex;

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

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

Errors

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

Panics

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

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

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

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

Examples

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

Panics

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

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

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

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

Examples

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

Panics

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

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

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

Examples

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

Errors

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

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

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

Examples

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

Errors

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

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

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

Examples

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

Errors

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

Panics

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

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

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

Examples

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

Errors

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

Panics

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

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

Borrows the real part as a Float.

Examples

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

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

Borrows the imaginary part as a Float.

Examples

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

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

Borrows the real part mutably.

Examples

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

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

Borrows the imaginary part mutably.

Examples

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

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

Borrows the real and imaginary parts.

Examples

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

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

Borrows the real and imaginary parts mutably.

Examples

use rug::Complex;

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

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

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

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

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

`fn proj(self) -> Complex`

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().get_sign());

`fn proj_mut(&mut self)`

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

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

Examples

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

`fn proj_ref(&self) -> ProjRef`

Computes the projection onto the Riemann sphere.

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

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().get_sign());

`fn square(self) -> Complex`

Computes the square, rounding to the nearest.

Examples

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

`fn square_mut(&mut self)`

Computes the square, rounding to the nearest.

Examples

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

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

Computes the square, applying the specified rounding method.

Examples

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

`fn square_ref(&self) -> SquareRef`

Computes the square.

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`

Computes the square root, rounding to the nearest.

Examples

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

`fn sqrt_mut(&mut self)`

Computes the square root, rounding to the nearest.

Examples

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

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

Computes the square root, applying the specified rounding method.

Examples

use rug::Complex;
use 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(Default::default());
assert_eq!(c, (1.625, 0.6875));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

`fn sqrt_ref(&self) -> SqrtRef`

Computes the square root.

Examples

use rug::Complex;
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 (sqrt, dir) = Complex::with_val_round(4, r, Default::default());
assert_eq!(sqrt, (1.625, 0.6875));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

`fn conj(self) -> Complex`

Computes the complex conjugate.

Examples

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

`fn conj_mut(&mut self)`

Computes the complex conjugate.

Examples

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

`fn conj_ref(&self) -> ConjugateRef`

Computes the complex conjugate.

Examples

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

`fn abs(self) -> Float`

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

Examples

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

`fn abs_mut(&mut self)`

Computes the absolute value.

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

Examples

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

`fn abs_ref(&self) -> AbsRef`

Computes the absolute value.

Examples

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

`fn arg(self) -> Float`

Computes the argument, rounding to the nearest.

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

Examples

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

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

use rug::{Assign, Complex, Float};
use rug::float::Special;
use std::f64;
// f has precision 53, just like f64, so PI constants match.
let mut arg = Float::new(53);
let mut zero = Complex::new(53);
zero.assign((Special::Zero, Special::Zero));
arg.assign(zero.arg_ref());
assert!(arg.is_zero() && !arg.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 arg_mut(&mut self)`

Computes the argument, rounding to the nearest.

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

Examples

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

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

Computes the argument, applying the specified rounding method.

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

Examples

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

`fn arg_ref(&self) -> ArgRef`

Computes the argument.

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`

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

Examples

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

`fn mul_i_mut(&mut self, negative: bool)`

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

Examples

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

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

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

Examples

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

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

Multiplies the complex number by ±i.

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`

Computes the reciprocal, rounding to the nearest.

Examples

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

`fn recip_mut(&mut self)`

Computes the reciprocal, rounding to the nearest.

Examples

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

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

Computes the reciprocal, applying the specified rounding method.

Examples

use rug::Complex;
use 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(Default::default());
assert_eq!(c, (13.0/64.0, -13.0/32.0));
assert_eq!(dir, (Ordering::Greater, Ordering::Less));

`fn recip_ref(&self) -> RecipRef`

Computes the reciprocal.

Examples

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

`fn norm(self) -> Float`

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

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

Examples

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

`fn norm_mut(&mut self)`

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

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

Examples

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

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

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

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

Examples

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

`fn norm_ref(&self) -> NormRef`

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

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`

Computes the natural logarithm, rounding to the nearest.

`fn ln_mut(&mut self)`

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(self) -> Complex`

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

`fn log10_mut(&mut self)`

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(self) -> Complex`

Computes the exponential, rounding to the nearest.

`fn exp_mut(&mut self)`

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(self) -> Complex`

Computes the sine, rounding to the nearest.

`fn sin_mut(&mut self)`

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(self) -> Complex`

Computes the cosine, rounding to the nearest.

`fn cos_mut(&mut self)`

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(self, cos: Complex) -> (Complex, 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_mut(&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::with_val(53, (0.5, 0.2));
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::with_val(10, (0.48905, 0.17669)));
assert_eq!(cos, Complex::with_val(10, (0.89519, -0.096526)));

`fn tan(self) -> Complex`

Computes the tangent, rounding to the nearest.

`fn tan_mut(&mut self)`

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(self) -> Complex`

Computes the hyperbolic sine, rounding to the nearest.

`fn sinh_mut(&mut self)`

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(self) -> Complex`

Computes the hyperbolic cosine, rounding to the nearest.

`fn cosh_mut(&mut self)`

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(self) -> Complex`

Computes the hyperbolic tangent, rounding to the nearest.

`fn tanh_mut(&mut self)`

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(self) -> Complex`

Computes the inverse sine, rounding to the nearest.

`fn asin_mut(&mut self)`

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(self) -> Complex`

Computes the inverse cosine, rounding to the nearest.

`fn acos_mut(&mut self)`

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(self) -> Complex`

Computes the inverse tangent, rounding to the nearest.

`fn atan_mut(&mut self)`

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(self) -> Complex`

Computes the inverse hyperbolic sine, rounding to the nearest.

`fn asinh_mut(&mut self)`

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(self) -> Complex`

Computes the inverse hyperbolic cosine, rounding to the nearest.

`fn acosh_mut(&mut self)`

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(self) -> Complex`

Computes the inverse hyperbolic tangent, rounding to the nearest.

`fn atanh_mut(&mut self)`

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 ≤ x < 1.

This is equivalent to calling assign_random_bits(rng) on the real part, and then calling the same method 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 ≤ x < 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 ≤ x < 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 then calling the same method 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 Display for Complex`
[src]

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

Formats the value using the given formatter. Read more

`impl Debug for Complex`
[src]

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

Formats the value using the given formatter.

`impl LowerExp for Complex`
[src]

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

Formats the value using the given formatter.

`impl UpperExp for Complex`
[src]

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

Formats the value using the given formatter.

`impl Binary for Complex`
[src]

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

Formats the value using the given formatter.

`impl Octal for Complex`
[src]

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

Formats the value using the given formatter.

`impl LowerHex for Complex`
[src]

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

Formats the value using the given formatter.

`impl UpperHex for Complex`
[src]

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

Formats the value using the given formatter.

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

`fn assign(&mut self, other: T)`

Peforms the assignement. Read more

Struct rug::Complex [−] [src]

Methods

impl Complex[src]

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

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

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

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(self) -> Complex

fn proj_mut(&mut self)

fn proj_ref(&self) -> ProjRef

fn square(self) -> Complex

fn square_mut(&mut self)

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

fn square_ref(&self) -> SquareRef

fn sqrt(self) -> Complex

fn sqrt_mut(&mut self)

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

fn sqrt_ref(&self) -> SqrtRef

fn conj(self) -> Complex

fn conj_mut(&mut self)

fn conj_ref(&self) -> ConjugateRef

fn abs(self) -> Float

fn abs_mut(&mut self)

fn abs_ref(&self) -> AbsRef

fn arg(self) -> Float

fn arg_mut(&mut self)

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

fn arg_ref(&self) -> ArgRef

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

fn mul_i_mut(&mut self, negative: bool)

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

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

fn recip(self) -> Complex

fn recip_mut(&mut self)

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

fn recip_ref(&self) -> RecipRef

fn norm(self) -> Float

fn norm_mut(&mut self)

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

fn norm_ref(&self) -> NormRef

fn ln(self) -> Complex

fn ln_mut(&mut self)

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

fn ln_ref(&self) -> LnRef

fn log10(self) -> Complex

fn log10_mut(&mut self)

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

fn log10_ref(&self) -> Log10Ref

fn exp(self) -> Complex

fn exp_mut(&mut self)

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

fn exp_ref(&self) -> ExpRef

fn sin(self) -> Complex

fn sin_mut(&mut self)

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

`impl Complex`
[src]

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

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

`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)>,`

`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(self) -> Complex`

`fn proj_mut(&mut self)`

`fn proj_ref(&self) -> ProjRef`

`fn square(self) -> Complex`

`fn square_mut(&mut self)`

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

`fn square_ref(&self) -> SquareRef`

`fn sqrt(self) -> Complex`

`fn sqrt_mut(&mut self)`

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

`fn sqrt_ref(&self) -> SqrtRef`

`fn conj(self) -> Complex`

`fn conj_mut(&mut self)`

`fn conj_ref(&self) -> ConjugateRef`

`fn abs(self) -> Float`

`fn abs_mut(&mut self)`

`fn abs_ref(&self) -> AbsRef`

`fn arg(self) -> Float`

`fn arg_mut(&mut self)`

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

`fn arg_ref(&self) -> ArgRef`

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

`fn mul_i_mut(&mut self, negative: bool)`

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

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

`fn recip(self) -> Complex`

`fn recip_mut(&mut self)`

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

`fn recip_ref(&self) -> RecipRef`

`fn norm(self) -> Float`

`fn norm_mut(&mut self)`

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

`fn norm_ref(&self) -> NormRef`

`fn ln(self) -> Complex`

`fn ln_mut(&mut self)`

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

`fn ln_ref(&self) -> LnRef`

`fn log10(self) -> Complex`

`fn log10_mut(&mut self)`

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

`fn log10_ref(&self) -> Log10Ref`

`fn exp(self) -> Complex`

`fn exp_mut(&mut self)`

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

`fn exp_ref(&self) -> ExpRef`

`fn sin(self) -> Complex`

`fn sin_mut(&mut self)`

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