Struct rug::complex::SmallComplex

#[repr(C)]
pub struct SmallComplex { /* fields omitted */ }

A small complex number that does not require any memory allocation.

This can be useful when you have real and imaginary numbers that are primitive integers or floats and you need a reference to a Complex. The SmallComplex will have a precision according to the type of the primitive used to set its value.

• i8, u8: the SmallComplex will have eight bits of precision.
• i16, u16: the SmallComplex will have 16 bits of precision.
• i32, u32: the SmallComplex will have 32 bits of precision.
• i64, u64: the SmallComplex will have 64 bits of precision.
• f32: the SmallComplex will have 24 bits of precision.
• f64: the SmallComplex will have 53 bits of precision.

The SmallComplex type can be coerced to a Complex, as it implements Deref with a Complex target.

Examples

use rug::Complex;
use rug::complex::SmallComplex;
// `a` requires a heap allocation
let mut a = Complex::with_val(53, (1, 2));
// `b` can reside on the stack
let b = SmallComplex::from((-10f64, -20.5f64));
a += &*b;
assert_eq!(*a.real(), -9);
assert_eq!(*a.imag(), -18.5);

Methods

impl SmallComplex

fn new() -> SmallComplex

Creates a SmallComplex with value 0.

Examples

use rug::complex::SmallComplex;
let c = SmallComplex::new();
// Use c as if it were Complex.
assert_eq!(*c.real(), 0.0);
assert_eq!(*c.imag(), 0.0);

Methods from Deref<Target = Complex>

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 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 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 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 into_real_imag(self) -> (Float, Float)

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

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

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

fn as_neg(&self) -> BorrowComplex

Borrows a negated copy of the Complex number.

The returned object implements Deref 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

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

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

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

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

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_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_ref(&self) -> SqrtRef

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

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

Examples

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

fn ln_ref(&self) -> LnRef

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

fn log10(self) -> Complex

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

Examples

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

fn log10_ref(&self) -> Log10Ref

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

fn exp(self) -> Complex

Computes the exponential, rounding to the nearest.

Examples

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

fn exp_ref(&self) -> ExpRef

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

fn sin(self) -> Complex

Computes the sine, rounding to the nearest.

Examples

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

fn sin_ref(&self) -> SinRef

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

fn cos(self) -> Complex

Computes the cosine, rounding to the nearest.

Examples

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

fn cos_ref(&self) -> CosRef

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

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

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

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

Examples

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

fn sin_cos_ref(&self) -> SinCosRef

Computes the sine and cosine.

Examples

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

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

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

fn tan(self) -> Complex

Computes the tangent, rounding to the nearest.

Examples

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

fn tan_ref(&self) -> TanRef

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

fn sinh(self) -> Complex

Computes the hyperbolic sine, rounding to the nearest.

Examples

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

fn sinh_ref(&self) -> SinhRef

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

fn cosh(self) -> Complex

Computes the hyperbolic cosine, rounding to the nearest.

Examples

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

fn cosh_ref(&self) -> CoshRef

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

fn tanh(self) -> Complex

Computes the hyperbolic tangent, rounding to the nearest.

Examples

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

fn tanh_ref(&self) -> TanhRef

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

fn asin(self) -> Complex

Computes the inverse sine, rounding to the nearest.

Examples

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

fn asin_ref(&self) -> AsinRef

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

fn acos(self) -> Complex

Computes the inverse cosine, rounding to the nearest.

Examples

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

fn acos_ref(&self) -> AcosRef

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

fn atan(self) -> Complex

Computes the inverse tangent, rounding to the nearest.

Examples

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

fn atan_ref(&self) -> AtanRef

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

fn asinh(self) -> Complex

Computes the inverse hyperbolic sine, rounding to the nearest.

Examples

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

fn asinh_ref(&self) -> AsinhRef

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

fn acosh(self) -> Complex

Computes the inverse hyperbolic cosine, rounding to the nearest.

Examples

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

fn acosh_ref(&self) -> AcoshRef

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

fn atanh(self) -> Complex

Computes the inverse hyperbolic tangent, rounding to the nearest.

