Struct ExactComplex 

pub struct ExactComplex { /* private fields */ }

Complex value re + i·im with software-limb real and imaginary parts.

Implementations

impl ExactComplex

pub fn new(re: ExactNum, im: ExactNum) -> Self

Constructs re + i·im.

pub fn re(&self) -> &ExactNum

Real part.

pub fn im(&self) -> &ExactNum

Imaginary part.

pub fn zero(p: usize) -> Self

0 + 0i at precision p.

pub fn one(p: usize) -> Self

1 + 0i at precision p.

pub fn i(p: usize) -> Self

0 + 1i at precision p.

pub fn inexact(&self) -> bool

True if either part is inexact.

pub fn set_inexact(&mut self, inexact: bool)

Sets the inexact flag on both parts.

pub fn set_precision(&mut self, p: usize, rm: RoundingMode) -> Result<(), Error>

Rounds both parts to precision p.

pub fn from_real(re: ExactNum, p: usize) -> Self

Real x as x + 0i. Imaginary zero uses precision p.

pub fn reciprocal(&self, p: usize, rm: RoundingMode) -> Self

1 / self.

pub fn is_nan(&self) -> bool

True if either part is NaN.

pub fn conj(&self) -> Self

Complex conjugate.

pub fn abs(&self, p: usize, rm: RoundingMode) -> ExactNum

Modulus |z| = hypot(re, im) at precision p.

