Arbitrary Precision Floating Point Complex Numbers#

AUTHORS:

William Stein (2006-01-26): complete rewrite
Joel B. Mohler (2006-12-16): naive rewrite into pyrex
William Stein(2007-01): rewrite of Mohler’s rewrite
Vincent Delecroix (2010-01): plot function
Niles Johnson (2010-08): github issue #3893: random_element() should pass on *args and **kwds.
Travis Scrimshaw (2012-10-18): Added documentation for full coverage
Vincent Klein (2017-11-14) : add __mpc__() to class ComplexNumber. ComplexNumber constructor support gmpy2.mpc parameter.

sage.rings.complex_mpfr.ComplexField(prec=53, names=None)#

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

EXAMPLES:

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

ComplexField()
ComplexField(100)
ComplexField(100).base_ring()
i = ComplexField(200).gen()
i^2

class sage.rings.complex_mpfr.ComplexField_class(prec=53)#

Bases: ComplexField

An approximation to the field of complex numbers using floating point numbers with any specified precision. Answers derived from calculations in this approximation may differ from what they would be if those calculations were performed in the true field of complex numbers. This is due to the rounding errors inherent to finite precision calculations.

EXAMPLES:

sage: C = ComplexField(); C
Complex Field with 53 bits of precision
sage: Q = RationalField()
sage: C(1/3)
0.333333333333333
sage: C(1/3, 2)
0.333333333333333 + 2.00000000000000*I
sage: C(RR.pi())
3.14159265358979
sage: C(RR.log2(), RR.pi())
0.693147180559945 + 3.14159265358979*I

C = ComplexField(); C
Q = RationalField()
C(1/3)
C(1/3, 2)
C(RR.pi())
C(RR.log2(), RR.pi())

We can also coerce rational numbers and integers into C, but coercing a polynomial will raise an exception:

sage: Q = RationalField()
sage: C(1/3)
0.333333333333333
sage: S = PolynomialRing(Q, 'x')
sage: C(S.gen())
Traceback (most recent call last):
...
TypeError: cannot convert nonconstant polynomial

Q = RationalField()
C(1/3)
S = PolynomialRing(Q, 'x')
C(S.gen())

This illustrates precision:

sage: CC = ComplexField(10); CC(1/3, 2/3)
0.33 + 0.67*I
sage: CC
Complex Field with 10 bits of precision
sage: CC = ComplexField(100); CC
Complex Field with 100 bits of precision
sage: z = CC(1/3, 2/3); z
0.33333333333333333333333333333 + 0.66666666666666666666666666667*I

CC = ComplexField(10); CC(1/3, 2/3)
CC
CC = ComplexField(100); CC
z = CC(1/3, 2/3); z

We can load and save complex numbers and the complex field:

sage: loads(z.dumps()) == z
True
sage: loads(CC.dumps()) == CC
True
sage: k = ComplexField(100)
sage: loads(dumps(k)) == k
True

loads(z.dumps()) == z
loads(CC.dumps()) == CC
k = ComplexField(100)
loads(dumps(k)) == k

This illustrates basic properties of a complex field:

sage: CC = ComplexField(200)
sage: CC.is_field()
True
sage: CC.characteristic()
0
sage: CC.precision()
200
sage: CC.variable_name()
'I'
sage: CC == ComplexField(200)
True
sage: CC == ComplexField(53)
False
sage: CC == 1.1
False

CC = ComplexField(200)
CC.is_field()
CC.characteristic()
CC.precision()
CC.variable_name()
CC == ComplexField(200)
CC == ComplexField(53)
CC == 1.1

algebraic_closure()#

Return the algebraic closure of self (which is itself).

EXAMPLES:

sage: CC
Complex Field with 53 bits of precision
sage: CC.algebraic_closure()
Complex Field with 53 bits of precision
sage: CC = ComplexField(1000)
sage: CC.algebraic_closure() is CC
True

CC
CC.algebraic_closure()
CC = ComplexField(1000)
CC.algebraic_closure() is CC

characteristic()#

Return the characteristic of $C$ , which is 0.

EXAMPLES:

sage: ComplexField().characteristic()
0

ComplexField().characteristic()

construction()#

Return the functorial construction of self, namely the algebraic closure of the real field with the same precision.

EXAMPLES:

sage: c, S = CC.construction(); S
Real Field with 53 bits of precision
sage: CC == c(S)
True

c, S = CC.construction(); S
CC == c(S)

gen(n=0)#

Return the generator of the complex field.

EXAMPLES:

sage: ComplexField().gen(0)
1.00000000000000*I

ComplexField().gen(0)

is_exact()#

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

EXAMPLES:

sage: ComplexField().is_exact()
False

ComplexField().is_exact()

ngens()#

The number of generators of this complex field as an $R$ -algebra.

There is one generator, namely sqrt(-1).

EXAMPLES:

sage: ComplexField().ngens()
1

ComplexField().ngens()

pi()#

Return $π$ as a complex number.

EXAMPLES:

sage: ComplexField().pi()
3.14159265358979
sage: ComplexField(100).pi()
3.1415926535897932384626433833

ComplexField().pi()
ComplexField(100).pi()

prec()#

Return the precision of this complex field.

EXAMPLES:

sage: ComplexField().prec()
53
sage: ComplexField(15).prec()
15

ComplexField().prec()
ComplexField(15).prec()

