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 types of the
primitives used to set its real and imaginary parts. Note that if
different types are used to set the parts, the parts can have
different precisions.
i8
,u8
: the part will have eight bits of precision.i16
,u16
: the part will have 16 bits of precision.i32
,u32
: the part will have 32 bits of precision.i64
,u64
: the part will have 64 bits of precision.i128
,u128
: (if supported by the compiler) theSmallFloat
will have 128 bits of precision.isize
,usize
: the part will have 32 or 64 bits of precision, depending on the platform.f32
: the part will have 24 bits of precision.f64
: the part will have 53 bits of precision.
The SmallComplex
type can be coerced to a Complex
, as it
implements Deref<Target = Complex>
.
Examples
use rug::complex::SmallComplex; use rug::Complex; // `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]
impl SmallComplex
pub unsafe fn as_nonreallocating_complex(&mut self) -> &mut Complex
[src]
pub unsafe fn as_nonreallocating_complex(&mut self) -> &mut Complex
Returns a mutable reference to a Complex
number for simple
operations that do not need to change the precision of the
real or imaginary part.
Safety
It is undefined behaviour to modify the precision of the
referenced Complex
number or to swap it with another
number.
Examples
use rug::complex::SmallComplex; let mut c = SmallComplex::from((1.0f32, 3.0f32)); // rotation does not change the precision unsafe { c.as_nonreallocating_complex().mul_i_mut(false); } assert_eq!(*c, (-3.0, 1.0));
Methods from Deref<Target = Complex>
pub fn prec(&self) -> (u32, u32)
[src]
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));
pub fn as_raw(&self) -> *const mpc_t
[src]
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
extern crate gmp_mpfr_sys; extern crate rug; use gmp_mpfr_sys::{mpc, mpfr}; use rug::Complex; fn main() { 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, mpfr::rnd_t::RNDN); assert_eq!(re, -14.5); let im_ptr = mpc::imagref_const(m_ptr); let im = mpfr::get_d(im_ptr, mpfr::rnd_t::RNDN); assert_eq!(im, 3.25); } // c is still valid assert_eq!(c, (-14.5, 3.25)); }
pub fn to_string_radix(&self, radix: i32, num_digits: Option<usize>) -> String
[src]
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 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)");
pub fn to_string_radix_round(
&self,
radix: i32,
num_digits: Option<usize>,
round: (Round, Round)
) -> String
[src]
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, "(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)");
pub fn real(&self) -> &Float
[src]
pub 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)
pub fn imag(&self) -> &Float
[src]
pub 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)
pub fn as_neg(&self) -> BorrowComplex
[src]
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);
pub fn as_conj(&self) -> BorrowComplex
[src]
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);
pub fn as_mul_i(&self, negative: bool) -> BorrowComplex
[src]
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);
pub fn as_ord(&self) -> &OrdComplex
[src]
pub fn as_ord(&self) -> &OrdComplex
Borrows the Complex
number as an ordered complex number of
type OrdComplex
.
Examples
use rug::float::Special; use rug::Complex; 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);
pub fn eq0(&self) -> bool
[src]
pub fn eq0(&self) -> bool
Returns the same result as self.eq(&0)
, but is
faster.
Examples
use rug::float::Special; use rug::{Assign, Complex}; let mut c = Complex::with_val(53, (Special::NegZero, Special::Zero)); assert!(c.eq0()); c += 5.2; assert!(!c.eq0()); c.mut_real().assign(Special::Nan); assert!(!c.eq0());
pub fn cmp_abs(&self, other: &Self) -> Option<Ordering>
[src]
pub fn cmp_abs(&self, other: &Self) -> Option<Ordering>
Compares the absolute values of self
and other
.
Examples
use rug::Complex; use std::cmp::Ordering; 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);
pub fn mul_add_ref<'a>(
&'a self,
mul: &'a Self,
add: &'a Self
) -> AddMulIncomplete<'a>
[src]
pub fn mul_add_ref<'a>(
&'a self,
mul: &'a Self,
add: &'a Self
) -> AddMulIncomplete<'a>
Multiplies and adds in one fused operation.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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));
pub fn mul_sub_ref<'a>(
&'a self,
mul: &'a Self,
sub: &'a Self
) -> SubMulFromIncomplete<'a>
[src]
pub fn mul_sub_ref<'a>(
&'a self,
mul: &'a Self,
sub: &'a Self
) -> SubMulFromIncomplete<'a>
Multiplies and subtracts in one fused operation.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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));
pub fn proj_ref(&self) -> ProjIncomplete
[src]
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.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as Src
.
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());
pub fn square_ref(&self) -> SquareIncomplete
[src]
pub fn square_ref(&self) -> SquareIncomplete
Computes the square.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as Src
.
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));
pub fn sqrt_ref(&self) -> SqrtIncomplete
[src]
pub fn sqrt_ref(&self) -> SqrtIncomplete
Computes the square root.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as Src
.
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));
pub fn conj_ref(&self) -> ConjIncomplete
[src]
pub fn conj_ref(&self) -> ConjIncomplete
Computes the complex conjugate.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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));
pub fn abs_ref(&self) -> AbsIncomplete
[src]
pub fn abs_ref(&self) -> AbsIncomplete
Computes the absolute value.
Assign<Src> for Float
,
Assign<Src> for Complex
,
AssignRound<Src> for Float
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn arg_ref(&self) -> ArgIncomplete
[src]
pub fn arg_ref(&self) -> ArgIncomplete
Computes the argument.
Assign<Src> for Float
,
Assign<Src> for Complex
,
AssignRound<Src> for Float
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as Src
.
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);
pub fn mul_i_ref(&self, negative: bool) -> MulIIncomplete
[src]
pub fn mul_i_ref(&self, negative: bool) -> MulIIncomplete
Multiplies the complex number by ±i.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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));
pub fn recip_ref(&self) -> RecipIncomplete
[src]
pub fn recip_ref(&self) -> RecipIncomplete
Computes the reciprocal.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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));
pub fn norm_ref(&self) -> NormIncomplete
[src]
pub fn norm_ref(&self) -> NormIncomplete
Computes the norm, that is the square of the absolute value.
Assign<Src> for Float
,
Assign<Src> for Complex
,
AssignRound<Src> for Float
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn ln_ref(&self) -> LnIncomplete
[src]
pub fn ln_ref(&self) -> LnIncomplete
Computes the natural logarithm;
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn log10_ref(&self) -> Log10Incomplete
[src]
pub fn log10_ref(&self) -> Log10Incomplete
Computes the logarithm to base 10.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn exp_ref(&self) -> ExpIncomplete
[src]
pub fn exp_ref(&self) -> ExpIncomplete
Computes the exponential.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn sin_ref(&self) -> SinIncomplete
[src]
pub fn sin_ref(&self) -> SinIncomplete
Computes the sine.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn cos_ref(&self) -> CosIncomplete
[src]
pub fn cos_ref(&self) -> CosIncomplete
Computes the cosine.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn sin_cos_ref(&self) -> SinCosIncomplete
[src]
pub fn sin_cos_ref(&self) -> SinCosIncomplete
Computes the sine and cosine.
Assign<Src> for (Complex, Complex)
,
Assign<Src> for (&mut Complex, &mut Complex)
,
AssignRound<Src> for (Complex, Complex)
and
AssignRound<Src> for (&mut Complex, &mut Complex)
are implemented with the returned
incomplete-computation value as Src
.
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 (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));
pub fn tan_ref(&self) -> TanIncomplete
[src]
pub fn tan_ref(&self) -> TanIncomplete
Computes the tangent.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn sinh_ref(&self) -> SinhIncomplete
[src]
pub fn sinh_ref(&self) -> SinhIncomplete
Computes the hyperbolic sine.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn cosh_ref(&self) -> CoshIncomplete
[src]
pub fn cosh_ref(&self) -> CoshIncomplete
Computes the hyperbolic cosine.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn tanh_ref(&self) -> TanhIncomplete
[src]
pub fn tanh_ref(&self) -> TanhIncomplete
Computes the hyperbolic tangent.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn asin_ref(&self) -> AsinIncomplete
[src]
pub fn asin_ref(&self) -> AsinIncomplete
Computes the inverse sine.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn acos_ref(&self) -> AcosIncomplete
[src]
pub fn acos_ref(&self) -> AcosIncomplete
Computes the inverse cosine.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn atan_ref(&self) -> AtanIncomplete
[src]
pub fn atan_ref(&self) -> AtanIncomplete
Computes the inverse tangent.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn asinh_ref(&self) -> AsinhIncomplete
[src]
pub fn asinh_ref(&self) -> AsinhIncomplete
Computes the inverse hyperboic sine.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn acosh_ref(&self) -> AcoshIncomplete
[src]
pub fn acosh_ref(&self) -> AcoshIncomplete
Computes the inverse hyperbolic cosine.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
pub fn atanh_ref(&self) -> AtanhIncomplete
[src]
pub fn atanh_ref(&self) -> AtanhIncomplete
Computes the inverse hyperbolic tangent.
Assign<Src> for Complex
and
AssignRound<Src> for Complex
are
implemented with the returned
incomplete-computation value as 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);
Trait Implementations
impl Clone for SmallComplex
[src]
impl Clone for SmallComplex
fn clone(&self) -> SmallComplex
[src]
fn clone(&self) -> SmallComplex
Returns a copy of the value. Read more
fn clone_from(&mut self, source: &Self)
1.0.0[src]
fn clone_from(&mut self, source: &Self)
Performs copy-assignment from source
. Read more
impl Deref for SmallComplex
[src]
impl Deref for SmallComplex
type Target = Complex
The resulting type after dereferencing.
fn deref(&self) -> &Complex
[src]
fn deref(&self) -> &Complex
Dereferences the value.
impl<Re> From<Re> for SmallComplex where
SmallFloat: From<Re>,
[src]
impl<Re> From<Re> for SmallComplex where
SmallFloat: From<Re>,
impl<Re, Im> From<(Re, Im)> for SmallComplex where
SmallFloat: From<Re> + From<Im>,
[src]
impl<Re, Im> From<(Re, Im)> for SmallComplex where
SmallFloat: From<Re> + From<Im>,
impl Assign<i8> for SmallComplex
[src]
impl Assign<i8> for SmallComplex
impl Assign<(i8, i8)> for SmallComplex
[src]
impl Assign<(i8, i8)> for SmallComplex
impl Assign<(i8, i16)> for SmallComplex
[src]
impl Assign<(i8, i16)> for SmallComplex
impl Assign<(i8, i32)> for SmallComplex
[src]
impl Assign<(i8, i32)> for SmallComplex
impl Assign<(i8, i64)> for SmallComplex
[src]
impl Assign<(i8, i64)> for SmallComplex
impl Assign<(i8, i128)> for SmallComplex
[src]
impl Assign<(i8, i128)> for SmallComplex
impl Assign<(i8, isize)> for SmallComplex
[src]
impl Assign<(i8, isize)> for SmallComplex
impl Assign<(i8, u8)> for SmallComplex
[src]
impl Assign<(i8, u8)> for SmallComplex
impl Assign<(i8, u16)> for SmallComplex
[src]
impl Assign<(i8, u16)> for SmallComplex
impl Assign<(i8, u32)> for SmallComplex
[src]
impl Assign<(i8, u32)> for SmallComplex
impl Assign<(i8, u64)> for SmallComplex
[src]
impl Assign<(i8, u64)> for SmallComplex
impl Assign<(i8, u128)> for SmallComplex
[src]
impl Assign<(i8, u128)> for SmallComplex
impl Assign<(i8, usize)> for SmallComplex
[src]
impl Assign<(i8, usize)> for SmallComplex
impl Assign<(i8, f32)> for SmallComplex
[src]
impl Assign<(i8, f32)> for SmallComplex
impl Assign<(i8, f64)> for SmallComplex
[src]
impl Assign<(i8, f64)> for SmallComplex
impl Assign<i16> for SmallComplex
[src]
impl Assign<i16> for SmallComplex
impl Assign<(i16, i8)> for SmallComplex
[src]
impl Assign<(i16, i8)> for SmallComplex
impl Assign<(i16, i16)> for SmallComplex
[src]
impl Assign<(i16, i16)> for SmallComplex
impl Assign<(i16, i32)> for SmallComplex
[src]
impl Assign<(i16, i32)> for SmallComplex
impl Assign<(i16, i64)> for SmallComplex
[src]
impl Assign<(i16, i64)> for SmallComplex
impl Assign<(i16, i128)> for SmallComplex
[src]
impl Assign<(i16, i128)> for SmallComplex
impl Assign<(i16, isize)> for SmallComplex
[src]
impl Assign<(i16, isize)> for SmallComplex
impl Assign<(i16, u8)> for SmallComplex
[src]
impl Assign<(i16, u8)> for SmallComplex
impl Assign<(i16, u16)> for SmallComplex
[src]
impl Assign<(i16, u16)> for SmallComplex
impl Assign<(i16, u32)> for SmallComplex
[src]
impl Assign<(i16, u32)> for SmallComplex
impl Assign<(i16, u64)> for SmallComplex
[src]
impl Assign<(i16, u64)> for SmallComplex
impl Assign<(i16, u128)> for SmallComplex
[src]
impl Assign<(i16, u128)> for SmallComplex
impl Assign<(i16, usize)> for SmallComplex
[src]
impl Assign<(i16, usize)> for SmallComplex
impl Assign<(i16, f32)> for SmallComplex
[src]
impl Assign<(i16, f32)> for SmallComplex
impl Assign<(i16, f64)> for SmallComplex
[src]
impl Assign<(i16, f64)> for SmallComplex
impl Assign<i32> for SmallComplex
[src]
impl Assign<i32> for SmallComplex
impl Assign<(i32, i8)> for SmallComplex
[src]
impl Assign<(i32, i8)> for SmallComplex
impl Assign<(i32, i16)> for SmallComplex
[src]
impl Assign<(i32, i16)> for SmallComplex
impl Assign<(i32, i32)> for SmallComplex
[src]
impl Assign<(i32, i32)> for SmallComplex
impl Assign<(i32, i64)> for SmallComplex
[src]
impl Assign<(i32, i64)> for SmallComplex
impl Assign<(i32, i128)> for SmallComplex
[src]
impl Assign<(i32, i128)> for SmallComplex
impl Assign<(i32, isize)> for SmallComplex
[src]
impl Assign<(i32, isize)> for SmallComplex
impl Assign<(i32, u8)> for SmallComplex
[src]
impl Assign<(i32, u8)> for SmallComplex
impl Assign<(i32, u16)> for SmallComplex
[src]
impl Assign<(i32, u16)> for SmallComplex
impl Assign<(i32, u32)> for SmallComplex
[src]
impl Assign<(i32, u32)> for SmallComplex
impl Assign<(i32, u64)> for SmallComplex
[src]
impl Assign<(i32, u64)> for SmallComplex
impl Assign<(i32, u128)> for SmallComplex
[src]
impl Assign<(i32, u128)> for SmallComplex
impl Assign<(i32, usize)> for SmallComplex
[src]
impl Assign<(i32, usize)> for SmallComplex
impl Assign<(i32, f32)> for SmallComplex
[src]
impl Assign<(i32, f32)> for SmallComplex
impl Assign<(i32, f64)> for SmallComplex
[src]
impl Assign<(i32, f64)> for SmallComplex
impl Assign<i64> for SmallComplex
[src]
impl Assign<i64> for SmallComplex
impl Assign<(i64, i8)> for SmallComplex
[src]
impl Assign<(i64, i8)> for SmallComplex
impl Assign<(i64, i16)> for SmallComplex
[src]
impl Assign<(i64, i16)> for SmallComplex
impl Assign<(i64, i32)> for SmallComplex
[src]
impl Assign<(i64, i32)> for SmallComplex
impl Assign<(i64, i64)> for SmallComplex
[src]
impl Assign<(i64, i64)> for SmallComplex
impl Assign<(i64, i128)> for SmallComplex
[src]
impl Assign<(i64, i128)> for SmallComplex
impl Assign<(i64, isize)> for SmallComplex
[src]
impl Assign<(i64, isize)> for SmallComplex
impl Assign<(i64, u8)> for SmallComplex
[src]
impl Assign<(i64, u8)> for SmallComplex
impl Assign<(i64, u16)> for SmallComplex
[src]
impl Assign<(i64, u16)> for SmallComplex
impl Assign<(i64, u32)> for SmallComplex
[src]
impl Assign<(i64, u32)> for SmallComplex
impl Assign<(i64, u64)> for SmallComplex
[src]
impl Assign<(i64, u64)> for SmallComplex
impl Assign<(i64, u128)> for SmallComplex
[src]
impl Assign<(i64, u128)> for SmallComplex
impl Assign<(i64, usize)> for SmallComplex
[src]
impl Assign<(i64, usize)> for SmallComplex
impl Assign<(i64, f32)> for SmallComplex
[src]
impl Assign<(i64, f32)> for SmallComplex
impl Assign<(i64, f64)> for SmallComplex
[src]
impl Assign<(i64, f64)> for SmallComplex
impl Assign<i128> for SmallComplex
[src]
impl Assign<i128> for SmallComplex
impl Assign<(i128, i8)> for SmallComplex
[src]
impl Assign<(i128, i8)> for SmallComplex
impl Assign<(i128, i16)> for SmallComplex
[src]
impl Assign<(i128, i16)> for SmallComplex
impl Assign<(i128, i32)> for SmallComplex
[src]
impl Assign<(i128, i32)> for SmallComplex
impl Assign<(i128, i64)> for SmallComplex
[src]
impl Assign<(i128, i64)> for SmallComplex
impl Assign<(i128, i128)> for SmallComplex
[src]
impl Assign<(i128, i128)> for SmallComplex
impl Assign<(i128, isize)> for SmallComplex
[src]
impl Assign<(i128, isize)> for SmallComplex
impl Assign<(i128, u8)> for SmallComplex
[src]
impl Assign<(i128, u8)> for SmallComplex
impl Assign<(i128, u16)> for SmallComplex
[src]
impl Assign<(i128, u16)> for SmallComplex
impl Assign<(i128, u32)> for SmallComplex
[src]
impl Assign<(i128, u32)> for SmallComplex
impl Assign<(i128, u64)> for SmallComplex
[src]
impl Assign<(i128, u64)> for SmallComplex
impl Assign<(i128, u128)> for SmallComplex
[src]
impl Assign<(i128, u128)> for SmallComplex
impl Assign<(i128, usize)> for SmallComplex
[src]
impl Assign<(i128, usize)> for SmallComplex
impl Assign<(i128, f32)> for SmallComplex
[src]
impl Assign<(i128, f32)> for SmallComplex
impl Assign<(i128, f64)> for SmallComplex
[src]
impl Assign<(i128, f64)> for SmallComplex
impl Assign<isize> for SmallComplex
[src]
impl Assign<isize> for SmallComplex
impl Assign<(isize, i8)> for SmallComplex
[src]
impl Assign<(isize, i8)> for SmallComplex
impl Assign<(isize, i16)> for SmallComplex
[src]
impl Assign<(isize, i16)> for SmallComplex
impl Assign<(isize, i32)> for SmallComplex
[src]
impl Assign<(isize, i32)> for SmallComplex
impl Assign<(isize, i64)> for SmallComplex
[src]
impl Assign<(isize, i64)> for SmallComplex
impl Assign<(isize, i128)> for SmallComplex
[src]
impl Assign<(isize, i128)> for SmallComplex
impl Assign<(isize, isize)> for SmallComplex
[src]
impl Assign<(isize, isize)> for SmallComplex
impl Assign<(isize, u8)> for SmallComplex
[src]
impl Assign<(isize, u8)> for SmallComplex
impl Assign<(isize, u16)> for SmallComplex
[src]
impl Assign<(isize, u16)> for SmallComplex
impl Assign<(isize, u32)> for SmallComplex
[src]
impl Assign<(isize, u32)> for SmallComplex
impl Assign<(isize, u64)> for SmallComplex
[src]
impl Assign<(isize, u64)> for SmallComplex
impl Assign<(isize, u128)> for SmallComplex
[src]
impl Assign<(isize, u128)> for SmallComplex
impl Assign<(isize, usize)> for SmallComplex
[src]
impl Assign<(isize, usize)> for SmallComplex
impl Assign<(isize, f32)> for SmallComplex
[src]
impl Assign<(isize, f32)> for SmallComplex
impl Assign<(isize, f64)> for SmallComplex
[src]
impl Assign<(isize, f64)> for SmallComplex
impl Assign<u8> for SmallComplex
[src]
impl Assign<u8> for SmallComplex
impl Assign<(u8, i8)> for SmallComplex
[src]
impl Assign<(u8, i8)> for SmallComplex
impl Assign<(u8, i16)> for SmallComplex
[src]
impl Assign<(u8, i16)> for SmallComplex
impl Assign<(u8, i32)> for SmallComplex
[src]
impl Assign<(u8, i32)> for SmallComplex
impl Assign<(u8, i64)> for SmallComplex
[src]
impl Assign<(u8, i64)> for SmallComplex
impl Assign<(u8, i128)> for SmallComplex
[src]
impl Assign<(u8, i128)> for SmallComplex
impl Assign<(u8, isize)> for SmallComplex
[src]
impl Assign<(u8, isize)> for SmallComplex
impl Assign<(u8, u8)> for SmallComplex
[src]
impl Assign<(u8, u8)> for SmallComplex
impl Assign<(u8, u16)> for SmallComplex
[src]
impl Assign<(u8, u16)> for SmallComplex
impl Assign<(u8, u32)> for SmallComplex
[src]
impl Assign<(u8, u32)> for SmallComplex
impl Assign<(u8, u64)> for SmallComplex
[src]
impl Assign<(u8, u64)> for SmallComplex
impl Assign<(u8, u128)> for SmallComplex
[src]
impl Assign<(u8, u128)> for SmallComplex
impl Assign<(u8, usize)> for SmallComplex
[src]
impl Assign<(u8, usize)> for SmallComplex
impl Assign<(u8, f32)> for SmallComplex
[src]
impl Assign<(u8, f32)> for SmallComplex
impl Assign<(u8, f64)> for SmallComplex
[src]
impl Assign<(u8, f64)> for SmallComplex
impl Assign<u16> for SmallComplex
[src]
impl Assign<u16> for SmallComplex
impl Assign<(u16, i8)> for SmallComplex
[src]
impl Assign<(u16, i8)> for SmallComplex
impl Assign<(u16, i16)> for SmallComplex
[src]
impl Assign<(u16, i16)> for SmallComplex
impl Assign<(u16, i32)> for SmallComplex
[src]
impl Assign<(u16, i32)> for SmallComplex
impl Assign<(u16, i64)> for SmallComplex
[src]
impl Assign<(u16, i64)> for SmallComplex
impl Assign<(u16, i128)> for SmallComplex
[src]
impl Assign<(u16, i128)> for SmallComplex
impl Assign<(u16, isize)> for SmallComplex
[src]
impl Assign<(u16, isize)> for SmallComplex
impl Assign<(u16, u8)> for SmallComplex
[src]
impl Assign<(u16, u8)> for SmallComplex
impl Assign<(u16, u16)> for SmallComplex
[src]
impl Assign<(u16, u16)> for SmallComplex
impl Assign<(u16, u32)> for SmallComplex
[src]
impl Assign<(u16, u32)> for SmallComplex
impl Assign<(u16, u64)> for SmallComplex
[src]
impl Assign<(u16, u64)> for SmallComplex
impl Assign<(u16, u128)> for SmallComplex
[src]
impl Assign<(u16, u128)> for SmallComplex
impl Assign<(u16, usize)> for SmallComplex
[src]
impl Assign<(u16, usize)> for SmallComplex
impl Assign<(u16, f32)> for SmallComplex
[src]
impl Assign<(u16, f32)> for SmallComplex
impl Assign<(u16, f64)> for SmallComplex
[src]
impl Assign<(u16, f64)> for SmallComplex
impl Assign<u32> for SmallComplex
[src]
impl Assign<u32> for SmallComplex
impl Assign<(u32, i8)> for SmallComplex
[src]
impl Assign<(u32, i8)> for SmallComplex
impl Assign<(u32, i16)> for SmallComplex
[src]
impl Assign<(u32, i16)> for SmallComplex
impl Assign<(u32, i32)> for SmallComplex
[src]
impl Assign<(u32, i32)> for SmallComplex
impl Assign<(u32, i64)> for SmallComplex
[src]
impl Assign<(u32, i64)> for SmallComplex
impl Assign<(u32, i128)> for SmallComplex
[src]
impl Assign<(u32, i128)> for SmallComplex
impl Assign<(u32, isize)> for SmallComplex
[src]
impl Assign<(u32, isize)> for SmallComplex
impl Assign<(u32, u8)> for SmallComplex
[src]
impl Assign<(u32, u8)> for SmallComplex
impl Assign<(u32, u16)> for SmallComplex
[src]
impl Assign<(u32, u16)> for SmallComplex
impl Assign<(u32, u32)> for SmallComplex
[src]
impl Assign<(u32, u32)> for SmallComplex
impl Assign<(u32, u64)> for SmallComplex
[src]
impl Assign<(u32, u64)> for SmallComplex
impl Assign<(u32, u128)> for SmallComplex
[src]
impl Assign<(u32, u128)> for SmallComplex
impl Assign<(u32, usize)> for SmallComplex
[src]
impl Assign<(u32, usize)> for SmallComplex
impl Assign<(u32, f32)> for SmallComplex
[src]
impl Assign<(u32, f32)> for SmallComplex
impl Assign<(u32, f64)> for SmallComplex
[src]
impl Assign<(u32, f64)> for SmallComplex
impl Assign<u64> for SmallComplex
[src]
impl Assign<u64> for SmallComplex
impl Assign<(u64, i8)> for SmallComplex
[src]
impl Assign<(u64, i8)> for SmallComplex
impl Assign<(u64, i16)> for SmallComplex
[src]
impl Assign<(u64, i16)> for SmallComplex
impl Assign<(u64, i32)> for SmallComplex
[src]
impl Assign<(u64, i32)> for SmallComplex
impl Assign<(u64, i64)> for SmallComplex
[src]
impl Assign<(u64, i64)> for SmallComplex
impl Assign<(u64, i128)> for SmallComplex
[src]
impl Assign<(u64, i128)> for SmallComplex
impl Assign<(u64, isize)> for SmallComplex
[src]
impl Assign<(u64, isize)> for SmallComplex
impl Assign<(u64, u8)> for SmallComplex
[src]
impl Assign<(u64, u8)> for SmallComplex
impl Assign<(u64, u16)> for SmallComplex
[src]
impl Assign<(u64, u16)> for SmallComplex
impl Assign<(u64, u32)> for SmallComplex
[src]
impl Assign<(u64, u32)> for SmallComplex
impl Assign<(u64, u64)> for SmallComplex
[src]
impl Assign<(u64, u64)> for SmallComplex
impl Assign<(u64, u128)> for SmallComplex
[src]
impl Assign<(u64, u128)> for SmallComplex
impl Assign<(u64, usize)> for SmallComplex
[src]
impl Assign<(u64, usize)> for SmallComplex
impl Assign<(u64, f32)> for SmallComplex
[src]
impl Assign<(u64, f32)> for SmallComplex
impl Assign<(u64, f64)> for SmallComplex
[src]
impl Assign<(u64, f64)> for SmallComplex
impl Assign<u128> for SmallComplex
[src]
impl Assign<u128> for SmallComplex
impl Assign<(u128, i8)> for SmallComplex
[src]
impl Assign<(u128, i8)> for SmallComplex
impl Assign<(u128, i16)> for SmallComplex
[src]
impl Assign<(u128, i16)> for SmallComplex
impl Assign<(u128, i32)> for SmallComplex
[src]
impl Assign<(u128, i32)> for SmallComplex
impl Assign<(u128, i64)> for SmallComplex
[src]
impl Assign<(u128, i64)> for SmallComplex
impl Assign<(u128, i128)> for SmallComplex
[src]
impl Assign<(u128, i128)> for SmallComplex
impl Assign<(u128, isize)> for SmallComplex
[src]
impl Assign<(u128, isize)> for SmallComplex
impl Assign<(u128, u8)> for SmallComplex
[src]
impl Assign<(u128, u8)> for SmallComplex
impl Assign<(u128, u16)> for SmallComplex
[src]
impl Assign<(u128, u16)> for SmallComplex
impl Assign<(u128, u32)> for SmallComplex
[src]
impl Assign<(u128, u32)> for SmallComplex
impl Assign<(u128, u64)> for SmallComplex
[src]
impl Assign<(u128, u64)> for SmallComplex
impl Assign<(u128, u128)> for SmallComplex
[src]
impl Assign<(u128, u128)> for SmallComplex
impl Assign<(u128, usize)> for SmallComplex
[src]
impl Assign<(u128, usize)> for SmallComplex
impl Assign<(u128, f32)> for SmallComplex
[src]
impl Assign<(u128, f32)> for SmallComplex
impl Assign<(u128, f64)> for SmallComplex
[src]
impl Assign<(u128, f64)> for SmallComplex
impl Assign<usize> for SmallComplex
[src]
impl Assign<usize> for SmallComplex
impl Assign<(usize, i8)> for SmallComplex
[src]
impl Assign<(usize, i8)> for SmallComplex
impl Assign<(usize, i16)> for SmallComplex
[src]
impl Assign<(usize, i16)> for SmallComplex
impl Assign<(usize, i32)> for SmallComplex
[src]
impl Assign<(usize, i32)> for SmallComplex
impl Assign<(usize, i64)> for SmallComplex
[src]
impl Assign<(usize, i64)> for SmallComplex
impl Assign<(usize, i128)> for SmallComplex
[src]
impl Assign<(usize, i128)> for SmallComplex
impl Assign<(usize, isize)> for SmallComplex
[src]
impl Assign<(usize, isize)> for SmallComplex
impl Assign<(usize, u8)> for SmallComplex
[src]
impl Assign<(usize, u8)> for SmallComplex
impl Assign<(usize, u16)> for SmallComplex
[src]
impl Assign<(usize, u16)> for SmallComplex
impl Assign<(usize, u32)> for SmallComplex
[src]
impl Assign<(usize, u32)> for SmallComplex
impl Assign<(usize, u64)> for SmallComplex
[src]
impl Assign<(usize, u64)> for SmallComplex
impl Assign<(usize, u128)> for SmallComplex
[src]
impl Assign<(usize, u128)> for SmallComplex
impl Assign<(usize, usize)> for SmallComplex
[src]
impl Assign<(usize, usize)> for SmallComplex
impl Assign<(usize, f32)> for SmallComplex
[src]
impl Assign<(usize, f32)> for SmallComplex
impl Assign<(usize, f64)> for SmallComplex
[src]
impl Assign<(usize, f64)> for SmallComplex
impl Assign<f32> for SmallComplex
[src]
impl Assign<f32> for SmallComplex
impl Assign<(f32, i8)> for SmallComplex
[src]
impl Assign<(f32, i8)> for SmallComplex
impl Assign<(f32, i16)> for SmallComplex
[src]
impl Assign<(f32, i16)> for SmallComplex
impl Assign<(f32, i32)> for SmallComplex
[src]
impl Assign<(f32, i32)> for SmallComplex
impl Assign<(f32, i64)> for SmallComplex
[src]
impl Assign<(f32, i64)> for SmallComplex
impl Assign<(f32, i128)> for SmallComplex
[src]
impl Assign<(f32, i128)> for SmallComplex
impl Assign<(f32, isize)> for SmallComplex
[src]
impl Assign<(f32, isize)> for SmallComplex
impl Assign<(f32, u8)> for SmallComplex
[src]
impl Assign<(f32, u8)> for SmallComplex
impl Assign<(f32, u16)> for SmallComplex
[src]
impl Assign<(f32, u16)> for SmallComplex
impl Assign<(f32, u32)> for SmallComplex
[src]
impl Assign<(f32, u32)> for SmallComplex
impl Assign<(f32, u64)> for SmallComplex
[src]
impl Assign<(f32, u64)> for SmallComplex
impl Assign<(f32, u128)> for SmallComplex
[src]
impl Assign<(f32, u128)> for SmallComplex
impl Assign<(f32, usize)> for SmallComplex
[src]
impl Assign<(f32, usize)> for SmallComplex
impl Assign<(f32, f32)> for SmallComplex
[src]
impl Assign<(f32, f32)> for SmallComplex
impl Assign<(f32, f64)> for SmallComplex
[src]
impl Assign<(f32, f64)> for SmallComplex
impl Assign<f64> for SmallComplex
[src]
impl Assign<f64> for SmallComplex
impl Assign<(f64, i8)> for SmallComplex
[src]
impl Assign<(f64, i8)> for SmallComplex
impl Assign<(f64, i16)> for SmallComplex
[src]
impl Assign<(f64, i16)> for SmallComplex
impl Assign<(f64, i32)> for SmallComplex
[src]
impl Assign<(f64, i32)> for SmallComplex
impl Assign<(f64, i64)> for SmallComplex
[src]
impl Assign<(f64, i64)> for SmallComplex
impl Assign<(f64, i128)> for SmallComplex
[src]
impl Assign<(f64, i128)> for SmallComplex
impl Assign<(f64, isize)> for SmallComplex
[src]
impl Assign<(f64, isize)> for SmallComplex
impl Assign<(f64, u8)> for SmallComplex
[src]
impl Assign<(f64, u8)> for SmallComplex
impl Assign<(f64, u16)> for SmallComplex
[src]
impl Assign<(f64, u16)> for SmallComplex
impl Assign<(f64, u32)> for SmallComplex
[src]
impl Assign<(f64, u32)> for SmallComplex
impl Assign<(f64, u64)> for SmallComplex
[src]
impl Assign<(f64, u64)> for SmallComplex
impl Assign<(f64, u128)> for SmallComplex
[src]
impl Assign<(f64, u128)> for SmallComplex
impl Assign<(f64, usize)> for SmallComplex
[src]
impl Assign<(f64, usize)> for SmallComplex
impl Assign<(f64, f32)> for SmallComplex
[src]
impl Assign<(f64, f32)> for SmallComplex
impl Assign<(f64, f64)> for SmallComplex
[src]
impl Assign<(f64, f64)> for SmallComplex
impl<'a> Assign<&'a Self> for SmallComplex
[src]
impl<'a> Assign<&'a Self> for SmallComplex
impl Assign for SmallComplex
[src]
impl Assign for SmallComplex
Auto Trait Implementations
impl Send for SmallComplex
impl Send for SmallComplex
impl Sync for SmallComplex
impl Sync for SmallComplex