pub fn arg(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> ExactNum

Argument atan2(im, re) at precision p.

Branch: same as real atan2; values lie in (−π, π]. The cut of ln / sqrt / pow is the non-positive real axis, approached from above as +π and from below as −π.

pub fn add(&self, rhs: &Self, p: usize, rm: RoundingMode) -> Self

self + rhs at precision p.

pub fn sub(&self, rhs: &Self, p: usize, rm: RoundingMode) -> Self

self - rhs at precision p.

pub fn mul(&self, rhs: &Self, p: usize, rm: RoundingMode) -> Self

self * rhs at precision p.

Each of ac, bd, ad, bc is rounded at (p, rm), then ac−bd and ad+bc are rounded at (p, rm). That matches the MPFR componentwise gold. Callers that pass RoundingMode::None still keep full products (series paths).

pub fn div(&self, rhs: &Self, p: usize, rm: RoundingMode) -> Self

self / rhs at precision p.

pub fn exp(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

e^self using exp(re) (cos(im) + i sin(im)).

pub fn ln(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal logarithm ln|z| + i Arg(z).

Branch cut: (−∞, 0] on the real axis. ln(−1) is iπ (argument +π).

pub fn sin(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

sin(self) via sin(re)cosh(im) + i cos(re)sinh(im).

The complex value is not passed to rem_pi. Only the real (resp. imaginary) component uses real sin_cos / sinh_cosh.

pub fn cos(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

cos(self) via cos(re)cosh(im) - i sin(re)sinh(im).

pub fn tan(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

tan(self) = sin(self) / cos(self).

pub fn sinh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

sinh(self) via sinh(re)cos(im) + i cosh(re)sin(im).

pub fn cosh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

cosh(self) via cosh(re)cos(im) + i sinh(re)sin(im).

pub fn tanh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

tanh(self) = sinh(self) / cosh(self).

pub fn sqrt(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal square root: √r (cos(θ/2) + i sin(θ/2)).

Branch cut: (−∞, 0]. Real part of the result is ≥ 0. sqrt(−1) is +i.

pub fn log2(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

log2(self) = ln(self) / ln 2 (principal branch).

pub fn log10(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

log10(self) = ln(self) / ln 10 (principal branch).

pub fn log( &self, base: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

log_base(self) = ln(self) / ln(base) (principal branch).

pub fn log1p(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

ln(1 + self) (principal branch).

pub fn exp2(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

exp2(self) = exp(self · ln 2).

pub fn exp10(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

exp10(self) = exp(self · ln 10).

pub fn expm1(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

exp(self) − 1.

pub fn ldexp(&self, n: Exponent, p: usize, rm: RoundingMode) -> Self

Scale both parts by 2^n (ldexp on re and im).

pub fn scalb(&self, n: Exponent, p: usize, rm: RoundingMode) -> Self

Same as ldexp.

pub fn logb(&self, p: usize, rm: RoundingMode) -> ExactNum

logb(|z|) as a real (x + 0i).

pub fn nth_root( &self, n: usize, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

Principal n-th root via exp(ln(z) / n). Inherits the ln branch cut.

pub fn cbrt(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal cube root. Same branch as nth_root with n = 3.

pub fn hypot( &self, other: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

Principal sqrt(self² + other²) (analytic continuation of real hypot).

pub fn fma(&self, b: &Self, c: &Self, p: usize, rm: RoundingMode) -> Self

self * b + c at extra working precision, then one round (not a fused complex hardware op).

pub fn mul_add(&self, b: &Self, c: &Self, p: usize, rm: RoundingMode) -> Self

Alias of fma.

pub fn pow( &self, rhs: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

self^rhs as exp(rhs * ln(self)) (principal branch).

Inherits the ln cut on self: non-positive real base uses Arg = ±π.

pub fn asin(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal asin: -i ln(i z + √(1 − z²)).

pub fn acos(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal acos: π/2 − asin(z).

pub fn atan(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal atan: (i/2) ln((i+z)/(i−z)).

pub fn asinh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal asinh: ln(z + √(z² + 1)).

pub fn acosh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal acosh: ln(z + √(z−1)√(z+1)).

pub fn atanh(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal atanh: (1/2) ln((1+z)/(1−z)).

impl ExactComplex

pub fn ai(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Airy (\mathrm{Ai}(z)). Entire. NaN in → NaN out.

Precision

• Algorithm: series for |z| < AIRY_SERIES_THRESHOLD (8); asymptotic otherwise.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn bi(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Airy (\mathrm{Bi}(z)). Entire. NaN in → NaN out.

Precision

• Algorithm: same AIRY_SERIES_THRESHOLD = 8 as Self::ai.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

impl ExactComplex

pub fn bessel_j_nu( &self, nu: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

(J_\nu(z)). Entire for integer (\nu); cut on ((-\infty,0]) otherwise. (z=0) with non-integer (\nu) → NaN.

Precision

• Algorithm: series for |z| < BESSEL_SERIES_THRESHOLD (16); Hankel otherwise. Integer |n| ≤ BESSEL_INTEGER_MAX (64).
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn bessel_y( &self, nu: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

(Y_\nu(z)). Cut on ((-\infty,0]); (z=0) → NaN.

Precision

• Algorithm: from (J_ν); BESSEL_SERIES_THRESHOLD = 16.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn bessel_i( &self, nu: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

(I_\nu(z)=i^{-\nu}J_\nu(iz)). Same cut rules as (J_\nu).

Precision

• Algorithm: via Self::bessel_j_nu; BESSEL_SERIES_THRESHOLD = 16.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn bessel_k( &self, nu: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

(K_\nu(z)=(\pi/2),i^{\nu+1}H_\nu^{(1)}(iz)). Cut on ((-\infty,0]); (z=0) → NaN.

Precision

• Algorithm: Hankel of (iz); BESSEL_SERIES_THRESHOLD = 16.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

impl ExactComplex

pub fn ei(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Exponential integral (\mathrm{Ei}(z)). Cut on ((-\infty,0]); pole at (0) → NaN.

Precision

• Algorithm: power series for |z| < EI_SERIES_THRESHOLD (16); asymptotic otherwise.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn si(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Sine integral (\mathrm{Si}(z)=(E_i(iz)-E_i(-iz))/(2i)-\pi/2).

Precision

• Algorithm: via Self::ei; inherits EI_SERIES_THRESHOLD = 16.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn ci(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Cosine integral (\mathrm{Ci}(z)). Pole at (0) → NaN. Inherits the (\mathrm{Ei}) cut.

Precision

• Algorithm: via Self::ei; EI_SERIES_THRESHOLD = 16.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn li(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Logarithmic integral (\mathrm{li}(z)=\mathrm{Ei}(\ln z)). Cut on ((-\infty,1]); pole at (1) → NaN.

Precision

• Algorithm: Self::ei of ln z.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn fresnel_s(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Fresnel sine integral (S(z)). Entire.

Precision

• Algorithm: via complex erf; Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn fresnel_c(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Fresnel cosine integral (C(z)). Entire.

Precision

• Algorithm: via complex erf; Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

impl ExactComplex

pub fn elliptic_k(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Complete elliptic (K(m)), (m=k^2). Cut on ([1,+\infty)). (m=1) is (+\infty).

Precision

• Algorithm: Carlson R_F in ℂ; CARLSON_DUPE_MAX = 128.
• Bound: identities evaluated outside Ziv (nested Ziv would exhaust MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn elliptic_e_complete( &self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

Complete elliptic (E(m)). (E(1)=1). Cut of (K) inherited through (1-m).

Precision

• Algorithm: Carlson R_F / R_D; CARLSON_DUPE_MAX = 128.
• Bound: same as Self::elliptic_k.
• MPFR oracle: no.

pub fn elliptic_f( &self, m: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

Incomplete (F(x|m)), (x=\sin\varphi), (m=k^2).

Precision

• Algorithm: Carlson R_F; CARLSON_DUPE_MAX = 128.
• MPFR oracle: no.

Carlson (R_F(1-x^2,1-mx^2,1)). Cuts when (1-x^2) or (1-mx^2) lies on ((-\infty,0]) (principal square-root cut). (F(x,0)=\arcsin x).

pub fn elliptic_e( &self, m: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

Incomplete (E(x|m)). Same (x,m) convention as Self::elliptic_f.

Precision

• Algorithm: Carlson R_F / R_D; CARLSON_DUPE_MAX = 128.
• MPFR oracle: no. Cuts as for (F). (E(x,0)=\arcsin x); (E(x,1)=x).

pub fn elliptic_pi_complete( &self, m: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

Complete (\Pi(n,m)). self is (n). (\Pi(0,m)=K(m)). Pole at (n=1).

Precision

• Algorithm: Carlson R_J; CARLSON_DUPE_MAX = 128.
• MPFR oracle: no.

pub fn elliptic_pi( &self, x: &Self, m: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

Incomplete (\Pi(n;x|m)). self is (n).

Precision

• Algorithm: Carlson R_J; CARLSON_DUPE_MAX = 128.
• MPFR oracle: no.

Cuts when (1-x^2), (1-mx^2), or (1-nx^2) meets the Carlson cut ((-\infty,0]). (\Pi(0;x|m)=F(x|m)).

impl ExactComplex

pub fn hypergeom_2f1( &self, b: &Self, c: &Self, z: &Self, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

Gaussian ({}_2F_1(a=\mathrm{self},b;c;z)) in (\mathbb{C}).

Series when (\lvert z\rvert<1); Pfaff when (\mathrm{Re}(z)<1/2); Euler / (1-z) and (1/z) linear transforms otherwise. Kummer at (z=1) when (\mathrm{Re}(c-a-b)>0). Cut on ([1,+\infty)) in (z) (principal value from above). Non-positive integer (c) (uncanceled) → NaN.

Precision

• Algorithm: series / Euler / Pfaff / Kummer. Caps HYPERGEOM_SERIES_MAX_TERMS = 10_000, HYPERGEOM_TRANSFORM_MAX = 8.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

impl ExactComplex

pub fn erf(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Error function (\mathrm{erf}(z)=1-\mathrm{erfc}(z)). Entire; NaN in → NaN out.

Precision

• Algorithm: Faddeeva w(z) series for |z| below FADDEEVA_SERIES_L1 = 8; continued fraction otherwise.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: real axis vs mpfr_erf. GNU MPC has no mpc_erf. Off-axis: erf odd, erfc=1-erf.

pub fn erfc(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Complementary error function via Faddeeva: (\mathrm{erfc}(z)=e^{-z^2}w(iz)). Entire; NaN in → NaN out.

Precision

• Algorithm: same Faddeeva path as Self::erf.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: real axis vs mpfr_erfc (via 1-erf identity). GNU MPC has no mpc_erfc.

pub fn gamma(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Gamma (\Gamma(z)). Poles at non-positive integers → NaN.

Precision

• Algorithm: Stirling (GAMMA_STIRLING_TERMS = 64) plus reflection; factorial for small integers (GAMMA_FACTORIAL_MAX = 64).
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: real axis vs mpfr_gamma. GNU MPC has no mpc_gamma. Integers: Γ(n)=(n-1)!.

pub fn ln_gamma(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Principal (\ln\Gamma(z)). Cut on ((-\infty,0]); poles → NaN. Equals (\ln(\Gamma(z))) with the principal logarithm.

Precision

• Algorithm: Stirling (GAMMA_STIRLING_TERMS = 64) plus reflection.
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

pub fn digamma(&self, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Digamma (\psi(z)=\Gamma’/\Gamma). Poles at non-positive integers → NaN.

Precision

• Algorithm: recurrence plus Bernoulli; reflection for (\operatorname{Re} z < 0).
• Bound: Ziv on each part (MAX_PREC_RETRY).
• MPFR oracle: no.

Trait Implementations

impl Add for ExactComplex

type Output = ExactComplex

The resulting type after applying the + operator.

fn add(self, rhs: ExactComplex) -> ExactComplex

Performs the + operation.

impl Add<&ExactComplex> for &ExactComplex

type Output = ExactComplex

The resulting type after applying the + operator.

fn add(self, rhs: &ExactComplex) -> ExactComplex

Performs the + operation.

impl Add<&ExactComplex> for ExactComplex

type Output = ExactComplex

The resulting type after applying the + operator.

fn add(self, rhs: &ExactComplex) -> ExactComplex

Performs the + operation.

impl Add<ExactComplex> for &ExactComplex

type Output = ExactComplex

The resulting type after applying the + operator.

fn add(self, rhs: ExactComplex) -> ExactComplex

Performs the + operation.

impl Clone for ExactComplex

fn clone(&self) -> ExactComplex

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ExactComplex

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Div for ExactComplex

type Output = ExactComplex

The resulting type after applying the / operator.

fn div(self, rhs: ExactComplex) -> ExactComplex

Performs the / operation.

impl Div<&ExactComplex> for &ExactComplex

type Output = ExactComplex

The resulting type after applying the / operator.

fn div(self, rhs: &ExactComplex) -> ExactComplex

Performs the / operation.

impl Div<&ExactComplex> for ExactComplex

type Output = ExactComplex

The resulting type after applying the / operator.

fn div(self, rhs: &ExactComplex) -> ExactComplex

Performs the / operation.

impl Div<ExactComplex> for &ExactComplex

type Output = ExactComplex

The resulting type after applying the / operator.

fn div(self, rhs: ExactComplex) -> ExactComplex

Performs the / operation.

impl FromExt<&ExactComplex> for ExactComplex

fn from_ext( v: &ExactComplex, p: usize, rm: RoundingMode, cc: &mut Consts, ) -> Self

Converts v to ExactNum with precision p using rounding mode rm.

impl FromExt<ExactComplex> for ExactComplex

fn from_ext( v: ExactComplex, p: usize, rm: RoundingMode, _cc: &mut Consts, ) -> Self

Converts v to ExactNum with precision p using rounding mode rm.

impl<T> FromExt<T> for ExactComplex

where ExactNum: FromExt<T>,

fn from_ext(v: T, p: usize, rm: RoundingMode, cc: &mut Consts) -> Self

Converts v to ExactNum with precision p using rounding mode rm.

impl Mul for ExactComplex

type Output = ExactComplex

The resulting type after applying the * operator.

fn mul(self, rhs: ExactComplex) -> ExactComplex

Performs the * operation.

impl Mul<&ExactComplex> for &ExactComplex

type Output = ExactComplex

The resulting type after applying the * operator.

fn mul(self, rhs: &ExactComplex) -> ExactComplex

Performs the * operation.

impl Mul<&ExactComplex> for ExactComplex

type Output = ExactComplex

The resulting type after applying the * operator.

fn mul(self, rhs: &ExactComplex) -> ExactComplex

Performs the * operation.

impl Mul<ExactComplex> for &ExactComplex

type Output = ExactComplex

The resulting type after applying the * operator.

fn mul(self, rhs: ExactComplex) -> ExactComplex

Performs the * operation.

impl Sub for ExactComplex

type Output = ExactComplex

The resulting type after applying the - operator.

fn sub(self, rhs: ExactComplex) -> ExactComplex

Performs the - operation.

impl Sub<&ExactComplex> for &ExactComplex

type Output = ExactComplex

The resulting type after applying the - operator.

fn sub(self, rhs: &ExactComplex) -> ExactComplex

Performs the - operation.

impl Sub<&ExactComplex> for ExactComplex

type Output = ExactComplex

The resulting type after applying the - operator.

fn sub(self, rhs: &ExactComplex) -> ExactComplex

Performs the - operation.

impl Sub<ExactComplex> for &ExactComplex

type Output = ExactComplex

The resulting type after applying the - operator.

fn sub(self, rhs: ExactComplex) -> ExactComplex

Performs the - operation.