Arbitrary precision floating point complex numbers using GNU MPC

This is a binding for the arbitrary-precision floating point library GNU MPC.

We define a class MPComplexField, each instance of which specifies a field of floating-point complex numbers with a specified precision shared by the real and imaginary part and a rounding mode stating the rounding mode directions specific to real and imaginary parts.

Individual floating-point numbers are of class MPComplexNumber.

For floating-point representation and rounding mode description see the documentation for the sage.rings.real_mpfr.

AUTHORS:

  • Philippe Theveny (2008-10-13): initial version, adapted from sage.rings.real_mpfr and sage.rings.complex_mpfr.

  • Alex Ghitza (2008-11): cache, generators, random element, and many doctests.

  • Yann Laigle-Chapuy (2010-01): improves compatibility with CC, updates.

  • Jeroen Demeyer (2012-02): reformat documentation, make MPC a standard package.

  • Travis Scrimshaw (2012-10-18): Added doctests for full coverage.

  • Vincent Klein (2017-11-15) : add __mpc__() to class MPComplexNumber. MPComplexNumber constructor support gmpy2.mpz, gmpy2.mpq, gmpy2.mpfr and gmpy2.mpc parameters.

EXAMPLES:

sage: MPC = MPComplexField(42)
sage: a = MPC(12, '15.64E+32'); a
12.0000000000 + 1.56400000000e33*I
sage: a *a *a *a
5.98338564121e132 - 1.83633318912e101*I
sage: a + 1
13.0000000000 + 1.56400000000e33*I
sage: a / 3
4.00000000000 + 5.21333333333e32*I
sage: MPC("infinity + NaN *I")
+infinity + NaN*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(42))
>>> a = MPC(Integer(12), '15.64E+32'); a
12.0000000000 + 1.56400000000e33*I
>>> a *a *a *a
5.98338564121e132 - 1.83633318912e101*I
>>> a + Integer(1)
13.0000000000 + 1.56400000000e33*I
>>> a / Integer(3)
4.00000000000 + 5.21333333333e32*I
>>> MPC("infinity + NaN *I")
+infinity + NaN*I

MPC = MPComplexField(42)
a = MPC(12, '15.64E+32'); a
a *a *a *a
a + 1
a / 3
MPC("infinity + NaN *I")
class sage.rings.complex_mpc.CCtoMPC[source]

Bases: Map

class sage.rings.complex_mpc.INTEGERtoMPC[source]

Bases: Map

sage.rings.complex_mpc.MPComplexField(prec=53, rnd='RNDNN', names=None)[source]

Return the complex field with real and imaginary parts having prec bits of precision.

EXAMPLES:

sage: MPComplexField()
Complex Field with 53 bits of precision
sage: MPComplexField(100)
Complex Field with 100 bits of precision
sage: MPComplexField(100).base_ring()
Real Field with 100 bits of precision
sage: i = MPComplexField(200).gen()
sage: i^2
-1.0000000000000000000000000000000000000000000000000000000000

>>> from sage.all import *
>>> MPComplexField()
Complex Field with 53 bits of precision
>>> MPComplexField(Integer(100))
Complex Field with 100 bits of precision
>>> MPComplexField(Integer(100)).base_ring()
Real Field with 100 bits of precision
>>> i = MPComplexField(Integer(200)).gen()
>>> i**Integer(2)
-1.0000000000000000000000000000000000000000000000000000000000

MPComplexField()
MPComplexField(100)
MPComplexField(100).base_ring()
i = MPComplexField(200).gen()
i^2
class sage.rings.complex_mpc.MPComplexField_class[source]

Bases: Field

Initialize self.

INPUT:

  • prec – integer (default: 53); precision

    prec is the number of bits used to represent the mantissa of both the real and imaginary part of complex floating-point number.

  • rnd – string (default: 'RNDNN'); the rounding mode

    Rounding mode is of the form 'RNDxy' where x and y are the rounding mode for respectively the real and imaginary parts and are one of:

    • 'N' for rounding to nearest

    • 'Z' for rounding towards zero

    • 'U' for rounding towards plus infinity

    • 'D' for rounding towards minus infinity

    For example, 'RNDZU' indicates to round the real part towards zero, and the imaginary part towards plus infinity.

EXAMPLES:

sage: MPComplexField(17)
Complex Field with 17 bits of precision
sage: MPComplexField()
Complex Field with 53 bits of precision
sage: MPComplexField(1042,'RNDDZ')
Complex Field with 1042 bits of precision and rounding RNDDZ

>>> from sage.all import *
>>> MPComplexField(Integer(17))
Complex Field with 17 bits of precision
>>> MPComplexField()
Complex Field with 53 bits of precision
>>> MPComplexField(Integer(1042),'RNDDZ')
Complex Field with 1042 bits of precision and rounding RNDDZ