Examples

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

fn atanh_ref(&self) -> AtanhRef

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

Trait Implementations

impl Default for SmallComplex

fn default() -> SmallComplex

Returns the "default value" for a type.

impl Deref for SmallComplex

type Target = Complex

The resulting type after dereferencing.

fn deref(&self) -> &Complex

Dereferences the value.

impl<T> From<T> for SmallComplex where
    SmallComplex: Assign<T>, 

fn from(val: T) -> SmallComplex

Performs the conversion.

impl Assign<i8> for SmallComplex

fn assign(&mut self, val: i8)

Peforms the assignement.

impl Assign<i16> for SmallComplex

fn assign(&mut self, val: i16)

Peforms the assignement.

impl Assign<i32> for SmallComplex

fn assign(&mut self, val: i32)

Peforms the assignement.

impl Assign<i64> for SmallComplex

fn assign(&mut self, val: i64)

Peforms the assignement.

impl Assign<u8> for SmallComplex

fn assign(&mut self, val: u8)

Peforms the assignement.

impl Assign<u16> for SmallComplex

fn assign(&mut self, val: u16)

Peforms the assignement.

impl Assign<u32> for SmallComplex

fn assign(&mut self, val: u32)

Peforms the assignement.

impl Assign<u64> for SmallComplex

fn assign(&mut self, val: u64)

Peforms the assignement.

impl Assign<(i8, i8)> for SmallComplex

fn assign(&mut self, (re, im): (i8, i8))

Peforms the assignement.

impl Assign<(i16, i16)> for SmallComplex

fn assign(&mut self, (re, im): (i16, i16))

Peforms the assignement.

impl Assign<(i32, i32)> for SmallComplex

fn assign(&mut self, (re, im): (i32, i32))

Peforms the assignement.

impl Assign<(i64, i64)> for SmallComplex

fn assign(&mut self, (re, im): (i64, i64))

Peforms the assignement.

impl Assign<(i8, u8)> for SmallComplex

fn assign(&mut self, (re, im): (i8, u8))

Peforms the assignement.

impl Assign<(i16, u16)> for SmallComplex

fn assign(&mut self, (re, im): (i16, u16))

Peforms the assignement.

impl Assign<(i32, u32)> for SmallComplex

fn assign(&mut self, (re, im): (i32, u32))

Peforms the assignement.

impl Assign<(i64, u64)> for SmallComplex

fn assign(&mut self, (re, im): (i64, u64))

Peforms the assignement.

impl Assign<(u8, i8)> for SmallComplex

fn assign(&mut self, (re, im): (u8, i8))

Peforms the assignement.

impl Assign<(u16, i16)> for SmallComplex

fn assign(&mut self, (re, im): (u16, i16))

Peforms the assignement.

impl Assign<(u32, i32)> for SmallComplex

fn assign(&mut self, (re, im): (u32, i32))

Peforms the assignement.

impl Assign<(u64, i64)> for SmallComplex

fn assign(&mut self, (re, im): (u64, i64))

Peforms the assignement.

impl Assign<(u8, u8)> for SmallComplex

fn assign(&mut self, (re, im): (u8, u8))

Peforms the assignement.

impl Assign<(u16, u16)> for SmallComplex

fn assign(&mut self, (re, im): (u16, u16))

Peforms the assignement.

impl Assign<(u32, u32)> for SmallComplex

fn assign(&mut self, (re, im): (u32, u32))

Peforms the assignement.

impl Assign<(u64, u64)> for SmallComplex

fn assign(&mut self, (re, im): (u64, u64))

Peforms the assignement.

impl Assign<f32> for SmallComplex

fn assign(&mut self, val: f32)

Peforms the assignement.

impl Assign<f64> for SmallComplex

fn assign(&mut self, val: f64)

Peforms the assignement.

impl Assign<(f32, f32)> for SmallComplex

fn assign(&mut self, (re, im): (f32, f32))

Peforms the assignement.

impl Assign<(f64, f64)> for SmallComplex

fn assign(&mut self, (re, im): (f64, f64))

Peforms the assignement.