precision()#

Return the precision of this complex field.

EXAMPLES:

sage: ComplexField().prec()
53
sage: ComplexField(15).prec()
15

ComplexField().prec()
ComplexField(15).prec()

random_element(component_max=1, *args, **kwds)#

Return a uniformly distributed random number inside a square centered on the origin (by default, the square $[- 1, 1] \times [- 1, 1]$ ).

Passes additional arguments and keywords to underlying real field.

EXAMPLES:

sage: CC.random_element().parent() is CC
True
sage: re, im = CC.random_element()
sage: -1 <= re <= 1, -1 <= im <= 1
(True, True)
sage: CC6 = ComplexField(6)
sage: CC6.random_element().parent() is CC6
True
sage: re, im = CC6.random_element(2^-20)
sage: -2^-20 <= re <= 2^-20, -2^-20 <= im <= 2^-20
(True, True)
sage: re, im = CC6.random_element(pi^20)                                    # needs sage.symbolic
sage: bool(-pi^20 <= re <= pi^20), bool(-pi^20 <= im <= pi^20)              # needs sage.symbolic
(True, True)

CC.random_element().parent() is CC
re, im = CC.random_element()
-1 <= re <= 1, -1 <= im <= 1
CC6 = ComplexField(6)
CC6.random_element().parent() is CC6
re, im = CC6.random_element(2^-20)
-2^-20 <= re <= 2^-20, -2^-20 <= im <= 2^-20
re, im = CC6.random_element(pi^20)                                    # needs sage.symbolic
bool(-pi^20 <= re <= pi^20), bool(-pi^20 <= im <= pi^20)              # needs sage.symbolic

Passes extra positional or keyword arguments through:

sage: CC.random_element(distribution='1/n').parent() is CC
True

CC.random_element(distribution='1/n').parent() is CC

scientific_notation(status=None)#

Set or return the scientific notation printing flag.

If this flag is True then complex numbers with this space as parent print using scientific notation.

EXAMPLES:

sage: C = ComplexField()
sage: C((0.025, 2))
0.0250000000000000 + 2.00000000000000*I
sage: C.scientific_notation(True)
sage: C((0.025, 2))
2.50000000000000e-2 + 2.00000000000000e0*I
sage: C.scientific_notation(False)
sage: C((0.025, 2))
0.0250000000000000 + 2.00000000000000*I

C = ComplexField()
C((0.025, 2))
C.scientific_notation(True)
C((0.025, 2))
C.scientific_notation(False)
C((0.025, 2))

to_prec(prec)#

Return the complex field to the specified precision.

EXAMPLES:

sage: CC.to_prec(10)
Complex Field with 10 bits of precision
sage: CC.to_prec(100)
Complex Field with 100 bits of precision

CC.to_prec(10)
CC.to_prec(100)

zeta(n=2)#

Return a primitive $n$ -th root of unity.

INPUT:

n – an integer (default: 2)

OUTPUT: a complex $n$ -th root of unity.

EXAMPLES:

sage: C = ComplexField()
sage: C.zeta(2)
-1.00000000000000
sage: C.zeta(5)
0.309016994374947 + 0.951056516295154*I

C = ComplexField()
C.zeta(2)
C.zeta(5)

class sage.rings.complex_mpfr.ComplexNumber#

Bases: FieldElement

A floating point approximation to a complex number using any specified precision. Answers derived from calculations with such approximations may differ from what they would be if those calculations were performed with true complex numbers. This is due to the rounding errors inherent to finite precision calculations.

EXAMPLES:

sage: I = CC.0
sage: b = 1.5 + 2.5*I
sage: loads(b.dumps()) == b
True

I = CC.0
b = 1.5 + 2.5*I
loads(b.dumps()) == b

additive_order()#

Return the additive order of self.

EXAMPLES:

sage: CC(0).additive_order()
1
sage: CC.gen().additive_order()
+Infinity

CC(0).additive_order()
CC.gen().additive_order()

agm(right, algorithm='optimal')#

Return the Arithmetic-Geometric Mean (AGM) of self and right.

INPUT:

right (complex) – another complex number
algorithm (string, default "optimal") – the algorithm to use (see below).

OUTPUT:

(complex) A value of the AGM of self and right. Note that this is a multi-valued function, and the algorithm used affects the value returned, as follows:

"pari": Call the pari:agm function from the PARI library.
"optimal": Use the AGM sequence such that at each stage $(a, b)$ is replaced by $(a_{1}, b_{1}) = ((a + b) / 2, \pm \sqrt{a b})$ where the sign is chosen so that $| a_{1} - b_{1} | \leq | a_{1} + b_{1} |$ , or equivalently $ℜ (b_{1} / a_{1}) \geq 0$ . The resulting limit is maximal among all possible values.
"principal": Use the AGM sequence such that at each stage $(a, b)$ is replaced by $(a_{1}, b_{1}) = ((a + b) / 2, \pm \sqrt{a b})$ where the sign is chosen so that $ℜ (b_{1}) \geq 0$ (the so-called principal branch of the square root).

The values $A G M (a, 0)$ , $A G M (0, a)$ , and $A G M (a, - a)$ are all taken to be 0.

EXAMPLES:

sage: a = CC(1,1)
sage: b = CC(2,-1)
sage: a.agm(b)
1.62780548487271 + 0.136827548397369*I
sage: a.agm(b, algorithm="optimal")
1.62780548487271 + 0.136827548397369*I
sage: a.agm(b, algorithm="principal")
1.62780548487271 + 0.136827548397369*I
sage: a.agm(b, algorithm="pari")                                            # needs sage.libs.pari
1.62780548487271 + 0.136827548397369*I

a = CC(1,1)
b = CC(2,-1)
a.agm(b)
a.agm(b, algorithm="optimal")
a.agm(b, algorithm="principal")
a.agm(b, algorithm="pari")                                            # needs sage.libs.pari

An example to show that the returned value depends on the algorithm parameter:

sage: a = CC(-0.95,-0.65)
sage: b = CC(0.683,0.747)
sage: a.agm(b, algorithm="optimal")
-0.371591652351761 + 0.319894660206830*I
sage: a.agm(b, algorithm="principal")
0.338175462986180 - 0.0135326969565405*I
sage: a.agm(b, algorithm="pari")                                            # needs sage.libs.pari
-0.371591652351761 + 0.319894660206830*I
sage: a.agm(b, algorithm="optimal").abs()
0.490319232466314
sage: a.agm(b, algorithm="principal").abs()
0.338446122230459
sage: a.agm(b, algorithm="pari").abs()                                      # needs sage.libs.pari
0.490319232466314

a = CC(-0.95,-0.65)
b = CC(0.683,0.747)
a.agm(b, algorithm="optimal")
a.agm(b, algorithm="principal")
a.agm(b, algorithm="pari")                                            # needs sage.libs.pari
a.agm(b, algorithm="optimal").abs()
a.agm(b, algorithm="principal").abs()
a.agm(b, algorithm="pari").abs()                                      # needs sage.libs.pari

algdep(n, **kwds)#

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: C = ComplexField()
sage: z = (1/2)*(1 + sqrt(3.0) *C.0); z
0.500000000000000 + 0.866025403784439*I
sage: p = z.algdep(5); p
x^2 - x + 1
sage: p(z)
1.11022302462516e-16

C = ComplexField()
z = (1/2)*(1 + sqrt(3.0) *C.0); z
p = z.algdep(5); p
p(z)

algebraic_dependency(n, **kwds)#

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: C = ComplexField()
sage: z = (1/2)*(1 + sqrt(3.0) *C.0); z
0.500000000000000 + 0.866025403784439*I
sage: p = z.algdep(5); p
x^2 - x + 1
sage: p(z)
1.11022302462516e-16

C = ComplexField()
z = (1/2)*(1 + sqrt(3.0) *C.0); z
p = z.algdep(5); p
p(z)

arccos()#

Return the arccosine of self.

EXAMPLES:

sage: (1+CC(I)).arccos()                                                    # needs sage.libs.pari
0.904556894302381 - 1.06127506190504*I

(1+CC(I)).arccos()                                                    # needs sage.libs.pari

arccosh()#

Return the hyperbolic arccosine of self.

EXAMPLES:

sage: (1+CC(I)).arccosh()                                                   # needs sage.libs.pari
1.06127506190504 + 0.904556894302381*I

(1+CC(I)).arccosh()                                                   # needs sage.libs.pari

arccoth()#

Return the hyperbolic arccotangent of self.

EXAMPLES:

sage: ComplexField(100)(1,1).arccoth()                                      # needs sage.libs.pari
0.40235947810852509365018983331 - 0.55357435889704525150853273009*I

ComplexField(100)(1,1).arccoth()                                      # needs sage.libs.pari

arccsch()#

Return the hyperbolic arccosecant of self.

EXAMPLES:

sage: ComplexField(100)(1,1).arccsch()                                      # needs sage.libs.pari
0.53063753095251782601650945811 - 0.45227844715119068206365839783*I

ComplexField(100)(1,1).arccsch()                                      # needs sage.libs.pari

arcsech()#

Return the hyperbolic arcsecant of self.

EXAMPLES:

sage: ComplexField(100)(1,1).arcsech()                                      # needs sage.libs.pari
0.53063753095251782601650945811 - 1.1185178796437059371676632938*I

ComplexField(100)(1,1).arcsech()                                      # needs sage.libs.pari

arcsin()#

Return the arcsine of self.

EXAMPLES:

sage: (1+CC(I)).arcsin()                                                    # needs sage.libs.pari
0.666239432492515 + 1.06127506190504*I

(1+CC(I)).arcsin()                                                    # needs sage.libs.pari

arcsinh()#

Return the hyperbolic arcsine of self.

EXAMPLES:

sage: (1+CC(I)).arcsinh()                                                   # needs sage.libs.pari
1.06127506190504 + 0.666239432492515*I

(1+CC(I)).arcsinh()                                                   # needs sage.libs.pari

arctan()#

Return the arctangent of self.

EXAMPLES:

sage: (1+CC(I)).arctan()                                                    # needs sage.libs.pari
1.01722196789785 + 0.402359478108525*I

(1+CC(I)).arctan()                                                    # needs sage.libs.pari

arctanh()#

Return the hyperbolic arctangent of self.

EXAMPLES:

sage: (1+CC(I)).arctanh()                                                   # needs sage.libs.pari
0.402359478108525 + 1.01722196789785*I

(1+CC(I)).arctanh()                                                   # needs sage.libs.pari

arg()#

See argument().

EXAMPLES:

sage: i = CC.0
sage: (i^2).arg()
3.14159265358979