MPComplexField(17)
MPComplexField()
MPComplexField(1042,'RNDDZ')

ALGORITHMS: Computations are done using the MPC library.

characteristic()[source]

Return 0, since the field of complex numbers has characteristic 0.

EXAMPLES:

sage: MPComplexField(42).characteristic()
0

>>> from sage.all import *
>>> MPComplexField(Integer(42)).characteristic()
0

MPComplexField(42).characteristic()
gen(n=0)[source]

Return the generator of this complex field over its real subfield.

EXAMPLES:

sage: MPComplexField(34).gen()
1.00000000*I

>>> from sage.all import *
>>> MPComplexField(Integer(34)).gen()
1.00000000*I

MPComplexField(34).gen()
is_exact()[source]

Return whether or not this field is exact, which is always False.

EXAMPLES:

sage: MPComplexField(42).is_exact()
False

>>> from sage.all import *
>>> MPComplexField(Integer(42)).is_exact()
False

MPComplexField(42).is_exact()
name()[source]

Return the name of the complex field.

EXAMPLES:

sage: C = MPComplexField(10, 'RNDNZ'); C.name()
'MPComplexField10_RNDNZ'

>>> from sage.all import *
>>> C = MPComplexField(Integer(10), 'RNDNZ'); C.name()
'MPComplexField10_RNDNZ'

C = MPComplexField(10, 'RNDNZ'); C.name()
ngens()[source]

Return 1, the number of generators of this complex field over its real subfield.

EXAMPLES:

sage: MPComplexField(34).ngens()
1

>>> from sage.all import *
>>> MPComplexField(Integer(34)).ngens()
1

MPComplexField(34).ngens()
prec()[source]

Return the precision of this field of complex numbers.

EXAMPLES:

sage: MPComplexField().prec()
53
sage: MPComplexField(22).prec()
22

>>> from sage.all import *
>>> MPComplexField().prec()
53
>>> MPComplexField(Integer(22)).prec()
22

MPComplexField().prec()
MPComplexField(22).prec()
random_element(min=0, max=1)[source]

Return a random complex number, uniformly distributed with real and imaginary parts between min and max (default 0 to 1).

EXAMPLES:

sage: MPComplexField(100).random_element(-5, 10)  # random
1.9305310520925994224072377281 + 0.94745292506956219710477444855*I
sage: MPComplexField(10).random_element()  # random
0.12 + 0.23*I

>>> from sage.all import *
>>> MPComplexField(Integer(100)).random_element(-Integer(5), Integer(10))  # random
1.9305310520925994224072377281 + 0.94745292506956219710477444855*I
>>> MPComplexField(Integer(10)).random_element()  # random
0.12 + 0.23*I

MPComplexField(100).random_element(-5, 10)  # random
MPComplexField(10).random_element()  # random
rounding_mode()[source]

Return rounding modes used for each part of a complex number.

EXAMPLES:

sage: MPComplexField().rounding_mode()
'RNDNN'
sage: MPComplexField(rnd='RNDZU').rounding_mode()
'RNDZU'

>>> from sage.all import *
>>> MPComplexField().rounding_mode()
'RNDNN'
>>> MPComplexField(rnd='RNDZU').rounding_mode()
'RNDZU'

MPComplexField().rounding_mode()
MPComplexField(rnd='RNDZU').rounding_mode()
rounding_mode_imag()[source]

Return rounding mode used for the imaginary part of complex number.

EXAMPLES:

sage: MPComplexField(rnd='RNDZU').rounding_mode_imag()
'RNDU'

>>> from sage.all import *
>>> MPComplexField(rnd='RNDZU').rounding_mode_imag()
'RNDU'

MPComplexField(rnd='RNDZU').rounding_mode_imag()
rounding_mode_real()[source]

Return rounding mode used for the real part of complex number.

EXAMPLES:

sage: MPComplexField(rnd='RNDZU').rounding_mode_real()
'RNDZ'

>>> from sage.all import *
>>> MPComplexField(rnd='RNDZU').rounding_mode_real()
'RNDZ'

MPComplexField(rnd='RNDZU').rounding_mode_real()
class sage.rings.complex_mpc.MPComplexNumber[source]

Bases: FieldElement

A floating point approximation to a complex number using any specified precision common to both real and imaginary part.

agm(right, algorithm='optimal')[source]

Return the algebro-geometric mean of self and right.

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(1, 4)
sage: v = MPC(-2,5)
sage: u.agm(v, algorithm='pari')
-0.410522769709397 + 4.60061063922097*I
sage: u.agm(v, algorithm='principal')
1.24010691168158 - 0.472193567796433*I
sage: u.agm(v, algorithm='optimal')
-0.410522769709397 + 4.60061063922097*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(1), Integer(4))
>>> v = MPC(-Integer(2),Integer(5))
>>> u.agm(v, algorithm='pari')
-0.410522769709397 + 4.60061063922097*I
>>> u.agm(v, algorithm='principal')
1.24010691168158 - 0.472193567796433*I
>>> u.agm(v, algorithm='optimal')
-0.410522769709397 + 4.60061063922097*I

