Multiple-precision Complex

gmpy2 adds a multiple-precision complex type called mpc that is based on the MPC library. The context manager settings for mpfr arithmetic are applied to mpc arithmetic by default. It is possible to specify different precision and rounding modes for both the real and imaginary components of an mpc.

>>> import gmpy2
>>> from gmpy2 import mpc
>>> gmpy2.set_context(gmpy2.context())
>>> gmpy2.sqrt(mpc("1+2j"))
mpc('1.272019649514069+0.78615137775742328j')
>>> gmpy2.set_context(gmpy2.context(real_prec=60,imag_prec=70))
>>> gmpy2.get_context()
context(precision=53, real_prec=60, imag_prec=70,
        round=RoundToNearest, real_round=Default, imag_round=Default,
        emax=1073741823, emin=-1073741823,
        subnormalize=False,
        trap_underflow=False, underflow=False,
        trap_overflow=False, overflow=False,
        trap_inexact=False, inexact=False,
        trap_invalid=False, invalid=False,
        trap_erange=False, erange=False,
        trap_divzero=False, divzero=False,
        allow_complex=False,
        rational_division=False,
        allow_release_gil=False)
>>> gmpy2.sqrt(mpc("1+2j"))
mpc('1.272019649514068965+0.78615137775742328606947j',(60,70))
>>> gmpy2.set_context(gmpy2.context())

Exceptions are normally raised in Python when the result of a real operation is not defined over the reals; for example, sqrt(-4) will raise an exception. The default context in gmpy2 implements the same behavior but by setting allow_complex to True, complex results will be returned.

>>> import gmpy2
>>> from gmpy2 import mpc
>>> gmpy2.sqrt(-4)
mpfr('nan')
>>> gmpy2.get_context().allow_complex=True
>>> gmpy2.sqrt(-4)
mpc('0.0+2.0j')

The mpc type supports the __format__() special method to allow custom output formatting.

>>> import gmpy2
>>> from gmpy2 import mpc
>>> a=gmpy2.sqrt(mpc("1+2j"))
>>> a
mpc('1.272019649514069+0.78615137775742328j')
>>> "{0:.4.4Mf}".format(a)
'(1.2720 0.7862)'
>>> "{0:.4.4f}".format(a)
'1.2720+0.7862j'
>>> "{0:^20.4.4U}".format(a)
'   1.2721+0.7862j   '
>>> "{0:^20.4.4D}".format(a)
'   1.2720+0.7861j   '

mpc Type

class gmpy2.mpc(c=0, /, precision=0)
class gmpy2.mpc(c=0, /, precision, context)
class gmpy2.mpc(real, /, imag=0, precision=0)
class gmpy2.mpc(real, /, imag, precision, context)
class gmpy2.mpc(s, /, precision=0, base=10)
class gmpy2.mpc(s, /, precision, base, context)

Return a complex floating-point number constructed from a numeric value c or from a pair of two non-complex numbers real and imag or from a string s made of digits in the given base.

A string can be possibly with real-part and/or imaginary-part (that have ‘j’ as a suffix), separated by ‘+’ and parsed the same as the mpfr constructor does (but the base must be up to 36).

The precision can be specified by either a single number that is used for both the real and imaginary components, or as a pair of different precisions for the real and imaginary components. For every component, the meaning of its precision value is the same as in the mpfr type constructor.

__format__(fmt) str

Return a Python string by formatting ‘x’ using the format string ‘fmt’. A valid format string consists of:

optional alignment code:

‘<’ -> left shifted in field ‘>’ -> right shifted in field ‘^’ -> centered in field

optional leading sign code

‘+’ -> always display leading sign ‘-’ -> only display minus for negative values ‘ ‘ -> minus for negative values, space for positive values

optional width.real_precision.imag_precision

optional rounding mode:

‘U’ -> round toward plus infinity ‘D’ -> round toward minus infinity ‘Z’ -> round toward zero ‘N’ -> round to nearest

optional output style:

‘P’ -> Python style, 1+2j, (default) ‘M’ -> MPC style, (1 2)

optional conversion code:

‘a’,’A’ -> hex format ‘b’ -> binary format ‘e’,’E’ -> scientific format ‘f’,’F’ -> fixed point format ‘g’,’G’ -> fixed or scientific format

The default format is ‘f’.

conjugate() mpc

Returns the conjugate of x.

digits(base=10, prec=0, /) tuple[tuple[str, int, int], tuple[str, int, int]]

Returns up to ‘prec’ digits in the given base. If ‘prec’ is 0, as many digits that are available given c’s precision are returned. ‘base’ must be between 2 and 62. The result consists of 2 three-element tuples that contain the mantissa, exponent, and number of bits of precision of the real and imaginary components.

is_finite() bool

Return True if x is an actual number (i.e. non NaN or Infinity). If x is an mpc, return True if both x.real and x.imag are finite.

is_infinite() bool

Return True if x is +Infinity or -Infinity. If x is an mpc, return True if either x.real or x.imag is infinite. Otherwise return False.

is_nan() bool

Return True if x is NaN (Not-A-Number) else False.

is_zero() bool

Return True if x is equal to 0. If x is an mpc, return True if both x.real and x.imag are equal to 0.

imag

imaginary component

precision

precision in bits

rc

return code

real

real component

mpc Functions

gmpy2.acos(x, /) mpfr | mpc

Return inverse cosine of x; result in radians.

gmpy2.acosh(x, /) mpfr | mpc

Return inverse hyperbolic cosine of x.

gmpy2.asin(x, /) mpfr | mpc

Return inverse sine of x; result in radians.

gmpy2.asinh(x, /) mpfr | mpc

Return inverse hyperbolic sine of x.

gmpy2.atan(x, /) mpfr | mpc

Return inverse tangent of x; result in radians.

gmpy2.atanh(x, /) mpfr | mpc

Return inverse hyperbolic tangent of x.

gmpy2.cos(x, /) mpfr | mpc

Return cosine of x; x in radians.

gmpy2.cosh(x, /) mpfr | mpc

Return hyperbolic cosine of x.

gmpy2.div_2exp(x, n, /) mpfr | mpc

Return x divided by 2**n.

gmpy2.exp(x, /) mpfr | mpc

Return the exponential of x.

gmpy2.is_nan(x, /) bool

Return True if x is NaN (Not-A-Number) else False.

gmpy2.is_zero(x, /) bool

Return True if x is equal to 0. If x is an mpc, return True if both x.real and x.imag are equal to 0.

gmpy2.log(x, /) mpfr | mpc

Return the natural logarithm of x.

gmpy2.log10(x, /) mpfr | mpc

Return the base-10 logarithm of x.

gmpy2.mpc_random(random_state, /) mpc

Return uniformly distributed number in the unit square [0,1]x[0,1].

gmpy2.mul_2exp(x, n, /) mpfr | mpc

Return x multiplied by 2**n.

gmpy2.norm(x, /) mpfr

Return the norm of a complex x. The norm(x) is defined as x.real**2 + x.imag**2. abs(x) is the square root of norm(x).

gmpy2.phase(x, /) mpfr

Return the phase angle, also known as argument, of a complex x.

gmpy2.polar(x, /) tuple[mpfr, mpfr]

Return the polar coordinate form of a complex x that is in rectangular form.

gmpy2.proj(x, /) mpc

Returns the projection of a complex x on to the Riemann sphere.

gmpy2.rect(r, phi, /) mpc

Return the rectangular coordinate form of a complex number that is given in polar form.

gmpy2.root_of_unity(n, k, /) mpc

Return the n-th root of mpc(1) raised to the k-th power..

gmpy2.sin(x, /) mpfr | mpc

Return sine of x; x in radians.

gmpy2.sin_cos(x, /) tuple[mpfr | mpc, mpfr | mpc]

Return a tuple containing the sine and cosine of x; x in radians.

gmpy2.sinh(x, /) mpfr | mpc

Return hyperbolic sine of x.

gmpy2.sqrt(x, /) mpfr | mpc

Return the square root of x.

gmpy2.tan(x, /) mpfr | mpc

Return tangent of x; x in radians.

gmpy2.tanh(x, /) mpfr | mpc

Return hyperbolic tangent of x.