i = CC.0
(i^2).arg()

argument()#

The argument (angle) of the complex number, normalized so that $- π < θ \leq π$ .

EXAMPLES:

sage: i = CC.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

i = CC.0
(i^2).argument()
(1+i).argument()
i.argument()
(-i).argument()
(RR('-0.001') - i).argument()

conjugate()#

Return the complex conjugate of this complex number.

EXAMPLES:

sage: i = CC.0
sage: (1+i).conjugate()
1.00000000000000 - 1.00000000000000*I

i = CC.0
(1+i).conjugate()

cos()#

Return the cosine of self.

EXAMPLES:

sage: (1+CC(I)).cos()
0.833730025131149 - 0.988897705762865*I

(1+CC(I)).cos()

cosh()#

Return the hyperbolic cosine of self.

EXAMPLES:

sage: (1+CC(I)).cosh()
0.833730025131149 + 0.988897705762865*I

(1+CC(I)).cosh()

cot()#

Return the cotangent of self.

EXAMPLES:

sage: # needs sage.libs.pari
sage: (1+CC(I)).cot()
0.217621561854403 - 0.868014142895925*I
sage: i = ComplexField(200).0
sage: (1+i).cot()
0.21762156185440268136513424360523807352075436916785404091068 - 0.86801414289592494863584920891627388827343874994609327121115*I
sage: i = ComplexField(220).0
sage: (1+i).cot()
0.21762156185440268136513424360523807352075436916785404091068124239 - 0.86801414289592494863584920891627388827343874994609327121115071646*I

# needs sage.libs.pari
(1+CC(I)).cot()
i = ComplexField(200).0
(1+i).cot()
i = ComplexField(220).0
(1+i).cot()

coth()#

Return the hyperbolic cotangent of self.

EXAMPLES:

sage: ComplexField(100)(1,1).coth()                                         # needs sage.libs.pari
0.86801414289592494863584920892 - 0.21762156185440268136513424361*I

ComplexField(100)(1,1).coth()                                         # needs sage.libs.pari

csc()#

Return the cosecant of self.

EXAMPLES:

sage: ComplexField(100)(1,1).csc()                                          # needs sage.libs.pari
0.62151801717042842123490780586 - 0.30393100162842645033448560451*I

ComplexField(100)(1,1).csc()                                          # needs sage.libs.pari

csch()#

Return the hyperbolic cosecant of self.

EXAMPLES:

sage: ComplexField(100)(1,1).csch()                                         # needs sage.libs.pari
0.30393100162842645033448560451 - 0.62151801717042842123490780586*I

ComplexField(100)(1,1).csch()                                         # needs sage.libs.pari

dilog()#

Return the complex dilogarithm of self.

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

L i_{2} (z) = - \int_{0}^{z} \frac{\log | 1 - ζ |}{ζ} d (ζ) = \sum_{k = 1}^{\infty} \frac{z^{k}}{k}

Note that the series definition can only be used for $| z | < 1$ .

EXAMPLES:

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

a = ComplexNumber(1,0)
a.dilog()                                                             # needs sage.libs.pari
float(pi^2/6)                                                         # needs sage.symbolic

sage: b = ComplexNumber(0,1)
sage: b.dilog()                                                             # needs sage.libs.pari
-0.205616758356028 + 0.915965594177219*I

b = ComplexNumber(0,1)
b.dilog()                                                             # needs sage.libs.pari

sage: c = ComplexNumber(0,0)
sage: c.dilog()                                                             # needs sage.libs.pari
0.000000000000000

c = ComplexNumber(0,0)
c.dilog()                                                             # needs sage.libs.pari

eta(omit_frac=False)#

Return the value of the Dedekind $η$ function on self, intelligently computed using $SL (2, Z)$ transformations.

The $η$ function is

η (z) = e^{π i z / 12} \prod_{n = 1}^{\infty} (1 - e^{2 π i n z})

INPUT:

self – element of the upper half plane (if not, raises a ValueError).
omit_frac – (bool, default: False), if True, omit the $e^{π i z / 12}$ factor.

OUTPUT: a complex number

ALGORITHM: Uses the PARI C library.

EXAMPLES:

First we compute $η (1 + i)$ :

sage: i = CC.0
sage: z = 1 + i; z.eta()                                                    # needs sage.libs.pari
0.742048775836565 + 0.198831370229911*I

i = CC.0
z = 1 + i; z.eta()                                                    # needs sage.libs.pari

We compute eta to low precision directly from the definition:

sage: pi = CC(pi)        # otherwise we will get a symbolic result.         # needs sage.symbolic
sage: exp(pi * i * z / 12) * prod(1 - exp(2*pi*i*n*z)                       # needs sage.libs.pari sage.symbolic
....:                             for n in range(1,10))
0.742048775836565 + 0.198831370229911*I

pi = CC(pi)        # otherwise we will get a symbolic result.         # needs sage.symbolic
exp(pi * i * z / 12) * prod(1 - exp(2*pi*i*n*z)                       # needs sage.libs.pari sage.symbolic
                            for n in range(1,10))

The optional argument allows us to omit the fractional part:

sage: z.eta(omit_frac=True)                                                 # needs sage.libs.pari
0.998129069925959
sage: prod(1 - exp(2*pi*i*n*z) for n in range(1,10))                        # needs sage.libs.pari sage.symbolic
0.998129069925958 + 4.59099857829247e-19*I