MPC = MPComplexField()
u = MPC(1, 4)
v = MPC(-2,5)
u.agm(v, algorithm='pari')
u.agm(v, algorithm='principal')
u.agm(v, algorithm='optimal')
algebraic_dependency(n, **kwds)[source]

Return an irreducible polynomial of degree at most \(n\) which is approximately satisfied by this complex number.

ALGORITHM: Uses the PARI C-library pari:algdep command.

INPUT: Type algdep? at the top level prompt. All additional parameters are passed onto the top-level algdep command.

EXAMPLES:

sage: MPC = MPComplexField()
sage: z = (1/2)*(1 + sqrt(3.0) * MPC.0); z
0.500000000000000 + 0.866025403784439*I
sage: p = z.algebraic_dependency(5)
sage: p
x^2 - x + 1
sage: p(z)
1.11022302462516e-16

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> z = (Integer(1)/Integer(2))*(Integer(1) + sqrt(RealNumber('3.0')) * MPC.gen(0)); z
0.500000000000000 + 0.866025403784439*I
>>> p = z.algebraic_dependency(Integer(5))
>>> p
x^2 - x + 1
>>> p(z)
1.11022302462516e-16

MPC = MPComplexField()
z = (1/2)*(1 + sqrt(3.0) * MPC.0); z
p = z.algebraic_dependency(5)
p
p(z)
arccos()[source]

Return the arccosine of this complex number.

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: arccos(u)
1.11692611683177 - 2.19857302792094*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> arccos(u)
1.11692611683177 - 2.19857302792094*I

MPC = MPComplexField()
u = MPC(2, 4)
arccos(u)
arccosh()[source]

Return the hyperbolic arccos of this complex number.

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: arccosh(u)
2.19857302792094 + 1.11692611683177*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> arccosh(u)
2.19857302792094 + 1.11692611683177*I

MPC = MPComplexField()
u = MPC(2, 4)
arccosh(u)
arccoth()[source]

Return the hyperbolic arccotangent of this complex number.

EXAMPLES:

sage: MPC = MPComplexField(100)
sage: MPC(1,1).arccoth()
0.40235947810852509365018983331 - 0.55357435889704525150853273009*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(100))
>>> MPC(Integer(1),Integer(1)).arccoth()
0.40235947810852509365018983331 - 0.55357435889704525150853273009*I

MPC = MPComplexField(100)
MPC(1,1).arccoth()
arccsch()[source]

Return the hyperbolic arcsine of this complex number.

EXAMPLES:

sage: MPC = MPComplexField(100)
sage: MPC(1,1).arccsch()
0.53063753095251782601650945811 - 0.45227844715119068206365839783*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(100))
>>> MPC(Integer(1),Integer(1)).arccsch()
0.53063753095251782601650945811 - 0.45227844715119068206365839783*I

MPC = MPComplexField(100)
MPC(1,1).arccsch()
arcsech()[source]

Return the hyperbolic arcsecant of this complex number.

EXAMPLES:

sage: MPC = MPComplexField(100)
sage: MPC(1,1).arcsech()
0.53063753095251782601650945811 - 1.1185178796437059371676632938*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(100))
>>> MPC(Integer(1),Integer(1)).arcsech()
0.53063753095251782601650945811 - 1.1185178796437059371676632938*I

MPC = MPComplexField(100)
MPC(1,1).arcsech()
arcsin()[source]

Return the arcsine of this complex number.

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: arcsin(u)
0.453870209963122 + 2.19857302792094*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> arcsin(u)
0.453870209963122 + 2.19857302792094*I

MPC = MPComplexField()
u = MPC(2, 4)
arcsin(u)
arcsinh()[source]

Return the hyperbolic arcsine of this complex number.

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: arcsinh(u)
2.18358521656456 + 1.09692154883014*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> arcsinh(u)
2.18358521656456 + 1.09692154883014*I

MPC = MPComplexField()
u = MPC(2, 4)
arcsinh(u)
arctan()[source]

Return the arctangent of this complex number.

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(-2, 4)
sage: arctan(u)
-1.46704821357730 + 0.200586618131234*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(-Integer(2), Integer(4))
>>> arctan(u)
-1.46704821357730 + 0.200586618131234*I

MPC = MPComplexField()
u = MPC(-2, 4)
arctan(u)
arctanh()[source]

Return the hyperbolic arctangent of this complex number.

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: arctanh(u)
0.0964156202029962 + 1.37153510396169*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> arctanh(u)
0.0964156202029962 + 1.37153510396169*I

