Struct rug::complex::BorrowComplex
source · #[repr(transparent)]pub struct BorrowComplex<'a> { /* private fields */ }
Expand description
Used to get a reference to a Complex
number.
The struct implements Deref<Target = Complex>
.
No memory is unallocated when this struct is dropped.
Examples
use rug::complex::BorrowComplex;
use rug::Complex;
let c = Complex::with_val(53, (4.2, -2.3));
let neg: BorrowComplex = c.as_neg();
// c is still valid
assert_eq!(c, (4.2, -2.3));
assert_eq!(*neg, (-4.2, 2.3));
Implementations§
source§impl<'a> BorrowComplex<'a>
impl<'a> BorrowComplex<'a>
sourcepub const unsafe fn from_raw(raw: mpc_t) -> BorrowComplex<'a>
pub const unsafe fn from_raw(raw: mpc_t) -> BorrowComplex<'a>
Create a borrow from a raw MPC complex number.
Safety
- The value must be initialized as a valid
mpc_t
. - The
mpc_t
type can be considered as a kind of pointer, so there can be multiple copies of it.BorrowComplex
cannot mutate the value, so there can be other copies, but none of them are allowed to mutate the value. - The lifetime is obtained from the return type. The user must ensure the value remains valid for the duration of the lifetime.
Examples
use rug::complex::BorrowComplex;
use rug::Complex;
let c = Complex::with_val(53, (4.2, -2.3));
// Safety: c.as_raw() is a valid pointer.
let raw = unsafe { *c.as_raw() };
// Safety: c is still valid when borrow is used.
let borrow = unsafe { BorrowComplex::from_raw(raw) };
assert_eq!(c, *borrow);
sourcepub const fn const_deref<'b>(b: &'b BorrowComplex<'a>) -> &'b Complex
pub const fn const_deref<'b>(b: &'b BorrowComplex<'a>) -> &'b Complex
Gets a reference to Complex
from a BorrowComplex
.
This is equivalent to taking the reference of the dereferencing operator
*
or to Deref::deref
, but can also be
used in constant context. Unless required in constant context, use the
operator or trait instead.
Planned deprecation
This method will be deprecated when the unary *
operator and the
Deref
trait are usable in constant context.
Examples
use core::ops::Deref;
use core::ptr;
use rug::complex::BorrowComplex;
use rug::Complex;
let c = Complex::with_val(53, (23.5, -12.25));
let b = c.as_conj();
let using_method: &Complex = BorrowComplex::const_deref(&b);
let using_operator: &Complex = &*b;
let using_trait: &Complex = b.deref();
assert_eq!(*using_method, (23.5, 12.25));
assert!(ptr::eq(using_method, using_operator));
assert!(ptr::eq(using_method, using_trait));
This method can be used to create a constant reference.
use core::ptr::NonNull;
use gmp_mpfr_sys::gmp::limb_t;
use gmp_mpfr_sys::mpfr::{mpfr_t, prec_t};
use gmp_mpfr_sys::mpc::mpc_t;
use rug::complex::BorrowComplex;
use rug::{Complex, Float};
const LIMBS: [limb_t; 2] = [5, 1 << (limb_t::BITS - 1)];
const LIMBS_PTR: *const [limb_t; 2] = &LIMBS;
const MANTISSA_DIGITS: u32 = limb_t::BITS * 2;
const MPC: mpc_t = mpc_t {
re: mpfr_t {
prec: MANTISSA_DIGITS as prec_t,
sign: -1,
exp: 1,
d: unsafe { NonNull::new_unchecked(LIMBS_PTR.cast_mut().cast()) },
},
im: mpfr_t {
prec: MANTISSA_DIGITS as prec_t,
sign: 1,
exp: 1,
d: unsafe { NonNull::new_unchecked(LIMBS_PTR.cast_mut().cast()) },
},
};
// Safety: MPFR will remain valid, and will not be changed.
const BORROW: BorrowComplex = unsafe { BorrowComplex::from_raw(MPC) };
const C: &Complex = BorrowComplex::const_deref(&BORROW);
let lsig = Float::with_val(MANTISSA_DIGITS, 5) >> (MANTISSA_DIGITS - 1);
let msig = 1u32;
let val = lsig + msig;
let check = Complex::from((-val.clone(), val));
assert_eq!(*C, check);
Methods from Deref<Target = Complex>§
sourcepub fn prec(&self) -> (u32, u32)
pub 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));
sourcepub fn as_raw(&self) -> *const mpc_t
pub fn as_raw(&self) -> *const mpc_t
Returns a pointer to the inner MPC complex number.
The returned pointer will be valid for as long as self
is valid.
Examples
use gmp_mpfr_sys::mpc;
use gmp_mpfr_sys::mpfr;
use gmp_mpfr_sys::mpfr::rnd_t;
use rug::Complex;
let c = Complex::with_val(53, (-14.5, 3.25));
let m_ptr = c.as_raw();
unsafe {
let re_ptr = mpc::realref_const(m_ptr);
let re = mpfr::get_d(re_ptr, rnd_t::RNDN);
assert_eq!(re, -14.5);
let im_ptr = mpc::imagref_const(m_ptr);
let im = mpfr::get_d(im_ptr, rnd_t::RNDN);
assert_eq!(im, 3.25);
}
// c is still valid
assert_eq!(c, (-14.5, 3.25));
sourcepub fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
pub 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.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::Complex;
let c1 = Complex::with_val(53, 0);
assert_eq!(c1.to_string_radix(10, None), "(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)), "(10.0 -4.00)");
assert_eq!(c3.to_string_radix(5, Some(3)), "(20.0 -4.00)");
// 2 raised to the power of 80 in hex is 1 followed by 20 zeros
let c4 = Complex::with_val(53, (80f64.exp2(), 0.25));
assert_eq!(c4.to_string_radix(10, Some(3)), "(1.21e24 2.50e-1)");
assert_eq!(c4.to_string_radix(16, Some(3)), "(1.00@20 4.00@-1)");
sourcepub fn to_string_radix_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: (Round, Round)
) -> String
pub 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.
Panics
Panics if radix
is less than 2 or greater than 36.
Examples
use rug::float::Round;
use rug::Complex;
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, "(10.406 0)");
let nu = c.to_string_radix_round(10, None, up);
assert_eq!(nu, "(10.407 0)");
let sd = c.to_string_radix_round(10, Some(2), down);
assert_eq!(sd, "(10 0)");
let sn = c.to_string_radix_round(10, Some(2), nearest);
assert_eq!(sn, "(10 0)");
let su = c.to_string_radix_round(10, Some(2), up);
assert_eq!(su, "(11 0)");
sourcepub fn as_neg(&self) -> BorrowComplex<'_>
pub fn as_neg(&self) -> BorrowComplex<'_>
Borrows a negated copy of the Complex
number.
The returned object implements Deref<Target = Complex>
.
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);
sourcepub fn as_conj(&self) -> BorrowComplex<'_>
pub fn as_conj(&self) -> BorrowComplex<'_>
Borrows a conjugate copy of the Complex
number.
The returned object implements Deref<Target = Complex>
.
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);
sourcepub fn as_mul_i(&self, negative: bool) -> BorrowComplex<'_>
pub fn as_mul_i(&self, negative: bool) -> BorrowComplex<'_>
Borrows a rotated copy of the Complex
number.
The returned object implements Deref<Target = Complex>
.
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);
sourcepub fn as_ord(&self) -> &OrdComplex
pub fn as_ord(&self) -> &OrdComplex
Borrows the Complex
number as an ordered complex number of type
OrdComplex
.
The same result can be obtained using the implementation of
AsRef<OrdComplex>
which is provided for Complex
.
Examples
use core::cmp::Ordering;
use rug::float::Special;
use rug::Complex;
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);
sourcepub fn cmp_abs(&self, other: &Self) -> Option<Ordering>
pub fn cmp_abs(&self, other: &Self) -> Option<Ordering>
Compares the absolute values of self
and other
.
Examples
use core::cmp::Ordering;
use rug::Complex;
let five = Complex::with_val(53, (5, 0));
let five_rotated = Complex::with_val(53, (3, -4));
let greater_than_five = Complex::with_val(53, (-4, -4));
let has_nan = Complex::with_val(53, (5, 0.0 / 0.0));
assert_eq!(five.cmp_abs(&five_rotated), Some(Ordering::Equal));
assert_eq!(five.cmp_abs(&greater_than_five), Some(Ordering::Less));
assert_eq!(five.cmp_abs(&has_nan), None);
sourcepub fn total_cmp(&self, other: &Complex) -> Ordering
pub fn total_cmp(&self, other: &Complex) -> Ordering
Returns the total ordering between self
and other
.
For ordering, the real part has precedence over the imaginary part. Negative zero is ordered as less than positive zero. Negative NaN is ordered as less than negative infinity, while positive NaN is ordered as greater than positive infinity. Comparing two negative NaNs or two positive NaNs produces equality.
Examples
use rug::float::Special;
use rug::Complex;
let mut values = vec![
Complex::with_val(53, (Special::Zero, Special::Zero)),
Complex::with_val(53, (Special::Zero, Special::NegZero)),
Complex::with_val(53, (Special::NegZero, Special::Infinity)),
];
values.sort_by(Complex::total_cmp);
// (-0, +∞)
assert!(values[0].real().is_zero() && values[0].real().is_sign_negative());
assert!(values[0].imag().is_infinite() && values[0].imag().is_sign_positive());
// (+0, -0)
assert!(values[1].real().is_zero() && values[1].real().is_sign_positive());
assert!(values[1].imag().is_zero() && values[1].imag().is_sign_negative());
// (+0, +0)
assert!(values[2].real().is_zero() && values[2].real().is_sign_positive());
assert!(values[2].imag().is_zero() && values[2].imag().is_sign_positive());
sourcepub fn mul_add_ref<'a>(
&'a self,
mul: &'a Self,
add: &'a Self
) -> AddMulIncomplete<'a>
pub fn mul_add_ref<'a>( &'a self, mul: &'a Self, add: &'a Self ) -> AddMulIncomplete<'a>
Multiplies and adds in one fused operation.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
a.mul_add_ref(&b, &c)
produces the exact same result as
&a * &b + &c
.
Examples
use rug::Complex;
let a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) × (1 - i) + (1000 + 1000i) = (1010 + 990i)
let ans = Complex::with_val(53, a.mul_add_ref(&b, &c));
assert_eq!(ans, (1010, 990));
sourcepub fn mul_sub_ref<'a>(
&'a self,
mul: &'a Self,
sub: &'a Self
) -> SubMulFromIncomplete<'a>
pub fn mul_sub_ref<'a>( &'a self, mul: &'a Self, sub: &'a Self ) -> SubMulFromIncomplete<'a>
Multiplies and subtracts in one fused operation.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
a.mul_sub_ref(&b, &c)
produces the exact same result as &a * &b - &c
.
Examples
use rug::Complex;
let a = Complex::with_val(53, (10, 0));
let b = Complex::with_val(53, (1, -1));
let c = Complex::with_val(53, (1000, 1000));
// (10 + 0i) × (1 - i) - (1000 + 1000i) = (-990 - 1010i)
let ans = Complex::with_val(53, a.mul_sub_ref(&b, &c));
assert_eq!(ans, (-990, -1010));
sourcepub fn proj_ref(&self) -> ProjIncomplete<'_>
pub fn proj_ref(&self) -> ProjIncomplete<'_>
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.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
Examples
use rug::Complex;
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());
sourcepub fn square_ref(&self) -> SquareIncomplete<'_>
pub fn square_ref(&self) -> SquareIncomplete<'_>
Computes the square.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
Examples
use core::cmp::Ordering;
use rug::float::Round;
use rug::Complex;
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));
sourcepub fn sqrt_ref(&self) -> SqrtIncomplete<'_>
pub fn sqrt_ref(&self) -> SqrtIncomplete<'_>
Computes the square root.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
Examples
use core::cmp::Ordering;
use rug::float::Round;
use rug::Complex;
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));
sourcepub fn conj_ref(&self) -> ConjIncomplete<'_>
pub fn conj_ref(&self) -> ConjIncomplete<'_>
Computes the complex conjugate.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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));
sourcepub fn abs_ref(&self) -> AbsIncomplete<'_>
pub fn abs_ref(&self) -> AbsIncomplete<'_>
Computes the absolute value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
Assign<Src> for Complex
AssignRound<Src> for Float
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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);
sourcepub fn arg_ref(&self) -> ArgIncomplete<'_>
pub fn arg_ref(&self) -> ArgIncomplete<'_>
Computes the argument.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
Assign<Src> for Complex
AssignRound<Src> for Float
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
Examples
use core::f64;
use rug::{Assign, Complex, Float};
// 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);
sourcepub fn mul_i_ref(&self, negative: bool) -> MulIIncomplete<'_>
pub fn mul_i_ref(&self, negative: bool) -> MulIIncomplete<'_>
Multiplies the complex number by ±i.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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));
sourcepub fn recip_ref(&self) -> RecipIncomplete<'_>
pub fn recip_ref(&self) -> RecipIncomplete<'_>
Computes the reciprocal.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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));
sourcepub fn norm_ref(&self) -> NormIncomplete<'_>
pub fn norm_ref(&self) -> NormIncomplete<'_>
Computes the norm, that is the square of the absolute value.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Float
Assign<Src> for Complex
AssignRound<Src> for Float
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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);
sourcepub fn ln_ref(&self) -> LnIncomplete<'_>
pub fn ln_ref(&self) -> LnIncomplete<'_>
Computes the natural logarithm.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn log10_ref(&self) -> Log10Incomplete<'_>
pub fn log10_ref(&self) -> Log10Incomplete<'_>
Computes the logarithm to base 10.
The following are implemented with the returned
incomplete-computation value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn exp_ref(&self) -> ExpIncomplete<'_>
pub fn exp_ref(&self) -> ExpIncomplete<'_>
Computes the exponential.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn sin_ref(&self) -> SinIncomplete<'_>
pub fn sin_ref(&self) -> SinIncomplete<'_>
Computes the sine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn cos_ref(&self) -> CosIncomplete<'_>
pub fn cos_ref(&self) -> CosIncomplete<'_>
Computes the cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn sin_cos_ref(&self) -> SinCosIncomplete<'_>
pub fn sin_cos_ref(&self) -> SinCosIncomplete<'_>
Computes the sine and cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for (Complex, Complex)
Assign<Src> for (&mut Complex, &mut Complex)
AssignRound<Src> for (Complex, Complex)
AssignRound<Src> for (&mut Complex, &mut Complex)
CompleteRound<Completed = (Complex, Complex)> for Src
Examples
use core::cmp::Ordering;
use rug::float::Round;
use rug::ops::AssignRound;
use rug::{Assign, Complex};
let phase = Complex::with_val(53, (1, 1));
let (mut sin, mut cos) = (Complex::new(53), Complex::new(53));
let sin_cos = phase.sin_cos_ref();
(&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().real() < 0.0001);
assert!(*(cos - expected_cos).abs().real() < 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 sin_cos = phase.sin_cos_ref();
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));
sourcepub fn tan_ref(&self) -> TanIncomplete<'_>
pub fn tan_ref(&self) -> TanIncomplete<'_>
Computes the tangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn sinh_ref(&self) -> SinhIncomplete<'_>
pub fn sinh_ref(&self) -> SinhIncomplete<'_>
Computes the hyperbolic sine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn cosh_ref(&self) -> CoshIncomplete<'_>
pub fn cosh_ref(&self) -> CoshIncomplete<'_>
Computes the hyperbolic cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn tanh_ref(&self) -> TanhIncomplete<'_>
pub fn tanh_ref(&self) -> TanhIncomplete<'_>
Computes the hyperbolic tangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn asin_ref(&self) -> AsinIncomplete<'_>
pub fn asin_ref(&self) -> AsinIncomplete<'_>
Computes the inverse sine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn acos_ref(&self) -> AcosIncomplete<'_>
pub fn acos_ref(&self) -> AcosIncomplete<'_>
Computes the inverse cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn atan_ref(&self) -> AtanIncomplete<'_>
pub fn atan_ref(&self) -> AtanIncomplete<'_>
Computes the inverse tangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn asinh_ref(&self) -> AsinhIncomplete<'_>
pub fn asinh_ref(&self) -> AsinhIncomplete<'_>
Computes the inverse hyperboic sine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn acosh_ref(&self) -> AcoshIncomplete<'_>
pub fn acosh_ref(&self) -> AcoshIncomplete<'_>
Computes the inverse hyperbolic cosine.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn atanh_ref(&self) -> AtanhIncomplete<'_>
pub fn atanh_ref(&self) -> AtanhIncomplete<'_>
Computes the inverse hyperbolic tangent.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
CompleteRound<Completed = Complex> for Src
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().real() < 0.0001);
sourcepub fn agm_ref<'a>(&'a self, other: &'a Self) -> AgmIncomplete<'_>
pub fn agm_ref<'a>(&'a self, other: &'a Self) -> AgmIncomplete<'_>
Computes the arithmetic-geometric mean.
The following are implemented with the returned incomplete-computation
value as Src
:
Assign<Src> for Complex
AssignRound<Src> for Complex
Examples
use rug::Complex;
let f = Complex::with_val(53, (1.25, 1.0));
let g = Complex::with_val(53, (3.75, -1.0));
let agm = Complex::with_val(53, f.agm_ref(&g));
let expected = Complex::with_val(53, (2.4763, 0.2571));
assert!(*(agm - expected).abs().real() < 0.0001);
Trait Implementations§
source§impl Binary for BorrowComplex<'_>
impl Binary for BorrowComplex<'_>
source§impl<'a> Clone for BorrowComplex<'a>
impl<'a> Clone for BorrowComplex<'a>
source§fn clone(&self) -> BorrowComplex<'a>
fn clone(&self) -> BorrowComplex<'a>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read more