z.eta(omit_frac=True)                                                 # needs sage.libs.pari
prod(1 - exp(2*pi*i*n*z) for n in range(1,10))                        # needs sage.libs.pari sage.symbolic

We illustrate what happens when $z$ is not in the upper half plane:

sage: z = CC(1)
sage: z.eta()                                                               # needs sage.libs.pari
Traceback (most recent call last):
...
ValueError: value must be in the upper half plane

z = CC(1)
z.eta()                                                               # needs sage.libs.pari

You can also use functional notation:

sage: eta(1 + CC(I))                                                        # needs sage.libs.pari
0.742048775836565 + 0.198831370229911*I

eta(1 + CC(I))                                                        # needs sage.libs.pari

exp()#

Compute $e^{z}$ or $\exp (z)$ .

EXAMPLES:

sage: i = ComplexField(300).0
sage: z = 1 + i
sage: z.exp()
1.46869393991588515713896759732660426132695673662900872279767567631093696585951213872272450 + 2.28735528717884239120817190670050180895558625666835568093865811410364716018934540926734485*I

i = ComplexField(300).0
z = 1 + i
z.exp()

gamma()#

Return the Gamma function evaluated at this complex number.

EXAMPLES:

sage: i = ComplexField(30).0
sage: (1 + i).gamma()                                                       # needs sage.libs.pari
0.49801567 - 0.15494983*I

i = ComplexField(30).0
(1 + i).gamma()                                                       # needs sage.libs.pari

gamma_inc(t)#

Return the incomplete Gamma function evaluated at this complex number.

EXAMPLES:

sage: # needs sage.libs.pari
sage: C, i = ComplexField(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
sage: CC(2).gamma_inc(5)
0.0404276819945128

# needs sage.libs.pari
C, i = ComplexField(30).objgen()
(1+i).gamma_inc(2 + 3*i)  # abs tol 2e-10
(1+i).gamma_inc(5)
C(2).gamma_inc(1 + i)
CC(2).gamma_inc(5)

imag()#

Return imaginary part of self.

EXAMPLES:

sage: i = ComplexField(100).0
sage: z = 2 + 3*i
sage: x = z.imag(); x
3.0000000000000000000000000000
sage: x.parent()
Real Field with 100 bits of precision
sage: z.imag_part()
3.0000000000000000000000000000

i = ComplexField(100).0
z = 2 + 3*i
x = z.imag(); x
x.parent()
z.imag_part()

imag_part()#

Return imaginary part of self.

EXAMPLES:

sage: i = ComplexField(100).0
sage: z = 2 + 3*i
sage: x = z.imag(); x
3.0000000000000000000000000000
sage: x.parent()
Real Field with 100 bits of precision
sage: z.imag_part()
3.0000000000000000000000000000

i = ComplexField(100).0
z = 2 + 3*i
x = z.imag(); x
x.parent()
z.imag_part()

is_NaN()#

Check if self is not-a-number.

EXAMPLES:

sage: CC(1, 2).is_NaN()
False
sage: CC(NaN).is_NaN()
True
sage: CC(NaN,2).log().is_NaN()
True

CC(1, 2).is_NaN()
CC(NaN).is_NaN()
CC(NaN,2).log().is_NaN()

is_imaginary()#

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

EXAMPLES:

sage: CC(1.23*i).is_imaginary()
True
sage: CC(1+i).is_imaginary()
False

CC(1.23*i).is_imaginary()
CC(1+i).is_imaginary()

is_infinity()#

Check if self is $\infty$ .

EXAMPLES:

sage: CC(1, 2).is_infinity()
False
sage: CC(0, oo).is_infinity()
True

CC(1, 2).is_infinity()
CC(0, oo).is_infinity()

is_integer()#

Return True if self is an integer.

EXAMPLES:

sage: CC(3).is_integer()
True
sage: CC(1,2).is_integer()
False

CC(3).is_integer()
CC(1,2).is_integer()

is_negative_infinity()#

Check if self is $- \infty$ .

EXAMPLES:

sage: CC(1, 2).is_negative_infinity()
False
sage: CC(-oo, 0).is_negative_infinity()
True
sage: CC(0, -oo).is_negative_infinity()
False

CC(1, 2).is_negative_infinity()
CC(-oo, 0).is_negative_infinity()
CC(0, -oo).is_negative_infinity()

is_positive_infinity()#

Check if self is $+ \infty$ .

EXAMPLES:

sage: CC(1, 2).is_positive_infinity()
False
sage: CC(oo, 0).is_positive_infinity()
True
sage: CC(0, oo).is_positive_infinity()
False

CC(1, 2).is_positive_infinity()
CC(oo, 0).is_positive_infinity()
CC(0, oo).is_positive_infinity()

is_real()#

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

EXAMPLES:

sage: CC(1.23).is_real()
True
sage: CC(1+i).is_real()
False

CC(1.23).is_real()
CC(1+i).is_real()

is_square()#

This function always returns true as $C$ is algebraically closed.

EXAMPLES:

sage: a = ComplexNumber(2,1)
sage: a.is_square()
True

a = ComplexNumber(2,1)
a.is_square()

$C$ is algebraically closed, hence every element is a square:

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

b = ComplexNumber(5)
b.is_square()

log(base=None)#

Complex logarithm of $z$ with branch chosen as follows: Write $z = ρ e^{i θ}$ with $- π < θ \leq π$ . Then $\log (z) = \log (ρ) + i θ$ .

Warning

Currently the real log is computed using floats, so there is potential precision loss.

EXAMPLES:

sage: a = ComplexNumber(2,1)
sage: a.log()
0.804718956217050 + 0.463647609000806*I
sage: log(a.abs())
0.804718956217050
sage: a.argument()
0.463647609000806

a = ComplexNumber(2,1)
a.log()
log(a.abs())
a.argument()

sage: b = ComplexNumber(float(exp(42)),0)
sage: b.log()  # abs tol 1e-12
41.99999999999971

b = ComplexNumber(float(exp(42)),0)
b.log()  # abs tol 1e-12

sage: c = ComplexNumber(-1,0)
sage: c.log()
3.14159265358979*I

c = ComplexNumber(-1,0)
c.log()

The option of a base is included for compatibility with other logs:

sage: c = ComplexNumber(-1,0)
sage: c.log(2)
4.53236014182719*I

c = ComplexNumber(-1,0)
c.log(2)

If either component (real or imaginary) of the complex number is NaN (not a number), log will return the complex NaN:

sage: c = ComplexNumber(NaN,2)
sage: c.log()
NaN + NaN*I

c = ComplexNumber(NaN,2)
c.log()

multiplicative_order()#

Return the multiplicative order of this complex number, if known, or raise a NotImplementedError.

EXAMPLES:

sage: C.<i> = ComplexField()
sage: i.multiplicative_order()
4
sage: C(1).multiplicative_order()
1
sage: C(-1).multiplicative_order()
2
sage: C(i^2).multiplicative_order()
2
sage: C(-i).multiplicative_order()
4
sage: C(2).multiplicative_order()
+Infinity
sage: w = (1+sqrt(-3.0))/2; w
0.500000000000000 + 0.866025403784439*I
sage: abs(w)
1.00000000000000
sage: w.multiplicative_order()
Traceback (most recent call last):
...
NotImplementedError: order of element not known

C.<i> = ComplexField()
i.multiplicative_order()
C(1).multiplicative_order()
C(-1).multiplicative_order()
C(i^2).multiplicative_order()
C(-i).multiplicative_order()
C(2).multiplicative_order()
w = (1+sqrt(-3.0))/2; w
abs(w)
w.multiplicative_order()

norm()#

Return the norm of this complex number.

If $c = a + b i$ is a complex number, then the norm of $c$ is defined as the product of $c$ and its complex conjugate:

norm (c) = norm (a + b i) = c \cdot \overset{―}{c} = a^{2} + b^{2} .

The norm of a complex number is different from its absolute value. The absolute value of a complex number is defined to be the square root of its norm. A typical use of the complex norm is in the integral domain $Z [i]$ of Gaussian integers, where the norm of each Gaussian integer $c = a + b i$ is defined as its complex norm.

See also

EXAMPLES:

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

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

a = ComplexNumber(2,1)
a.norm()
b = ComplexNumber(4.2,0)
b.norm()
b^2

nth_root(n, all=False)#

The $n$ -th root function.

INPUT:

all – bool (default: False); if True, return a list of all $n$ -th roots.

EXAMPLES:

sage: a = CC(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]
sage: a = ComplexField(20)(2,1)
sage: [r^7 for r in a.nth_root(7, all=True)]
[2.0000 + 1.0000*I, 2.0000 + 1.0000*I, 2.0000 + 1.0000*I, 2.0000 + 1.0000*I,
 2.0000 + 1.0000*I, 2.0000 + 1.0001*I, 2.0000 + 1.0001*I]

a = CC(27)
a.nth_root(3)
a.nth_root(3, all=True)
a = ComplexField(20)(2,1)
[r^7 for r in a.nth_root(7, all=True)]

plot(**kargs)#

Plots this complex number as a point in the plane

The accepted options are the ones of point2d(). Type point2d.options to see all options.

Note

Just wraps the sage.plot.point.point2d method

EXAMPLES:

You can either use the indirect:

sage: z = CC(0,1)
sage: plot(z)                                                               # needs sage.plot
Graphics object consisting of 1 graphics primitive

z = CC(0,1)
plot(z)                                                               # needs sage.plot

or the more direct:

sage: z = CC(0,1)
sage: z.plot()                                                              # needs sage.plot
Graphics object consisting of 1 graphics primitive

z = CC(0,1)
z.plot()                                                              # needs sage.plot

prec()#

Return precision of this complex number.

EXAMPLES:

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

i = ComplexField(2000).0
i.prec()

real()#

Return real part of self.

EXAMPLES:

sage: i = ComplexField(100).0
sage: z = 2 + 3*i
sage: x = z.real(); x
2.0000000000000000000000000000
sage: x.parent()
Real Field with 100 bits of precision
sage: z.real_part()
2.0000000000000000000000000000

i = ComplexField(100).0
z = 2 + 3*i
x = z.real(); x
x.parent()
z.real_part()

real_part()#

Return real part of self.

EXAMPLES:

sage: i = ComplexField(100).0
sage: z = 2 + 3*i
sage: x = z.real(); x
2.0000000000000000000000000000
sage: x.parent()
Real Field with 100 bits of precision
sage: z.real_part()
2.0000000000000000000000000000

i = ComplexField(100).0
z = 2 + 3*i
x = z.real(); x
x.parent()
z.real_part()

sec()#

Return the secant of self.

EXAMPLES:

sage: ComplexField(100)(1,1).sec()                                          # needs sage.libs.pari
0.49833703055518678521380589177 + 0.59108384172104504805039169297*I

ComplexField(100)(1,1).sec()                                          # needs sage.libs.pari

sech()#

Return the hyperbolic secant of self.

EXAMPLES:

sage: ComplexField(100)(1,1).sech()                                         # needs sage.libs.pari
0.49833703055518678521380589177 - 0.59108384172104504805039169297*I

ComplexField(100)(1,1).sech()                                         # needs sage.libs.pari

sin()#

Return the sine of self.

EXAMPLES:

sage: (1+CC(I)).sin()
1.29845758141598 + 0.634963914784736*I

(1+CC(I)).sin()

sinh()#

Return the hyperbolic sine of self.

EXAMPLES:

sage: (1+CC(I)).sinh()
0.634963914784736 + 1.29845758141598*I

(1+CC(I)).sinh()

sqrt(all=False)#

The square root function, taking the branch cut to be the negative real axis.

INPUT:

all – bool (default: False); if True, return a list of all square roots.

EXAMPLES:

sage: C.<i> = ComplexField(30)
sage: i.sqrt()
0.70710678 + 0.70710678*I
sage: (1+i).sqrt()
1.0986841 + 0.45508986*I
sage: (C(-1)).sqrt()
1.0000000*I
sage: (1 + 1e-100*i).sqrt()^2
1.0000000 + 1.0000000e-100*I
sage: i = ComplexField(200).0
sage: i.sqrt()
0.70710678118654752440084436210484903928483593768847403658834 + 0.70710678118654752440084436210484903928483593768847403658834*I

C.<i> = ComplexField(30)
i.sqrt()
(1+i).sqrt()
(C(-1)).sqrt()
(1 + 1e-100*i).sqrt()^2
i = ComplexField(200).0
i.sqrt()

str(base=10, istr='I', **kwds)#

Return a string representation of self.

INPUT:

base – (default: 10) base for output
istr – (default: I) String representation of the complex unit
**kwds – other arguments to pass to the str() method of the real numbers in the real and imaginary parts.

EXAMPLES:

sage: # needs sage.symbolic
sage: a = CC(pi + I*e); a
3.14159265358979 + 2.71828182845905*I
sage: a.str(truncate=True)
'3.14159265358979 + 2.71828182845905*I'
sage: a.str()
'3.1415926535897931 + 2.7182818284590451*I'
sage: a.str(base=2)
'11.001001000011111101101010100010001000010110100011000 + 10.101101111110000101010001011000101000101011101101001*I'
sage: CC(0.5 + 0.625*I).str(base=2)
'0.10000000000000000000000000000000000000000000000000000 + 0.10100000000000000000000000000000000000000000000000000*I'
sage: a.str(base=16)
'3.243f6a8885a30 + 2.b7e151628aed2*I'
sage: a.str(base=36)
'3.53i5ab8p5fc + 2.puw5nggjf8f*I'

sage: CC(0)
0.000000000000000
sage: CC.0.str(istr='%i')
'1.0000000000000000*%i'

# needs sage.symbolic
a = CC(pi + I*e); a
a.str(truncate=True)
a.str()
a.str(base=2)
CC(0.5 + 0.625*I).str(base=2)
a.str(base=16)
a.str(base=36)
CC(0)
CC.0.str(istr='%i')

tan()#

Return the tangent of self.

EXAMPLES:

sage: (1+CC(I)).tan()
0.271752585319512 + 1.08392332733869*I

(1+CC(I)).tan()

tanh()#

Return the hyperbolic tangent of self.

EXAMPLES:

sage: (1+CC(I)).tanh()
1.08392332733869 + 0.271752585319512*I

(1+CC(I)).tanh()

zeta()#

Return the Riemann zeta function evaluated at this complex number.

EXAMPLES:

sage: i = ComplexField(30).gen()
sage: z = 1 + i
sage: z.zeta()                                                              # needs sage.libs.pari
0.58215806 - 0.92684856*I
sage: zeta(z)                                                               # needs sage.libs.pari
0.58215806 - 0.92684856*I

sage: CC(1).zeta()
Infinity

i = ComplexField(30).gen()
z = 1 + i
z.zeta()                                                              # needs sage.libs.pari
zeta(z)                                                               # needs sage.libs.pari
CC(1).zeta()

class sage.rings.complex_mpfr.RRtoCC#

Bases: Map

EXAMPLES:

sage: from sage.rings.complex_mpfr import RRtoCC
sage: RRtoCC(RR, CC)
Natural map:
  From: Real Field with 53 bits of precision
  To:   Complex Field with 53 bits of precision

from sage.rings.complex_mpfr import RRtoCC
RRtoCC(RR, CC)

sage.rings.complex_mpfr.cmp_abs(a, b)#

Return $- 1$ , $0$ , or $1$ according to whether $| a |$ is less than, equal to, or greater than $| b |$ .

Optimized for non-close numbers, where the ordering can be determined by examining exponents.

EXAMPLES:

sage: from sage.rings.complex_mpfr import cmp_abs
sage: cmp_abs(CC(5), CC(1))
1
sage: cmp_abs(CC(5), CC(4))
1
sage: cmp_abs(CC(5), CC(5))
0
sage: cmp_abs(CC(5), CC(6))
-1
sage: cmp_abs(CC(5), CC(100))
-1
sage: cmp_abs(CC(-100), CC(1))
1
sage: cmp_abs(CC(-100), CC(100))
0
sage: cmp_abs(CC(-100), CC(1000))
-1
sage: cmp_abs(CC(1,1), CC(1))
1
sage: cmp_abs(CC(1,1), CC(2))
-1
sage: cmp_abs(CC(1,1), CC(1,0.99999))
1
sage: cmp_abs(CC(1,1), CC(1,-1))
0
sage: cmp_abs(CC(0), CC(1))
-1
sage: cmp_abs(CC(1), CC(0))
1
sage: cmp_abs(CC(0), CC(0))
0
sage: cmp_abs(CC(2,1), CC(1,2))
0

from sage.rings.complex_mpfr import cmp_abs
cmp_abs(CC(5), CC(1))
cmp_abs(CC(5), CC(4))
cmp_abs(CC(5), CC(5))
cmp_abs(CC(5), CC(6))
cmp_abs(CC(5), CC(100))
cmp_abs(CC(-100), CC(1))
cmp_abs(CC(-100), CC(100))
cmp_abs(CC(-100), CC(1000))
cmp_abs(CC(1,1), CC(1))
cmp_abs(CC(1,1), CC(2))
cmp_abs(CC(1,1), CC(1,0.99999))
cmp_abs(CC(1,1), CC(1,-1))
cmp_abs(CC(0), CC(1))
cmp_abs(CC(1), CC(0))
cmp_abs(CC(0), CC(0))
cmp_abs(CC(2,1), CC(1,2))

sage.rings.complex_mpfr.create_ComplexNumber(s_real, s_imag=None, pad=0, min_prec=53)#

Return the complex number defined by the strings s_real and s_imag as an element of ComplexField(prec=n), where $n$ potentially has slightly more (controlled by pad) bits than given by $s$ .

INPUT:

s_real – a string that defines a real number (or something whose string representation defines a number)
s_imag – a string that defines a real number (or something whose string representation defines a number)
pad – an integer at least 0.
min_prec – number will have at least this many bits of precision, no matter what.

EXAMPLES:

sage: ComplexNumber('2.3')
2.30000000000000
sage: ComplexNumber('2.3','1.1')
2.30000000000000 + 1.10000000000000*I
sage: ComplexNumber(10)
10.0000000000000
sage: ComplexNumber(10,10)
10.0000000000000 + 10.0000000000000*I
sage: ComplexNumber(1.000000000000000000000000000,2)
1.00000000000000000000000000 + 2.00000000000000000000000000*I
sage: ComplexNumber(1,2.000000000000000000000)
1.00000000000000000000 + 2.00000000000000000000*I

ComplexNumber('2.3')
ComplexNumber('2.3','1.1')
ComplexNumber(10)
ComplexNumber(10,10)
ComplexNumber(1.000000000000000000000000000,2)
ComplexNumber(1,2.000000000000000000000)

sage: sage.rings.complex_mpfr.create_ComplexNumber(s_real=2,s_imag=1)
2.00000000000000 + 1.00000000000000*I

sage.rings.complex_mpfr.create_ComplexNumber(s_real=2,s_imag=1)

sage.rings.complex_mpfr.is_ComplexNumber(x)#

Return True if x is a complex number. In particular, if x is of the ComplexNumber type.

EXAMPLES:

sage: from sage.rings.complex_mpfr import is_ComplexNumber
sage: a = ComplexNumber(1, 2); a
1.00000000000000 + 2.00000000000000*I
sage: is_ComplexNumber(a)
True
sage: b = ComplexNumber(1); b
1.00000000000000
sage: is_ComplexNumber(b)
True

from sage.rings.complex_mpfr import is_ComplexNumber
a = ComplexNumber(1, 2); a
is_ComplexNumber(a)
b = ComplexNumber(1); b
is_ComplexNumber(b)

Note that the global element I is a number field element, of type sage.rings.number_field.number_field_element_quadratic.NumberFieldElement_gaussian, while elements of the class ComplexField_class are of type ComplexNumber:

sage: # needs sage.symbolic
sage: c = 1 + 2*I
sage: is_ComplexNumber(c)
False
sage: d = CC(1 + 2*I)
sage: is_ComplexNumber(d)
True

# needs sage.symbolic
c = 1 + 2*I
is_ComplexNumber(c)
d = CC(1 + 2*I)
is_ComplexNumber(d)

sage.rings.complex_mpfr.late_import()#: Import the objects/modules after build (when needed).

sage.rings.complex_mpfr.make_ComplexNumber0(fld, mult_order, re, im)#

Create a complex number for pickling.

EXAMPLES:

sage: a = CC(1 + I)
sage: loads(dumps(a)) == a # indirect doctest
True

a = CC(1 + I)
loads(dumps(a)) == a # indirect doctest

sage.rings.complex_mpfr.set_global_complex_round_mode(n)#

Set the global complex rounding mode.

Warning

Do not call this function explicitly. The default rounding mode is n = 0.

EXAMPLES:

sage: sage.rings.complex_mpfr.set_global_complex_round_mode(0)

sage.rings.complex_mpfr.set_global_complex_round_mode(0)