MPC = MPComplexField()
u = MPC(2, 4)
arctanh(u)
argument()[source]

The argument (angle) of the complex number, normalized so that \(-\pi < \theta \leq \pi\).

EXAMPLES:

sage: MPC = MPComplexField()
sage: i = MPC.0
sage: (i^2).argument()
3.14159265358979
sage: (1+i).argument()
0.785398163397448
sage: i.argument()
1.57079632679490
sage: (-i).argument()
-1.57079632679490
sage: (RR('-0.001') - i).argument()
-1.57179632646156

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> i = MPC.gen(0)
>>> (i**Integer(2)).argument()
3.14159265358979
>>> (Integer(1)+i).argument()
0.785398163397448
>>> i.argument()
1.57079632679490
>>> (-i).argument()
-1.57079632679490
>>> (RR('-0.001') - i).argument()
-1.57179632646156

MPC = MPComplexField()
i = MPC.0
(i^2).argument()
(1+i).argument()
i.argument()
(-i).argument()
(RR('-0.001') - i).argument()
conjugate()[source]

Return the complex conjugate of this complex number:

\[\mathrm{conjugate}(a + ib) = a - ib.\]

EXAMPLES:

sage: MPC = MPComplexField()
sage: i = MPC(0, 1)
sage: (1+i).conjugate()
1.00000000000000 - 1.00000000000000*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> i = MPC(Integer(0), Integer(1))
>>> (Integer(1)+i).conjugate()
1.00000000000000 - 1.00000000000000*I

MPC = MPComplexField()
i = MPC(0, 1)
(1+i).conjugate()
cos()[source]

Return the cosine of this complex number:

\[\cos(a + ib) = \cos a \cosh b -i \sin a \sinh b.\]

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: cos(u)
-11.3642347064011 - 24.8146514856342*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> cos(u)
-11.3642347064011 - 24.8146514856342*I

MPC = MPComplexField()
u = MPC(2, 4)
cos(u)
cosh()[source]

Return the hyperbolic cosine of this complex number:

\[\cosh(a + ib) = \cosh a \cos b + i \sinh a \sin b.\]

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: cosh(u)
-2.45913521391738 - 2.74481700679215*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> cosh(u)
-2.45913521391738 - 2.74481700679215*I

MPC = MPComplexField()
u = MPC(2, 4)
cosh(u)
cot()[source]

Return the cotangent of this complex number.

EXAMPLES:

sage: MPC = MPComplexField(53)
sage: (1+MPC(I)).cot()
0.217621561854403 - 0.868014142895925*I
sage: i = MPComplexField(200).0
sage: (1+i).cot()
0.21762156185440268136513424360523807352075436916785404091068 - 0.86801414289592494863584920891627388827343874994609327121115*I
sage: i = MPComplexField(220).0
sage: (1+i).cot()
0.21762156185440268136513424360523807352075436916785404091068124239 - 0.86801414289592494863584920891627388827343874994609327121115071646*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(53))
>>> (Integer(1)+MPC(I)).cot()
0.217621561854403 - 0.868014142895925*I
>>> i = MPComplexField(Integer(200)).gen(0)
>>> (Integer(1)+i).cot()
0.21762156185440268136513424360523807352075436916785404091068 - 0.86801414289592494863584920891627388827343874994609327121115*I
>>> i = MPComplexField(Integer(220)).gen(0)
>>> (Integer(1)+i).cot()
0.21762156185440268136513424360523807352075436916785404091068124239 - 0.86801414289592494863584920891627388827343874994609327121115071646*I

MPC = MPComplexField(53)
(1+MPC(I)).cot()
i = MPComplexField(200).0
(1+i).cot()
i = MPComplexField(220).0
(1+i).cot()
coth()[source]

Return the hyperbolic cotangent of this complex number.

EXAMPLES:

sage: MPC = MPComplexField(100)
sage: MPC(1,1).coth()
0.86801414289592494863584920892 - 0.21762156185440268136513424361*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(100))
>>> MPC(Integer(1),Integer(1)).coth()
0.86801414289592494863584920892 - 0.21762156185440268136513424361*I

MPC = MPComplexField(100)
MPC(1,1).coth()
csc()[source]

Return the cosecant of this complex number.

EXAMPLES:

sage: MPC = MPComplexField(100)
sage: MPC(1,1).csc()
0.62151801717042842123490780586 - 0.30393100162842645033448560451*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(100))
>>> MPC(Integer(1),Integer(1)).csc()
0.62151801717042842123490780586 - 0.30393100162842645033448560451*I

MPC = MPComplexField(100)
MPC(1,1).csc()
csch()[source]

Return the hyperbolic cosecant of this complex number.

EXAMPLES:

sage: MPC = MPComplexField(100)
sage: MPC(1,1).csch()
0.30393100162842645033448560451 - 0.62151801717042842123490780586*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(100))
>>> MPC(Integer(1),Integer(1)).csch()
0.30393100162842645033448560451 - 0.62151801717042842123490780586*I

MPC = MPComplexField(100)
MPC(1,1).csch()
dilog()[source]

Return the complex dilogarithm of self.

The complex dilogarithm, or Spence’s function, is defined by

\[Li_2(z) = - \int_0^z \frac{\log|1-\zeta|}{\zeta} d(\zeta) = \sum_{k=1}^\infty \frac{z^k}{k^2}.\]

Note that the series definition can only be used for \(|z| < 1\).

EXAMPLES:

sage: MPC = MPComplexField()
sage: a = MPC(1,0)
sage: a.dilog()
1.64493406684823
sage: float(pi^2/6)                                                         # needs sage.symbolic
1.6449340668482262

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> a = MPC(Integer(1),Integer(0))
>>> a.dilog()
1.64493406684823
>>> float(pi**Integer(2)/Integer(6))                                                         # needs sage.symbolic
1.6449340668482262

MPC = MPComplexField()
a = MPC(1,0)
a.dilog()
float(pi^2/6)                                                         # needs sage.symbolic
sage: b = MPC(0,1)
sage: b.dilog()
-0.205616758356028 + 0.915965594177219*I

>>> from sage.all import *
>>> b = MPC(Integer(0),Integer(1))
>>> b.dilog()
-0.205616758356028 + 0.915965594177219*I

b = MPC(0,1)
b.dilog()
>>> from sage.all import *
>>> b = MPC(Integer(0),Integer(1))
>>> b.dilog()
-0.205616758356028 + 0.915965594177219*I

b = MPC(0,1)
b.dilog()
sage: c = MPC(0,0)
sage: c.dilog()
0

>>> from sage.all import *
>>> c = MPC(Integer(0),Integer(0))
>>> c.dilog()
0

c = MPC(0,0)
c.dilog()
>>> from sage.all import *
>>> c = MPC(Integer(0),Integer(0))
>>> c.dilog()
0

c = MPC(0,0)
c.dilog()
eta(omit_frac=False)[source]

Return the value of the Dedekind \(\eta\) function on self, intelligently computed using \(\mathbb{SL}(2,\ZZ)\) transformations.

The \(\eta\) function is

\[\eta(z) = e^{\pi i z / 12} \prod_{n=1}^{\infty}(1-e^{2\pi inz})\]

INPUT:

  • self – element of the upper half plane (if not, raises a ValueError)

  • omit_frac – – boolean (default: False); if True, omit the \(e^{\pi i z / 12}\) factor

OUTPUT: a complex number

ALGORITHM: Uses the PARI C library.

EXAMPLES:

sage: MPC = MPComplexField()
sage: i = MPC.0
sage: z = 1+i; z.eta()
0.742048775836565 + 0.198831370229911*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> i = MPC.gen(0)
>>> z = Integer(1)+i; z.eta()
0.742048775836565 + 0.198831370229911*I

MPC = MPComplexField()
i = MPC.0
z = 1+i; z.eta()
exp()[source]

Return the exponential of this complex number:

\[\exp(a + ib) = \exp(a) (\cos b + i \sin b).\]

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: exp(u)
-4.82980938326939 - 5.59205609364098*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> exp(u)
-4.82980938326939 - 5.59205609364098*I

MPC = MPComplexField()
u = MPC(2, 4)
exp(u)
gamma()[source]

Return the Gamma function evaluated at this complex number.

EXAMPLES:

sage: MPC = MPComplexField(30)
sage: i = MPC.0
sage: (1+i).gamma()
0.49801567 - 0.15494983*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(30))
>>> i = MPC.gen(0)
>>> (Integer(1)+i).gamma()
0.49801567 - 0.15494983*I

MPC = MPComplexField(30)
i = MPC.0
(1+i).gamma()
gamma_inc(t)[source]

Return the incomplete Gamma function evaluated at this complex number.

EXAMPLES:

sage: C, i = MPComplexField(30).objgen()
sage: (1+i).gamma_inc(2 + 3*i)  # abs tol 2e-10
0.0020969149 - 0.059981914*I
sage: (1+i).gamma_inc(5)
-0.0013781309 + 0.0065198200*I
sage: C(2).gamma_inc(1 + i)
0.70709210 - 0.42035364*I

>>> from sage.all import *
>>> C, i = MPComplexField(Integer(30)).objgen()
>>> (Integer(1)+i).gamma_inc(Integer(2) + Integer(3)*i)  # abs tol 2e-10
0.0020969149 - 0.059981914*I
>>> (Integer(1)+i).gamma_inc(Integer(5))
-0.0013781309 + 0.0065198200*I
>>> C(Integer(2)).gamma_inc(Integer(1) + i)
0.70709210 - 0.42035364*I

