Struct rug::complex::SmallComplex
[−]
[src]
#[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
: theSmallComplex
will have eight bits of precision.i16
,u16
: theSmallComplex
will have 16 bits of precision.i32
,u32
: theSmallComplex
will have 32 bits of precision.i64
,u64
: theSmallComplex
will have 64 bits of precision.f32
: theSmallComplex
will have 24 bits of precision.f64
: theSmallComplex
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
[src]
fn new() -> SmallComplex
[src]
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)
[src]
Returns the precision of the real and imaginary parts.
Examples
use rug::Complex; let r = Complex::new((24, 53)); assert_eq!(r.prec(), (24, 53));
fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
[src]
Returns a string representation of the value for the specified
radix
rounding to the nearest.
The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Examples
use rug::Complex; let c1 = Complex::with_val(53, 0); assert_eq!(c1.to_string_radix(10, None), "(0.0 0.0)"); let c2 = Complex::with_val(12, (15, 5)); assert_eq!(c2.to_string_radix(16, None), "(f.000 5.000)"); let c3 = Complex::with_val(53, (10, -4)); assert_eq!(c3.to_string_radix(10, Some(3)), "(1.00e1 -4.00)"); assert_eq!(c3.to_string_radix(5, Some(3)), "(2.00e1 -4.00)");
Panics
Panics if radix
is less than 2 or greater than 36.
fn to_string_radix_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: (Round, Round)
) -> String
[src]
&self,
radix: i32,
num_digits: Option<usize>,
round: (Round, Round)
) -> String
Returns a string representation of the value for the specified
radix
applying the specified rounding method.
The exponent is encoded in decimal. If the number of digits is not specified, the output string will have enough precision such that reading it again will give the exact same number.
Examples
use rug::Complex; use rug::float::Round; let c = Complex::with_val(10, 10.4); let down = (Round::Down, Round::Down); let nearest = (Round::Nearest, Round::Nearest); let up = (Round::Up, Round::Up); let nd = c.to_string_radix_round(10, None, down); assert_eq!(nd, "(1.0406e1 0.0)"); let nu = c.to_string_radix_round(10, None, up); assert_eq!(nu, "(1.0407e1 0.0)"); let sd = c.to_string_radix_round(10, Some(2), down); assert_eq!(sd, "(1.0e1 0.0)"); let sn = c.to_string_radix_round(10, Some(2), nearest); assert_eq!(sn, "(1.0e1 0.0)"); let su = c.to_string_radix_round(10, Some(2), up); assert_eq!(su, "(1.1e1 0.0)");
Panics
Panics if radix
is less than 2 or greater than 36.
fn real(&self) -> &Float
[src]
Borrows the real part as a Float
.
Examples
use rug::Complex; let c = Complex::with_val(53, (12.5, -20.75)); assert_eq!(*c.real(), 12.5)
fn imag(&self) -> &Float
[src]
Borrows the imaginary part as a Float
.
Examples
use rug::Complex; let c = Complex::with_val(53, (12.5, -20.75)); assert_eq!(*c.imag(), -20.75)
fn as_real_imag(&self) -> (&Float, &Float)
[src]
Borrows the real and imaginary parts.
Examples
use rug::Complex; let c = Complex::with_val(53, (12.5, -20.75)); assert_eq!(c, (12.5, -20.75)); let (re, im) = c.as_real_imag(); assert_eq!(*re, 12.5); assert_eq!(*im, -20.75);
fn into_real_imag(self) -> (Float, Float)
[src]
Consumes and converts the value into real and imaginary
Float
values.
This function reuses the allocated memory and does not allocate any new memory.
use rug::Complex; let c = Complex::with_val(53, (12.5, -20.75)); let (real, imag) = c.into_real_imag(); assert_eq!(real, 12.5); assert_eq!(imag, -20.75);
fn as_neg(&self) -> BorrowComplex
[src]
Borrows a negated copy of the Complex
number.
The returned object implements Deref
with a Complex
target. This method performs a shallow copy and negates it,
and negation does not change the allocated data.
Examples
use rug::Complex; let c = Complex::with_val(53, (4.2, -2.3)); let neg_c = c.as_neg(); assert_eq!(*neg_c, (-4.2, 2.3)); // methods taking &self can be used on the returned object let reneg_c = neg_c.as_neg(); assert_eq!(*reneg_c, (4.2, -2.3)); assert_eq!(*reneg_c, c);
fn as_conj(&self) -> BorrowComplex
[src]
Borrows a conjugate copy of the Complex
number.
The returned object implements Deref
with a Complex
target. This method performs a shallow copy and negates its
imaginary part, and negation does not change the allocated
data.
Examples
use rug::Complex; let c = Complex::with_val(53, (4.2, -2.3)); let conj_c = c.as_conj(); assert_eq!(*conj_c, (4.2, 2.3)); // methods taking &self can be used on the returned object let reconj_c = conj_c.as_conj(); assert_eq!(*reconj_c, (4.2, -2.3)); assert_eq!(*reconj_c, c);
fn as_mul_i(&self, negative: bool) -> BorrowComplex
[src]
Borrows a rotated copy of the Complex
number.
The returned object implements Deref
with a Complex
target. This method operates by performing some shallow
copying; unlike the mul_i
method and
friends, this method swaps the precision of the real and
imaginary parts if they have unequal precisions.
Examples
use rug::Complex; let c = Complex::with_val(53, (4.2, -2.3)); let mul_i_c = c.as_mul_i(false); assert_eq!(*mul_i_c, (2.3, 4.2)); // methods taking &self can be used on the returned object let mul_ii_c = mul_i_c.as_mul_i(false); assert_eq!(*mul_ii_c, (-4.2, 2.3)); let mul_1_c = mul_i_c.as_mul_i(true); assert_eq!(*mul_1_c, (4.2, -2.3)); assert_eq!(*mul_1_c, c);
fn as_ord(&self) -> &OrdComplex
[src]
Borrows the Complex
as an ordered complex number of type
OrdComplex
.
Examples
use rug::Complex; use rug::float::Special; use std::cmp::Ordering; let nan_c = Complex::with_val(53, (Special::Nan, Special::Nan)); let nan = nan_c.as_ord(); assert_eq!(nan.cmp(nan), Ordering::Equal); let one_neg0_c = Complex::with_val(53, (1, Special::NegZero)); let one_neg0 = one_neg0_c.as_ord(); let one_pos0_c = Complex::with_val(53, (1, Special::Zero)); let one_pos0 = one_pos0_c.as_ord(); assert_eq!(one_neg0.cmp(one_pos0), Ordering::Less); let zero_inf_s = (Special::Zero, Special::Infinity); let zero_inf_c = Complex::with_val(53, zero_inf_s); let zero_inf = zero_inf_c.as_ord(); assert_eq!(one_pos0.cmp(zero_inf), Ordering::Greater);
fn proj(self) -> Complex
[src]
Computes a projection onto the Riemann sphere, rounding to the nearest.
If no parts of the number are infinite, the result is unchanged. If any part is infinite, the real part of the result is set to +∞ and the imaginary part of the result is set to 0 with the same sign as the imaginary part of the input.
Examples
use rug::Complex; use std::f64; let c1 = Complex::with_val(53, (1.5, 2.5)); let proj1 = c1.proj(); assert_eq!(proj1, (1.5, 2.5)); let c2 = Complex::with_val(53, (f64::NAN, f64::NEG_INFINITY)); let proj2 = c2.proj(); assert_eq!(proj2, (f64::INFINITY, 0.0)); // imaginary was negative, so now it is minus zero assert!(proj2.imag().is_sign_negative());
fn proj_ref(&self) -> ProjRef
[src]
Computes the projection onto the Riemann sphere.
If no parts of the number are infinite, the result is unchanged. If any part is infinite, the real part of the result is set to +∞ and the imaginary part of the result is set to 0 with the same sign as the imaginary part of the input.
Examples
use rug::Complex; use std::f64; let c1 = Complex::with_val(53, (f64::INFINITY, 50)); let proj1 = Complex::with_val(53, c1.proj_ref()); assert_eq!(proj1, (f64::INFINITY, 0.0)); let c2 = Complex::with_val(53, (f64::NAN, f64::NEG_INFINITY)); let proj2 = Complex::with_val(53, c2.proj_ref()); assert_eq!(proj2, (f64::INFINITY, 0.0)); // imaginary was negative, so now it is minus zero assert!(proj2.imag().is_sign_negative());
fn square(self) -> Complex
[src]
Computes the square, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, -2)); // (1 - 2i) squared is (-3 - 4i) let square = c.square(); assert_eq!(square, (-3, -4));
fn square_ref(&self) -> SquareRef
[src]
Computes the square.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let c = Complex::with_val(53, (1.25, 1.25)); // (1.25 + 1.25i) squared is (0 + 3.125i). let r = c.square_ref(); // With 4 bits of precision, 3.125 is rounded down to 3. let round = (Round::Down, Round::Down); let (square, dir) = Complex::with_val_round(4, r, round); assert_eq!(square, (0, 3)); assert_eq!(dir, (Ordering::Equal, Ordering::Less));
fn sqrt(self) -> Complex
[src]
Computes the square root, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (-1, 0)); // square root of (-1 + 0i) is (0 + i) let sqrt = c.sqrt(); assert_eq!(sqrt, (0, 1));
fn sqrt_ref(&self) -> SqrtRef
[src]
Computes the square root.
Examples
use rug::Complex; use rug::float::Round; use std::cmp::Ordering; let c = Complex::with_val(53, (2, 2.25)); // Square root of (2 + 2.25i) is (1.5828 + 0.7108i). let r = c.sqrt_ref(); // Nearest with 4 bits of precision: (1.625 + 0.6875i) let nearest = (Round::Nearest, Round::Nearest); let (sqrt, dir) = Complex::with_val_round(4, r, nearest); assert_eq!(sqrt, (1.625, 0.6875)); assert_eq!(dir, (Ordering::Greater, Ordering::Less));
fn conj(self) -> Complex
[src]
Computes the complex conjugate.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, 2.5)); let conj = c.conj(); assert_eq!(conj, (1.5, -2.5));
fn conj_ref(&self) -> ConjugateRef
[src]
Computes the complex conjugate.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, 2.5)); let conj = Complex::with_val(53, c.conj_ref()); assert_eq!(conj, (1.5, -2.5));
fn abs(self) -> Float
[src]
Computes the absolute value and returns it as a
Float
with the precision of the real
part.
Examples
use rug::Complex; let c = Complex::with_val(53, (30, 40)); let f = c.abs(); assert_eq!(f, 50);
fn abs_ref(&self) -> AbsRef
[src]
Computes the absolute value.
Examples
use rug::{Complex, Float}; let c = Complex::with_val(53, (30, 40)); let f = Float::with_val(53, c.abs_ref()); assert_eq!(f, 50);
fn arg(self) -> Float
[src]
Computes the argument, rounding to the nearest.
The argument is returned as a Float
with the precision of the real part.
Examples
use rug::Complex; let c = Complex::with_val(53, (4, 3)); let f = c.arg(); assert_eq!(f, 0.75_f64.atan());
Special values are handled like atan2 in IEEE 754-2008.
use rug::{Assign, Complex, Float}; use rug::float::Special; use std::f64; // f has precision 53, just like f64, so PI constants match. let mut arg = Float::new(53); let mut zero = Complex::new(53); zero.assign((Special::Zero, Special::Zero)); arg.assign(zero.arg_ref()); assert!(arg.is_zero() && arg.is_sign_positive()); zero.assign((Special::Zero, Special::NegZero)); arg.assign(zero.arg_ref()); assert!(arg.is_zero() && arg.is_sign_negative()); zero.assign((Special::NegZero, Special::Zero)); arg.assign(zero.arg_ref()); assert_eq!(arg, f64::consts::PI); zero.assign((Special::NegZero, Special::NegZero)); arg.assign(zero.arg_ref()); assert_eq!(arg, -f64::consts::PI);
fn arg_ref(&self) -> ArgRef
[src]
Computes the argument.
Examples
use rug::{Assign, Complex, Float}; use std::f64; // f has precision 53, just like f64, so PI constants match. let mut arg = Float::new(53); let c_pos = Complex::with_val(53, 1); arg.assign(c_pos.arg_ref()); assert!(arg.is_zero()); let c_neg = Complex::with_val(53, -1.3); arg.assign(c_neg.arg_ref()); assert_eq!(arg, f64::consts::PI); let c_pi_4 = Complex::with_val(53, (1.333, 1.333)); arg.assign(c_pi_4.arg_ref()); assert_eq!(arg, f64::consts::FRAC_PI_4);
fn mul_i(self, negative: bool) -> Complex
[src]
Multiplies the complex number by ±i, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (13, 24)); let rot1 = c.mul_i(false); assert_eq!(rot1, (-24, 13)); let rot2 = rot1.mul_i(false); assert_eq!(rot2, (-13, -24)); let rot2_less1 = rot2.mul_i(true); assert_eq!(rot2_less1, (-24, 13));
fn mul_i_ref(&self, negative: bool) -> MulIRef
[src]
Multiplies the complex number by ±i.
Examples
use rug::Complex; let c = Complex::with_val(53, (13, 24)); let rotated = Complex::with_val(53, c.mul_i_ref(false)); assert_eq!(rotated, (-24, 13));
fn recip(self) -> Complex
[src]
Computes the reciprocal, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); // 1/(1 + i) = (0.5 - 0.5i) let recip = c.recip(); assert_eq!(recip, (0.5, -0.5));
fn recip_ref(&self) -> RecipRef
[src]
Computes the reciprocal.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); // 1/(1 + i) = (0.5 - 0.5i) let recip = Complex::with_val(53, c.recip_ref()); assert_eq!(recip, (0.5, -0.5));
fn norm(self) -> Float
[src]
Computes the norm, that is the square of the absolute value, rounding it to the nearest.
The norm is returned as a Float
with
the precision of the real part.
Examples
use rug::Complex; let c = Complex::with_val(53, (3, 4)); let f = c.norm(); assert_eq!(f, 25);
fn norm_ref(&self) -> NormRef
[src]
Computes the norm, that is the square of the absolute value.
Examples
use rug::{Complex, Float}; let c = Complex::with_val(53, (3, 4)); let f = Float::with_val(53, c.norm_ref()); assert_eq!(f, 25);
fn ln(self) -> Complex
[src]
Computes the natural logarithm, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, -0.5)); let ln = c.ln(); let expected = Complex::with_val(53, (0.4581, -0.3218)); assert!((ln - expected).abs() < 0.0001);
fn ln_ref(&self) -> LnRef
[src]
Computes the natural logarithm;
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, -0.5)); let ln = Complex::with_val(53, c.ln_ref()); let expected = Complex::with_val(53, (0.4581, -0.3218)); assert!((ln - expected).abs() < 0.0001);
fn log10(self) -> Complex
[src]
Computes the logarithm to base 10, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, -0.5)); let log10 = c.log10(); let expected = Complex::with_val(53, (0.1990, -0.1397)); assert!((log10 - expected).abs() < 0.0001);
fn log10_ref(&self) -> Log10Ref
[src]
Computes the logarithm to base 10.
Examples
use rug::Complex; let c = Complex::with_val(53, (1.5, -0.5)); let log10 = Complex::with_val(53, c.log10_ref()); let expected = Complex::with_val(53, (0.1990, -0.1397)); assert!((log10 - expected).abs() < 0.0001);
fn exp(self) -> Complex
[src]
Computes the exponential, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (0.5, -0.75)); let exp = c.exp(); let expected = Complex::with_val(53, (1.2064, -1.1238)); assert!((exp - expected).abs() < 0.0001);
fn exp_ref(&self) -> ExpRef
[src]
Computes the exponential.
Examples
use rug::Complex; let c = Complex::with_val(53, (0.5, -0.75)); let exp = Complex::with_val(53, c.exp_ref()); let expected = Complex::with_val(53, (1.2064, -1.1238)); assert!((exp - expected).abs() < 0.0001);
fn sin(self) -> Complex
[src]
Computes the sine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let sin = c.sin(); let expected = Complex::with_val(53, (1.2985, 0.6350)); assert!((sin - expected).abs() < 0.0001);
fn sin_ref(&self) -> SinRef
[src]
Computes the sine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let sin = Complex::with_val(53, c.sin_ref()); let expected = Complex::with_val(53, (1.2985, 0.6350)); assert!((sin - expected).abs() < 0.0001);
fn cos(self) -> Complex
[src]
Computes the cosine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let cos = c.cos(); let expected = Complex::with_val(53, (0.8337, -0.9889)); assert!((cos - expected).abs() < 0.0001);
fn cos_ref(&self) -> CosRef
[src]
Computes the cosine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let cos = Complex::with_val(53, c.cos_ref()); let expected = Complex::with_val(53, (0.8337, -0.9889)); assert!((cos - expected).abs() < 0.0001);
fn sin_cos(self, cos: Complex) -> (Complex, Complex)
[src]
Computes the sine and cosine of self
, rounding to the
nearest.
The sine keeps the precision of self
while the cosine
keeps the precision of cos
.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let (sin, cos) = c.sin_cos(Complex::new(53)); let expected_sin = Complex::with_val(53, (1.2985, 0.6350)); let expected_cos = Complex::with_val(53, (0.8337, -0.9889)); assert!((sin - expected_sin).abs() < 0.0001); assert!((cos - expected_cos).abs() < 0.0001);
fn sin_cos_ref(&self) -> SinCosRef
[src]
Computes the sine and cosine.
Examples
use rug::{Assign, Complex}; use rug::float::{AssignRound, Round}; use std::cmp::Ordering; let phase = Complex::with_val(53, (1, 1)); let sin_cos = phase.sin_cos_ref(); let (mut sin, mut cos) = (Complex::new(53), Complex::new(53)); (&mut sin, &mut cos).assign(sin_cos); let expected_sin = Complex::with_val(53, (1.2985, 0.6350)); let expected_cos = Complex::with_val(53, (0.8337, -0.9889)); assert!((sin - expected_sin).abs() < 0.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
[src]
Computes the tangent, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let tan = c.tan(); let expected = Complex::with_val(53, (0.2718, 1.0839)); assert!((tan - expected).abs() < 0.0001);
fn tan_ref(&self) -> TanRef
[src]
Computes the tangent.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let tan = Complex::with_val(53, c.tan_ref()); let expected = Complex::with_val(53, (0.2718, 1.0839)); assert!((tan - expected).abs() < 0.0001);
fn sinh(self) -> Complex
[src]
Computes the hyperbolic sine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let sinh = c.sinh(); let expected = Complex::with_val(53, (0.6350, 1.2985)); assert!((sinh - expected).abs() < 0.0001);
fn sinh_ref(&self) -> SinhRef
[src]
Computes the hyperbolic sine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let sinh = Complex::with_val(53, c.sinh_ref()); let expected = Complex::with_val(53, (0.6350, 1.2985)); assert!((sinh - expected).abs() < 0.0001);
fn cosh(self) -> Complex
[src]
Computes the hyperbolic cosine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let cosh = c.cosh(); let expected = Complex::with_val(53, (0.8337, 0.9889)); assert!((cosh - expected).abs() < 0.0001);
fn cosh_ref(&self) -> CoshRef
[src]
Computes the hyperbolic cosine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let cosh = Complex::with_val(53, c.cosh_ref()); let expected = Complex::with_val(53, (0.8337, 0.9889)); assert!((cosh - expected).abs() < 0.0001);
fn tanh(self) -> Complex
[src]
Computes the hyperbolic tangent, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let tanh = c.tanh(); let expected = Complex::with_val(53, (1.0839, 0.2718)); assert!((tanh - expected).abs() < 0.0001);
fn tanh_ref(&self) -> TanhRef
[src]
Computes the hyperbolic tangent.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let tanh = Complex::with_val(53, c.tanh_ref()); let expected = Complex::with_val(53, (1.0839, 0.2718)); assert!((tanh - expected).abs() < 0.0001);
fn asin(self) -> Complex
[src]
Computes the inverse sine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let asin = c.asin(); let expected = Complex::with_val(53, (0.6662, 1.0613)); assert!((asin - expected).abs() < 0.0001);
fn asin_ref(&self) -> AsinRef
[src]
Computes the inverse sine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let asin = Complex::with_val(53, c.asin_ref()); let expected = Complex::with_val(53, (0.6662, 1.0613)); assert!((asin - expected).abs() < 0.0001);
fn acos(self) -> Complex
[src]
Computes the inverse cosine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let acos = c.acos(); let expected = Complex::with_val(53, (0.9046, -1.0613)); assert!((acos - expected).abs() < 0.0001);
fn acos_ref(&self) -> AcosRef
[src]
Computes the inverse cosine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let acos = Complex::with_val(53, c.acos_ref()); let expected = Complex::with_val(53, (0.9046, -1.0613)); assert!((acos - expected).abs() < 0.0001);
fn atan(self) -> Complex
[src]
Computes the inverse tangent, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let atan = c.atan(); let expected = Complex::with_val(53, (1.0172, 0.4024)); assert!((atan - expected).abs() < 0.0001);
fn atan_ref(&self) -> AtanRef
[src]
Computes the inverse tangent.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let atan = Complex::with_val(53, c.atan_ref()); let expected = Complex::with_val(53, (1.0172, 0.4024)); assert!((atan - expected).abs() < 0.0001);
fn asinh(self) -> Complex
[src]
Computes the inverse hyperbolic sine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let asinh = c.asinh(); let expected = Complex::with_val(53, (1.0613, 0.6662)); assert!((asinh - expected).abs() < 0.0001);
fn asinh_ref(&self) -> AsinhRef
[src]
Computes the inverse hyperboic sine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let asinh = Complex::with_val(53, c.asinh_ref()); let expected = Complex::with_val(53, (1.0613, 0.6662)); assert!((asinh - expected).abs() < 0.0001);
fn acosh(self) -> Complex
[src]
Computes the inverse hyperbolic cosine, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let acosh = c.acosh(); let expected = Complex::with_val(53, (1.0613, 0.9046)); assert!((acosh - expected).abs() < 0.0001);
fn acosh_ref(&self) -> AcoshRef
[src]
Computes the inverse hyperbolic cosine.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let acosh = Complex::with_val(53, c.acosh_ref()); let expected = Complex::with_val(53, (1.0613, 0.9046)); assert!((acosh - expected).abs() < 0.0001);
fn atanh(self) -> Complex
[src]
Computes the inverse hyperbolic tangent, rounding to the nearest.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let atanh = c.atanh(); let expected = Complex::with_val(53, (0.4024, 1.0172)); assert!((atanh - expected).abs() < 0.0001);
fn atanh_ref(&self) -> AtanhRef
[src]
Computes the inverse hyperbolic tangent.
Examples
use rug::Complex; let c = Complex::with_val(53, (1, 1)); let atanh = Complex::with_val(53, c.atanh_ref()); let expected = Complex::with_val(53, (0.4024, 1.0172)); assert!((atanh - expected).abs() < 0.0001);
Trait Implementations
impl Default for SmallComplex
[src]
fn default() -> SmallComplex
[src]
Returns the "default value" for a type. Read more
impl Deref for SmallComplex
[src]
type Target = Complex
The resulting type after dereferencing.
fn deref(&self) -> &Complex
[src]
Dereferences the value.
impl<T> From<T> for SmallComplex where
SmallComplex: Assign<T>,
[src]
SmallComplex: Assign<T>,
fn from(val: T) -> SmallComplex
[src]
Performs the conversion.