AUTHORS:
EXAMPLES:
sage: from sage.rings.complex_number import CCtoCDF
sage: f = CCtoCDF(CC, CDF)
sage: f(CC.0)
1.0*I
sage: f(exp(pi*CC.0/4))
0.707106781187 + 0.707106781187*I
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
Method for computing the absolute value or modulus of self
EXAMPLES: Note that the absolute value of a complex number with imaginary component equal to zero is the absolute value of the real component.
sage: a = ComplexNumber(2,1)
sage: abs(a)
2.23606797749979
sage: a.__abs__()
2.23606797749979
sage: float(sqrt(2^2 + 1^1))
2.2360679774997898
sage: b = ComplexNumber(42,0)
sage: abs(b)
42.0000000000000
sage: b.__abs__()
42.0000000000000
sage: b
42.0000000000000
Method for converting self to type complex. Called by the complex function.
EXAMPLES:
sage: a = ComplexNumber(2,1)
sage: complex(a)
(2+1j)
sage: type(complex(a))
<type 'complex'>
sage: a.__complex__()
(2+1j)
Method for converting self to type float. Called by the float function. Note that calling this method returns an error since, in general, complex numbers cannot be coerced into floats.
EXAMPLES:
sage: a = ComplexNumber(2,1)
sage: float(a)
...
TypeError: can't convert complex to float; use abs(z)
sage: a.__float__()
...
TypeError: can't convert complex to float; use abs(z)
Returns either the real or imaginary component of self depending on the choice of i: real (i=0), imaginary (i=1)
INPUTS:
EXAMPLES:
sage: a = ComplexNumber(2,1)
sage: a.__getitem__(0)
2.00000000000000
sage: a.__getitem__(1)
1.00000000000000
sage: b = CC(42,0)
sage: b
42.0000000000000
sage: b.__getitem__(1)
0.000000000000000
Method for converting self to type int. Called by the int function. Note that calling this method returns an error since, in general, complex numbers cannot be coerced into integers.
EXAMPLES:
sage: a = ComplexNumber(2,1)
sage: int(a)
...
TypeError: can't convert complex to int; use int(abs(z))
sage: a.__int__()
...
TypeError: can't convert complex to int; use int(abs(z))
Return the multiplicative inverse.
EXAMPLES:
sage: I = CC.0
sage: a = ~(5+I)
sage: a * (5+I)
1.00000000000000
Method for converting self to type long. Called by the long function. Note that calling this method returns an error since, in general, complex numbers cannot be coerced into integers.
EXAMPLES:
sage: a = ComplexNumber(2,1)
sage: long(a)
...
TypeError: can't convert complex to long; use long(abs(z))
sage: a.__long__()
...
TypeError: can't convert complex to long; use long(abs(z))
Method for computing the negative of self.
-(a + bi) = -a - bi
EXAMPLES:
sage: a = ComplexNumber(2,1)
sage: -a
-2.00000000000000 - 1.00000000000000*I
sage: a.__neg__()
-2.00000000000000 - 1.00000000000000*I
Method for computing the “positive” of self.
EXAMPLES:
sage: a = ComplexNumber(2,1)
sage: +a
2.00000000000000 + 1.00000000000000*I
sage: a.__pos__()
2.00000000000000 + 1.00000000000000*I
Returns the quotient of left with self, that is:
left/self
as a complex number.
INPUTS:
EXAMPLES:
sage: a = ComplexNumber(2,0)
sage: a.__rdiv__(CC(1))
0.500000000000000
sage: CC(1)/a
0.500000000000000
Pickling support
EXAMPLES:
sage: a = CC(1 + I)
sage: loads(dumps(a)) == a
True
Returns self formatted as a string, suitable as input to another computer algebra system. (This is the default function used for exporting to other computer algebra systems.)
EXAMPLES:
sage: s1 = CC(exp(I)); s1
0.540302305868140 + 0.841470984807897*I
sage: s1._interface_init_()
'0.54030230586813977 + 0.84147098480789650*I'
sage: s1 == CC(gp(s1))
True
Method for converting self to a string with latex formatting. Called by the global function latex.
EXAMPLES:
sage: a = ComplexNumber(2,1)
sage: a
2.00000000000000 + 1.00000000000000*I
sage: latex(a)
2.00000000000000 + 1.00000000000000i
sage: a._latex_()
'2.00000000000000 + 1.00000000000000i'
sage: b = ComplexNumber(7,4,min_prec=16)
sage: b
7.000 + 4.000*I
sage: latex(b)
7.000 + 4.000i
sage: b._latex_()
'7.000 + 4.000i'
EXAMPLES:
sage: magma(CC([1, 2])) # optional - magma
1.00000000000000 + 2.00000000000000*$.1
sage: v = magma(CC([1, 2])).sage(); v # optional - magma
1.00000000000000 + 2.00000000000000*I
sage: v.parent() # optional - magma
Complex Field with 53 bits of precision
Returns an mpmath version of this ComplexNumber.
Note
Currently, the rounding mode is ignored.
EXAMPLES:
sage: CC(1,2)._mpmath_()
mpc(real='1.0', imag='2.0')
Coerces self into a Pari complex object.
EXAMPLES: Coerce the object using the pari function:
sage: a = ComplexNumber(2,1)
sage: pari(a)
2.00000000000000 + 1.00000000000000*I
sage: type(pari(a))
<type 'sage.libs.pari.gen.gen'>
sage: a._pari_()
2.00000000000000 + 1.00000000000000*I
sage: type(a._pari_())
<type 'sage.libs.pari.gen.gen'>
Returns self formatted as a string.
EXAMPLES:
sage: a = ComplexNumber(2,1); a
2.00000000000000 + 1.00000000000000*I
sage: a._repr_()
'2.00000000000000 + 1.00000000000000*I'
Produce an expression which will reproduce this value when evaluated.
Function for setting the ComplexNumber class attribute multiplicative_order of self.
INPUTS: n - an integer which will define the multiplicative order of self
EXAMPLES: Note that it is not advisable to explicitly call _set_multiplicative_order for explicitly declared complex numbers.
sage: a = ComplexNumber(2,1)
sage: a.multiplicative_order()
+Infinity
sage: a._set_multiplicative_order(5)
sage: a.multiplicative_order()
5
sage: a^5
-38.0000000000000 + 41.0000000000000*I
EXAMPLES:
sage: CC(0).additive_order()
1
sage: CC.gen().additive_order()
+Infinity
EXAMPLES:
sage: (1+CC(I)).agm(2-I)
1.62780548487271 + 0.136827548397369*I
Returns a polynomial of degree at most which is
approximately satisfied by this complex number. Note that the
returned polynomial need not be irreducible, and indeed usually
won’t be if
is a good approximation to an algebraic
number of degree less than
.
ALGORITHM: Uses the PARI C-library algdep command.
INPUT: Type algdep? at the top level prompt. All additional parameters are passed onto the top-level algdep command.
EXAMPLE:
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^5 + x^2
sage: p.factor()
(x + 1) * x^2 * (x^2 - x + 1)
sage: z^2 - z + 1
1.11022302462516e-16
Returns a polynomial of degree at most which is
approximately satisfied by this complex number. Note that the
returned polynomial need not be irreducible, and indeed usually
won’t be if
is a good approximation to an algebraic
number of degree less than
.
ALGORITHM: Uses the PARI C-library algdep command.
INPUT: Type algdep? at the top level prompt. All additional parameters are passed onto the top-level algdep command.
EXAMPLE:
sage: C = ComplexField()
sage: z = (1/2)*(1 + sqrt(3.0) *C.0); z
0.500000000000000 + 0.866025403784439*I
sage: p = z.algebraic_dependancy(5); p
x^5 + x^2
sage: p.factor()
(x + 1) * x^2 * (x^2 - x + 1)
sage: z^2 - z + 1
1.11022302462516e-16
EXAMPLES:
sage: (1+CC(I)).arccos()
0.904556894302381 - 1.06127506190504*I
EXAMPLES:
sage: (1+CC(I)).arccosh()
1.06127506190504 + 0.904556894302381*I
EXAMPLES:
sage: ComplexField(100)(1,1).arccoth()
0.40235947810852509365018983331 - 0.55357435889704525150853273009*I
EXAMPLES:
sage: ComplexField(100)(1,1).arccsch()
0.53063753095251782601650945811 - 0.45227844715119068206365839783*I
EXAMPLES:
sage: ComplexField(100)(1,1).arcsech()
-0.53063753095251782601650945811 + 1.1185178796437059371676632938*I
EXAMPLES:
sage: (1+CC(I)).arcsin()
0.666239432492515 + 1.06127506190504*I
EXAMPLES:
sage: (1+CC(I)).arcsinh()
1.06127506190504 + 0.666239432492515*I
EXAMPLES:
sage: (1+CC(I)).arctan()
1.01722196789785 + 0.402359478108525*I
EXAMPLES:
sage: (1+CC(I)).arctanh()
0.402359478108525 + 1.01722196789785*I
Same as argument.
EXAMPLES:
sage: i = CC.0
sage: (i^2).arg()
3.14159265358979
The argument (angle) of the complex number, normalized so that
.
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
Return the complex conjugate of this complex number.
EXAMPLES:
sage: i = CC.0
sage: (1+i).conjugate()
1.00000000000000 - 1.00000000000000*I
EXAMPLES:
sage: (1+CC(I)).cos()
0.833730025131149 - 0.988897705762865*I
EXAMPLES:
sage: (1+CC(I)).cosh()
0.833730025131149 + 0.988897705762865*I
EXAMPLES:
sage: (1+CC(I)).cotan()
0.217621561854403 - 0.868014142895925*I
sage: i = ComplexField(200).0
sage: (1+i).cotan()
0.21762156185440268136513424360523807352075436916785404091068 - 0.86801414289592494863584920891627388827343874994609327121115*I
sage: i = ComplexField(220).0
sage: (1+i).cotan()
0.21762156185440268136513424360523807352075436916785404091068124239 - 0.86801414289592494863584920891627388827343874994609327121115071646*I
EXAMPLES:
sage: ComplexField(100)(1,1).coth()
0.86801414289592494863584920892 - 0.21762156185440268136513424361*I
EXAMPLES:
sage: ComplexField(100)(1,1).csc()
0.62151801717042842123490780586 - 0.30393100162842645033448560451*I
EXAMPLES:
sage: ComplexField(100)(1,1).csch()
0.30393100162842645033448560451 - 0.62151801717042842123490780586*I
Returns the complex dilogarithm of self. The complex dilogarithm, or Spence’s function, is defined by
Note that the series definition can only be used for
EXAMPLES:
sage: a = ComplexNumber(1,0)
sage: a.dilog()
1.64493406684823
sage: float(pi^2/6)
1.6449340668482262
sage: b = ComplexNumber(0,1)
sage: b.dilog()
-0.205616758356028 + 0.915965594177219*I
sage: c = ComplexNumber(0,0)
sage: c.dilog()
0
Return the value of the Dedekind function on self,
intelligently computed using
transformations.
INPUT:
OUTPUT: a complex number
The function is
ALGORITHM: Uses the PARI C library.
EXAMPLES:
First we compute :
sage: i = CC.0
sage: z = 1+i; z.eta()
0.742048775836565 + 0.198831370229911*I
We compute eta to low precision directly from the definition.
sage: z = 1 + i; z.eta()
0.742048775836565 + 0.198831370229911*I
sage: pi = CC(pi) # otherwise we will get a symbolic result.
sage: exp(pi * i * z / 12) * prod([1-exp(2*pi*i*n*z) for n in range(1,10)])
0.742048775836565 + 0.198831370229911*I
The optional argument allows us to omit the fractional part:
sage: z = 1 + i
sage: z.eta(omit_frac=True)
0.998129069925959 - 8.12769318...e-22*I
sage: prod([1-exp(2*pi*i*n*z) for n in range(1,10)])
0.998129069925958 + 4.59099857829247e-19*I
We illustrate what happens when is not in the upper
half plane.
sage: z = CC(1)
sage: z.eta()
...
ValueError: value must be in the upper half plane
You can also use functional notation.
sage: eta(1+CC(I))
0.742048775836565 + 0.198831370229911*I
Compute exp(z).
EXAMPLES:
sage: i = ComplexField(300).0
sage: z = 1 + i
sage: z.exp()
1.46869393991588515713896759732660426132695673662900872279767567631093696585951213872272450 + 2.28735528717884239120817190670050180895558625666835568093865811410364716018934540926734485*I
Return the Gamma function evaluated at this complex number.
EXAMPLES:
sage: i = ComplexField(30).0
sage: (1+i).gamma()
0.49801567 - 0.15494983*I
TESTS:
sage: CC(0).gamma()
Infinity
sage: CC(-1).gamma()
Infinity
Return the incomplete Gamma function evaluated at this complex number.
EXAMPLES:
sage: C, i = ComplexField(30).objgen()
sage: (1+i).gamma_inc(2 + 3*i)
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: gamma_inc(2, 1 + i)
0.70709210 - 0.42035364*I
sage: gamma_inc(2, 5)
0.0404276819945128
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
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
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
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
This function always returns true as is
algebraically closed.
EXAMPLES:
sage: a = ComplexNumber(2,1)
sage: a.is_square()
True
is algebraically closed, hence every element
is a square:
sage: b = ComplexNumber(5)
sage: b.is_square()
True
Complex logarithm of z with branch chosen as follows: Write
. Then
.
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
sage: b = ComplexNumber(float(exp(42)),0)
sage: b.log()
41.99999999999971
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()
...
NotImplementedError: order of element not known
Returns the norm of this complex number. If is a
complex number, then the norm of
is defined as
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 of Gaussian integers, where the norm of
each Gaussian integer
is defined as its complex norm.
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
The n-th root function.
INPUT:
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]
Return precision of this complex number.
EXAMPLES:
sage: i = ComplexField(2000).0
sage: i.prec()
2000
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
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
EXAMPLES:
sage: ComplexField(100)(1,1).sec()
0.49833703055518678521380589177 + 0.59108384172104504805039169297*I
EXAMPLES:
sage: ComplexField(100)(1,1).sech()
0.49833703055518678521380589177 - 0.59108384172104504805039169297*I
EXAMPLES:
sage: (1+CC(I)).sin()
1.29845758141598 + 0.634963914784736*I
EXAMPLES:
sage: (1+CC(I)).sinh()
0.634963914784736 + 1.29845758141598*I
The square root function, taking the branch cut to be the negative real axis.
INPUT:
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
Return a string representation of this number.
INPUTS:
EXAMPLES:
sage: a = CC(pi + I*e)
sage: a.str()
'3.14159265358979 + 2.71828182845905*I'
sage: a.str(truncate=False)
'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'
EXAMPLES:
sage: (1+CC(I)).tan()
0.271752585319512 + 1.08392332733869*I
EXAMPLES:
sage: (1+CC(I)).tanh()
1.08392332733869 + 0.271752585319512*I
Return the Riemann zeta function evaluated at this complex number.
EXAMPLES:
sage: i = ComplexField(30).gen()
sage: z = 1 + i
sage: z.zeta()
0.58215806 - 0.92684856*I
sage: zeta(z)
0.58215806 - 0.92684856*I
EXAMPLES:
sage: from sage.rings.complex_number import RRtoCC
sage: f = RRtoCC(RealField(100), ComplexField(10))
sage: f(1/3)
0.33
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:
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
sage: sage.rings.complex_number.create_ComplexNumber(s_real=2,s_imag=1)
2.00000000000000 + 1.00000000000000*I
Returns True if x is a complex number. In particular, if x is of the ComplexNumber type.
EXAMPLES:
sage: from sage.rings.complex_number 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
Note that the global element I is of type SymbolicConstant. However, elements of the class ComplexField_class are of type ComplexNumber:
sage: c = 1 + 2*I
sage: is_ComplexNumber(c)
False
sage: d = CC(1 + 2*I)
sage: is_ComplexNumber(d)
True