C, i = MPComplexField(30).objgen()
(1+i).gamma_inc(2 + 3*i)  # abs tol 2e-10
(1+i).gamma_inc(5)
C(2).gamma_inc(1 + i)
imag()[source]

Return imaginary part of self.

EXAMPLES:

sage: C = MPComplexField(100)
sage: z = C(2, 3)
sage: x = z.imag(); x
3.0000000000000000000000000000
sage: x.parent()
Real Field with 100 bits of precision

>>> from sage.all import *
>>> C = MPComplexField(Integer(100))
>>> z = C(Integer(2), Integer(3))
>>> x = z.imag(); x
3.0000000000000000000000000000
>>> x.parent()
Real Field with 100 bits of precision

C = MPComplexField(100)
z = C(2, 3)
x = z.imag(); x
x.parent()
is_imaginary()[source]

Return True if self is imaginary, i.e. has real part zero.

EXAMPLES:

sage: C200 = MPComplexField(200)
sage: C200(1.23*i).is_imaginary()
True
sage: C200(1+i).is_imaginary()
False

>>> from sage.all import *
>>> C200 = MPComplexField(Integer(200))
>>> C200(RealNumber('1.23')*i).is_imaginary()
True
>>> C200(Integer(1)+i).is_imaginary()
False

C200 = MPComplexField(200)
C200(1.23*i).is_imaginary()
C200(1+i).is_imaginary()
is_real()[source]

Return True if self is real, i.e. has imaginary part zero.

EXAMPLES:

sage: C200 = MPComplexField(200)
sage: C200(1.23).is_real()
True
sage: C200(1+i).is_real()
False

>>> from sage.all import *
>>> C200 = MPComplexField(Integer(200))
>>> C200(RealNumber('1.23')).is_real()
True
>>> C200(Integer(1)+i).is_real()
False

C200 = MPComplexField(200)
C200(1.23).is_real()
C200(1+i).is_real()
is_square()[source]

This function always returns true as \(\CC\) is algebraically closed.

EXAMPLES:

sage: C200 = MPComplexField(200)
sage: a = C200(2,1)
sage: a.is_square()
True

>>> from sage.all import *
>>> C200 = MPComplexField(Integer(200))
>>> a = C200(Integer(2),Integer(1))
>>> a.is_square()
True

C200 = MPComplexField(200)
a = C200(2,1)
a.is_square()

\(\CC\) is algebraically closed, hence every element is a square:

sage: b = C200(5)
sage: b.is_square()
True

>>> from sage.all import *
>>> b = C200(Integer(5))
>>> b.is_square()
True

b = C200(5)
b.is_square()
log()[source]

Return the logarithm of this complex number with the branch cut on the negative real axis:

\[\log(z) = \log |z| + i \arg(z).\]

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: log(u)
1.49786613677700 + 1.10714871779409*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> log(u)
1.49786613677700 + 1.10714871779409*I

MPC = MPComplexField()
u = MPC(2, 4)
log(u)
norm()[source]

Return the norm of a complex number, rounded with the rounding mode of the real part. The norm is the square of the absolute value:

\[\mathrm{norm}(a + ib) = a^2 + b^2.\]

OUTPUT:

A floating-point number in the real field of the real part (same precision, same rounding mode).

EXAMPLES:

This indeed acts as the square function when the imaginary component of self is equal to zero:

sage: MPC = MPComplexField()
sage: a = MPC(2,1)
sage: a.norm()
5.00000000000000
sage: b = MPC(4.2,0)
sage: b.norm()
17.6400000000000
sage: b^2
17.6400000000000

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> a = MPC(Integer(2),Integer(1))
>>> a.norm()
5.00000000000000
>>> b = MPC(RealNumber('4.2'),Integer(0))
>>> b.norm()
17.6400000000000
>>> b**Integer(2)
17.6400000000000

MPC = MPComplexField()
a = MPC(2,1)
a.norm()
b = MPC(4.2,0)
b.norm()
b^2
nth_root(n, all=False)[source]

The \(n\)-th root function.

INPUT:

  • all – boolean (default: False); if True, return a list of all \(n\)-th roots

EXAMPLES:

sage: MPC = MPComplexField()
sage: a = MPC(27)
sage: a.nth_root(3)
3.00000000000000
sage: a.nth_root(3, all=True)
[3.00000000000000, -1.50000000000000 + 2.59807621135332*I, -1.50000000000000 - 2.59807621135332*I]

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> a = MPC(Integer(27))
>>> a.nth_root(Integer(3))
3.00000000000000
>>> a.nth_root(Integer(3), all=True)
[3.00000000000000, -1.50000000000000 + 2.59807621135332*I, -1.50000000000000 - 2.59807621135332*I]

MPC = MPComplexField()
a = MPC(27)
a.nth_root(3)
a.nth_root(3, all=True)
prec()[source]

Return precision of this complex number.

EXAMPLES:

sage: i = MPComplexField(2000).0
sage: i.prec()
2000

>>> from sage.all import *
>>> i = MPComplexField(Integer(2000)).gen(0)
>>> i.prec()
2000

i = MPComplexField(2000).0
i.prec()
real()[source]

Return the real part of self.

EXAMPLES:

sage: C = MPComplexField(100)
sage: z = C(2, 3)
sage: x = z.real(); x
2.0000000000000000000000000000
sage: x.parent()
Real Field with 100 bits of precision

>>> from sage.all import *
>>> C = MPComplexField(Integer(100))
>>> z = C(Integer(2), Integer(3))
>>> x = z.real(); x
2.0000000000000000000000000000
>>> x.parent()
Real Field with 100 bits of precision

C = MPComplexField(100)
z = C(2, 3)
x = z.real(); x
x.parent()
sec()[source]

Return the secant of this complex number.

EXAMPLES:

sage: MPC = MPComplexField(100)
sage: MPC(1,1).sec()
0.49833703055518678521380589177 + 0.59108384172104504805039169297*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(100))
>>> MPC(Integer(1),Integer(1)).sec()
0.49833703055518678521380589177 + 0.59108384172104504805039169297*I

MPC = MPComplexField(100)
MPC(1,1).sec()
sech()[source]

Return the hyperbolic secant of this complex number.

EXAMPLES:

sage: MPC = MPComplexField(100)
sage: MPC(1,1).sech()
0.49833703055518678521380589177 - 0.59108384172104504805039169297*I

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(100))
>>> MPC(Integer(1),Integer(1)).sech()
0.49833703055518678521380589177 - 0.59108384172104504805039169297*I

MPC = MPComplexField(100)
MPC(1,1).sech()
sin()[source]

Return the sine of this complex number:

\[\sin(a + ib) = \sin a \cosh b + i \cos x \sinh b.\]

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: sin(u)
24.8313058489464 - 11.3566127112182*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> sin(u)
24.8313058489464 - 11.3566127112182*I

MPC = MPComplexField()
u = MPC(2, 4)
sin(u)
sinh()[source]

Return the hyperbolic sine of this complex number:

\[\sinh(a + ib) = \sinh a \cos b + i \cosh a \sin b.\]

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: sinh(u)
-2.37067416935200 - 2.84723908684883*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> sinh(u)
-2.37067416935200 - 2.84723908684883*I

MPC = MPComplexField()
u = MPC(2, 4)
sinh(u)
sqr()[source]

Return the square of a complex number:

\[(a + ib)^2 = (a^2 - b^2) + 2iab.\]

EXAMPLES:

sage: C = MPComplexField()
sage: a = C(5, 1)
sage: a.sqr()
24.0000000000000 + 10.0000000000000*I

>>> from sage.all import *
>>> C = MPComplexField()
>>> a = C(Integer(5), Integer(1))
>>> a.sqr()
24.0000000000000 + 10.0000000000000*I

C = MPComplexField()
a = C(5, 1)
a.sqr()
sqrt()[source]

Return the square root, taking the branch cut to be the negative real axis:

\[\sqrt z = \sqrt{|z|}(\cos(\arg(z)/2) + i \sin(\arg(z)/2)).\]

EXAMPLES:

sage: C = MPComplexField()
sage: a = C(24, 10)
sage: a.sqrt()
5.00000000000000 + 1.00000000000000*I

>>> from sage.all import *
>>> C = MPComplexField()
>>> a = C(Integer(24), Integer(10))
>>> a.sqrt()
5.00000000000000 + 1.00000000000000*I

C = MPComplexField()
a = C(24, 10)
a.sqrt()
str(base=10, **kwds)[source]

Return a string of self.

INPUT:

  • base – (default: 10) base for output

  • **kwds – other arguments to pass to the str() method of the real numbers in the real and imaginary parts

EXAMPLES:

sage: MPC = MPComplexField(64)
sage: z = MPC(-4, 3)/7
sage: z.str()
'-0.571428571428571428564 + 0.428571428571428571436*I'
sage: z.str(16)
'-0.92492492492492490 + 0.6db6db6db6db6db70*I'
sage: z.str(truncate=True)
'-0.571428571428571429 + 0.428571428571428571*I'
sage: z.str(2)
'-0.1001001001001001001001001001001001001001001001001001001001001001 + 0.01101101101101101101101101101101101101101101101101101101101101110*I'

>>> from sage.all import *
>>> MPC = MPComplexField(Integer(64))
>>> z = MPC(-Integer(4), Integer(3))/Integer(7)
>>> z.str()
'-0.571428571428571428564 + 0.428571428571428571436*I'
>>> z.str(Integer(16))
'-0.92492492492492490 + 0.6db6db6db6db6db70*I'
>>> z.str(truncate=True)
'-0.571428571428571429 + 0.428571428571428571*I'
>>> z.str(Integer(2))
'-0.1001001001001001001001001001001001001001001001001001001001001001 + 0.01101101101101101101101101101101101101101101101101101101101101110*I'

MPC = MPComplexField(64)
z = MPC(-4, 3)/7
z.str()
z.str(16)
z.str(truncate=True)
z.str(2)
tan()[source]

Return the tangent of this complex number:

\[\tan(a + ib) = (\sin 2a + i \sinh 2b)/(\cos 2a + \cosh 2b).\]

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(-2, 4)
sage: tan(u)
0.000507980623470039 + 1.00043851320205*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(-Integer(2), Integer(4))
>>> tan(u)
0.000507980623470039 + 1.00043851320205*I

MPC = MPComplexField()
u = MPC(-2, 4)
tan(u)
tanh()[source]

Return the hyperbolic tangent of this complex number:

\[\tanh(a + ib) = (\sinh 2a + i \sin 2b)/(\cosh 2a + \cos 2b).\]

EXAMPLES:

sage: MPC = MPComplexField()
sage: u = MPC(2, 4)
sage: tanh(u)
1.00468231219024 + 0.0364233692474037*I

>>> from sage.all import *
>>> MPC = MPComplexField()
>>> u = MPC(Integer(2), Integer(4))
>>> tanh(u)
1.00468231219024 + 0.0364233692474037*I

MPC = MPComplexField()
u = MPC(2, 4)
tanh(u)
zeta()[source]

Return the Riemann zeta function evaluated at this complex number.

EXAMPLES:

sage: i = MPComplexField(30).gen()
sage: z = 1 + i
sage: z.zeta()
0.58215806 - 0.92684856*I

>>> from sage.all import *
>>> i = MPComplexField(Integer(30)).gen()
>>> z = Integer(1) + i
>>> z.zeta()
0.58215806 - 0.92684856*I

i = MPComplexField(30).gen()
z = 1 + i
z.zeta()
class sage.rings.complex_mpc.MPCtoMPC[source]

Bases: Map

section()[source]

EXAMPLES:

sage: from sage.rings.complex_mpc import *
sage: C10 = MPComplexField(10)
sage: C100 = MPComplexField(100)
sage: f = MPCtoMPC(C100, C10)
sage: f.section()
Generic map:
  From: Complex Field with 10 bits of precision
  To:   Complex Field with 100 bits of precision

>>> from sage.all import *
>>> from sage.rings.complex_mpc import *
>>> C10 = MPComplexField(Integer(10))
>>> C100 = MPComplexField(Integer(100))
>>> f = MPCtoMPC(C100, C10)
>>> f.section()
Generic map:
  From: Complex Field with 10 bits of precision
  To:   Complex Field with 100 bits of precision

from sage.rings.complex_mpc import *
C10 = MPComplexField(10)
C100 = MPComplexField(100)
f = MPCtoMPC(C100, C10)
f.section()
class sage.rings.complex_mpc.MPFRtoMPC[source]

Bases: Map

sage.rings.complex_mpc.late_import()[source]

Import the objects/modules after build (when needed).

sage.rings.complex_mpc.split_complex_string(string, base=10)[source]

Split and return in that order the real and imaginary parts of a complex in a string.

This is an internal function.

EXAMPLES:

sage: sage.rings.complex_mpc.split_complex_string('123.456e789')
('123.456e789', None)
sage: sage.rings.complex_mpc.split_complex_string('123.456e789*I')
(None, '123.456e789')
sage: sage.rings.complex_mpc.split_complex_string('123.+456e789*I')
('123.', '+456e789')
sage: sage.rings.complex_mpc.split_complex_string('123.456e789', base=2)
(None, None)

>>> from sage.all import *
>>> sage.rings.complex_mpc.split_complex_string('123.456e789')
('123.456e789', None)
>>> sage.rings.complex_mpc.split_complex_string('123.456e789*I')
(None, '123.456e789')
>>> sage.rings.complex_mpc.split_complex_string('123.+456e789*I')
('123.', '+456e789')
>>> sage.rings.complex_mpc.split_complex_string('123.456e789', base=Integer(2))
(None, None)

sage.rings.complex_mpc.split_complex_string('123.456e789')
sage.rings.complex_mpc.split_complex_string('123.456e789*I')
sage.rings.complex_mpc.split_complex_string('123.+456e789*I')
sage.rings.complex_mpc.split_complex_string('123.456e789', base=2)