Coverage for local/lib/python2.7/site-packages/sage/rings/complex

[9.999999999999998 + 2.0*I, 9.999999999999993 + 2.000000000000002*I, 9.999999999999996 + 1.9999999999999907*I, 9.999999999999993 + 2.0000000000000004*I, 9.999999999999998 + 1.9999999999999802*I]

sage: abs(sum(a.nth_root(111, all=True))) # rel tol 0.1

1.1057313523818259e-13

"""

if not self:

return [self] if all else self

arg = self.argument() / n

abs = self.abs().nth_root(n)

z = ComplexDoubleElement(abs * arg.cos(), abs*arg.sin())

if all:

zeta = self._parent.zeta(n)

return [z * zeta**k for k in range(n)]

else:

return z

def is_square(self):

r"""

This function always returns ``True`` as `\CC` is algebraically closed.

EXAMPLES::

sage: CDF(-1).is_square()

True

"""

return True

def is_integer(self):

"""

Returns True if this number is a integer

EXAMPLES::

sage: CDF(0.5).is_integer()

False

sage: CDF(I).is_integer()

False

sage: CDF(2).is_integer()

True

"""

return (self.real() in ZZ) and (self.imag()==0)

def is_positive_infinity(self):

r"""

Check if ``self`` is `+\infty`.

EXAMPLES::

sage: CDF(1, 2).is_positive_infinity()

False

sage: CDF(oo, 0).is_positive_infinity()

True

sage: CDF(0, oo).is_positive_infinity()

False

"""

return self.real().is_positive_infinity() and self.imag().is_zero()

def is_negative_infinity(self):

r"""

Check if ``self`` is `-\infty`.

EXAMPLES::

sage: CDF(1, 2).is_negative_infinity()

False

sage: CDF(-oo, 0).is_negative_infinity()

True

sage: CDF(0, -oo).is_negative_infinity()

False

"""

return self.real().is_negative_infinity() and self.imag().is_zero()

def is_infinity(self):

r"""

Check if ``self`` is `\infty`.

EXAMPLES::

sage: CDF(1, 2).is_infinity()

False

sage: CDF(0, oo).is_infinity()

True

"""

return self.real().is_infinity() or self.imag().is_infinity()

def is_NaN(self):

r"""

Check if ``self`` is not-a-number.

EXAMPLES::

sage: CDF(1, 2).is_NaN()

False

sage: CDF(NaN).is_NaN()

True

sage: (1/CDF(0, 0)).is_NaN()

True

"""

return self.real().is_NaN() or self.imag().is_NaN()

def _pow_(self, ComplexDoubleElement a):

"""

The function returns the complex number `z` raised to the

complex power `a`, `z^a`.

INPUT:

- ``a`` - a :class:`ComplexDoubleElement`

OUTPUT: :class:`ComplexDoubleElement`

EXAMPLES::

sage: a = CDF(1,1); b = CDF(2,3)

sage: a._pow_(b) # rel tol 5e-16

-0.163450932107355 + 0.09600498360894891*I

"""

return self._new_c(gsl_complex_pow(self._complex, a._complex))

def __pow__(z, a, dummy):

r"""

The function returns the complex number `z` raised to the

complex power `a`, `z^a`.

This is computed as `\exp(\log(z)*a)` using complex

logarithms and complex exponentials.

EXAMPLES::

sage: a = CDF(1,1); b = CDF(2,3)

sage: c = a^b; c # rel tol 5e-16, indirect doctest

-0.163450932107355 + 0.09600498360894891*I

sage: c^(1/b) # rel tol 2e-16

1.0 + 1.0*I

We compute the cube root of `-1` then cube it and observe a

rounding error::

sage: a = CDF(-1)^(1/3); a

0.5000000000000001 + 0.8660254037844386*I

sage: a^3 # rel tol 1e-4

-1.0 + 1.2246467991473532e-16*I

We raise to symbolic powers::

sage: x, n = var('x, n')

sage: CDF(1.2)^x

1.2^x

sage: CDF(1.2)^(x^n + n^x)

1.2^(n^x + x^n)

"""

try:

return z._pow_(a)

except AttributeError:

# z is not a complex number

return CDF(z)._pow_(a)

except TypeError:

# a is not a complex number

try:

return z._pow_(CDF(a))

except TypeError:

try:

return a.parent()(z)**a

except AttributeError:

raise TypeError

def exp(self):

r"""

This function returns the complex exponential of the complex number

`z`, `\exp(z)`.

EXAMPLES::

sage: CDF(1,1).exp() # abs tol 4e-16

1.4686939399158851 + 2.2873552871788423*I

We numerically verify a famous identity to the precision of a double::

sage: z = CDF(0, 2*pi); z

6.283185307179586*I

sage: exp(z) # rel tol 1e-4

1.0 - 2.4492935982947064e-16*I

"""

return self._new_c(gsl_complex_exp(self._complex))

def log(self, base=None):

r"""

This function returns the complex natural logarithm to the given

base of the complex number `z`, `\log(z)`. The

branch cut is the negative real axis.

INPUT:

- ``base`` - default: `e`, the base of the natural logarithm

EXAMPLES::

sage: CDF(1,1).log()

0.34657359027997264 + 0.7853981633974483*I

This is the only example different from the GSL::

sage: CDF(0,0).log()

-infinity

"""

if self == 0:

return RDF(0).log()

if base is None:

return self._new_c(gsl_complex_log(self._complex))

cdef ComplexDoubleElement z

try:

z = base

except TypeError:

z = CDF(base)

return self._new_c(gsl_complex_log_b(self._complex, z._complex))

def log10(self):

r"""

This function returns the complex base-10 logarithm of the complex

number `z`, `\log_{10}(z)`.

The branch cut is the negative real axis.

EXAMPLES::

sage: CDF(1,1).log10()

0.15051499783199057 + 0.3410940884604603*I

"""

if self == 0:

return RDF(0).log()

return self._new_c(gsl_complex_log10(self._complex))

def log_b(self, b):

r"""

This function returns the complex base-`b` logarithm of the

complex number `z`, `\log_b(z)`. This quantity is

computed as the ratio `\log(z)/\log(b)`.

The branch cut is the negative real axis.

EXAMPLES::

sage: CDF(1,1).log_b(10) # rel tol 1e-15

0.15051499783199057 + 0.3410940884604603*I

"""

cdef ComplexDoubleElement _b

if self == 0:

return RDF(0).log()

try:

_b = b

except TypeError:

_b = CDF(b)

return self._new_c(gsl_complex_log_b(self._complex, _b._complex))

#######################################################################

# Complex Trigonometric Functions

#######################################################################

def sin(self):

r"""

This function returns the complex sine of the complex number `z`:

.. MATH::

\sin(z) = \frac{e^{iz} - e^{-iz}}{2i}.

EXAMPLES::

sage: CDF(1,1).sin()

1.2984575814159773 + 0.6349639147847361*I

"""

return self._new_c(gsl_complex_sin(self._complex))

def cos(self):

r"""

This function returns the complex cosine of the complex number `z`:

.. MATH::

\cos(z) = \frac{e^{iz} + e^{-iz}}{2}

EXAMPLES::

sage: CDF(1,1).cos() # abs tol 1e-16

0.8337300251311491 - 0.9888977057628651*I

"""

return self._new_c(gsl_complex_cos(self._complex))

def tan(self):

r"""

This function returns the complex tangent of the complex number `z`:

.. MATH::

\tan(z) = \frac{\sin(z)}{\cos(z)}.

EXAMPLES::

sage: CDF(1,1).tan()

0.27175258531951174 + 1.0839233273386946*I

"""

return self._new_c(gsl_complex_tan(self._complex))

def sec(self):

r"""

This function returns the complex secant of the complex number `z`:

.. MATH::

{\rm sec}(z) = \frac{1}{\cos(z)}.

EXAMPLES::

sage: CDF(1,1).sec() # rel tol 1e-15

0.4983370305551868 + 0.591083841721045*I

"""

return self._new_c(gsl_complex_sec(self._complex))

def csc(self):

r"""

This function returns the complex cosecant of the complex number `z`:

.. MATH::

\csc(z) = \frac{1}{\sin(z)}.

EXAMPLES::

sage: CDF(1,1).csc() # rel tol 1e-15

0.6215180171704284 - 0.30393100162842646*I

"""

return self._new_c(gsl_complex_csc(self._complex))

def cot(self):

r"""

This function returns the complex cotangent of the complex number `z`:

.. MATH::

\cot(z) = \frac{1}{\tan(z)}.

EXAMPLES::

sage: CDF(1,1).cot() # rel tol 1e-15

0.21762156185440268 - 0.8680141428959249*I

"""

return self._new_c(gsl_complex_cot(self._complex))

#######################################################################

# Inverse Complex Trigonometric Functions

#######################################################################

def arcsin(self):

r"""

This function returns the complex arcsine of the complex number

`z`, `{\rm arcsin}(z)`. The branch cuts are on the

real axis, less than -1 and greater than 1.

EXAMPLES::

sage: CDF(1,1).arcsin()

0.6662394324925152 + 1.0612750619050357*I

"""

return self._new_c(gsl_complex_arcsin(self._complex))

def arccos(self):

r"""

This function returns the complex arccosine of the complex number

`z`, `{\rm arccos}(z)`. The branch cuts are on the

real axis, less than -1 and greater than 1.

EXAMPLES::

sage: CDF(1,1).arccos()

0.9045568943023814 - 1.0612750619050357*I

"""

return self._new_c(gsl_complex_arccos(self._complex))

def arctan(self):

r"""

This function returns the complex arctangent of the complex number

`z`, `{\rm arctan}(z)`. The branch cuts are on the

imaginary axis, below `-i` and above `i`.

EXAMPLES::

sage: CDF(1,1).arctan()

1.0172219678978514 + 0.4023594781085251*I

"""

return self._new_c(gsl_complex_arctan(self._complex))

def arccsc(self):

r"""

This function returns the complex arccosecant of the complex number

`z`, `{\rm arccsc}(z) = {\rm arcsin}(1/z)`.

EXAMPLES::

sage: CDF(1,1).arccsc() # rel tol 1e-15

0.45227844715119064 - 0.5306375309525178*I

"""

return self._new_c(gsl_complex_arccsc(self._complex))

def arccot(self):

r"""

This function returns the complex arccotangent of the complex

number `z`, `{\rm arccot}(z) = {\rm arctan}(1/z).`

EXAMPLES::

sage: CDF(1,1).arccot() # rel tol 1e-15

0.5535743588970452 - 0.4023594781085251*I

"""

return self._new_c(gsl_complex_arccot(self._complex))

def arcsec(self):

r"""

This function returns the complex arcsecant of the complex number

`z`, `{\rm arcsec}(z) = {\rm arccos}(1/z)`.

EXAMPLES::

sage: CDF(1,1).arcsec() # rel tol 1e-15

1.118517879643706 + 0.5306375309525178*I

"""

return self._new_c(gsl_complex_arcsec(self._complex))

#######################################################################

# Complex Hyperbolic Functions

#######################################################################

def sinh(self):

r"""

This function returns the complex hyperbolic sine of the complex

number `z`:

.. MATH::

\sinh(z) = \frac{e^z - e^{-z}}{2}.

EXAMPLES::

sage: CDF(1,1).sinh()

0.6349639147847361 + 1.2984575814159773*I

"""

return self._new_c(gsl_complex_sinh(self._complex))

def cosh(self):

r"""

This function returns the complex hyperbolic cosine of the complex

number `z`:

.. MATH::

\cosh(z) = \frac{e^z + e^{-z}}{2}.

EXAMPLES::

sage: CDF(1,1).cosh() # abs tol 1e-16

0.8337300251311491 + 0.9888977057628651*I

"""

return self._new_c(gsl_complex_cosh(self._complex))

def tanh(self):

r"""

This function returns the complex hyperbolic tangent of the complex

number `z`:

.. MATH::

\tanh(z) = \frac{\sinh(z)}{\cosh(z)}.

EXAMPLES::

sage: CDF(1,1).tanh()

1.0839233273386946 + 0.27175258531951174*I

"""

return self._new_c(gsl_complex_tanh(self._complex))

def sech(self):

r"""

This function returns the complex hyperbolic secant of the complex

number `z`:

.. MATH::

{\rm sech}(z) = \frac{1}{{\rm cosh}(z)}.

EXAMPLES::

sage: CDF(1,1).sech() # rel tol 1e-15

0.4983370305551868 - 0.591083841721045*I

"""

return self._new_c(gsl_complex_sech(self._complex))

def csch(self):

r"""

This function returns the complex hyperbolic cosecant of the

complex number `z`:

.. MATH::

{\rm csch}(z) = \frac{1}{{\rm sinh}(z)}.

EXAMPLES::

sage: CDF(1,1).csch() # rel tol 1e-15

0.30393100162842646 - 0.6215180171704284*I

"""

return self._new_c(gsl_complex_csch(self._complex))

def coth(self):

r"""

This function returns the complex hyperbolic cotangent of the

complex number `z`:

.. MATH::

\coth(z) = \frac{1}{\tanh(z)}.

EXAMPLES::

sage: CDF(1,1).coth() # rel tol 1e-15

0.8680141428959249 - 0.21762156185440268*I

"""

return self._new_c(gsl_complex_coth(self._complex))

#######################################################################

# Inverse Complex Hyperbolic Functions

#######################################################################

def arcsinh(self):

r"""

This function returns the complex hyperbolic arcsine of the complex

number `z`, `{\rm arcsinh}(z)`. The branch cuts are

on the imaginary axis, below `-i` and above `i`.

EXAMPLES::

sage: CDF(1,1).arcsinh()

1.0612750619050357 + 0.6662394324925152*I

"""

return self._new_c(gsl_complex_arcsinh(self._complex))

def arccosh(self):

r"""

This function returns the complex hyperbolic arccosine of the

complex number `z`, `{\rm arccosh}(z)`. The branch

cut is on the real axis, less than 1.

EXAMPLES::

sage: CDF(1,1).arccosh()

1.0612750619050357 + 0.9045568943023814*I

"""

return self._new_c(gsl_complex_arccosh(self._complex))

def arctanh(self):

r"""

This function returns the complex hyperbolic arctangent of the

complex number `z`, `{\rm arctanh} (z)`. The branch

cuts are on the real axis, less than -1 and greater than 1.

EXAMPLES::

sage: CDF(1,1).arctanh()

0.4023594781085251 + 1.0172219678978514*I

"""

return self._new_c(gsl_complex_arctanh(self._complex))

def arcsech(self):

r"""

This function returns the complex hyperbolic arcsecant of the

complex number `z`, `{\rm arcsech}(z) = {\rm arccosh}(1/z)`.

EXAMPLES::

sage: CDF(1,1).arcsech() # rel tol 1e-15

0.5306375309525176 - 1.118517879643706*I

"""

return self._new_c(gsl_complex_arcsech(self._complex))

def arccsch(self):

r"""

This function returns the complex hyperbolic arccosecant of the

complex number `z`, `{\rm arccsch}(z) = {\rm arcsin}(1/z)`.

EXAMPLES::

sage: CDF(1,1).arccsch() # rel tol 1e-15

0.5306375309525178 - 0.45227844715119064*I

"""

return self._new_c(gsl_complex_arccsch(self._complex))

def arccoth(self):

r"""

This function returns the complex hyperbolic arccotangent of the

complex number `z`, `{\rm arccoth}(z) = {\rm arctanh(1/z)}`.

EXAMPLES::

sage: CDF(1,1).arccoth() # rel tol 1e-15

0.4023594781085251 - 0.5535743588970452*I

"""

return self._new_c(gsl_complex_arccoth(self._complex))

#######################################################################

# Special Functions (from PARI)

#######################################################################

def eta(self, int omit_frac=0):

r"""

Return the value of the Dedekind `\eta` function on self.

INPUT:

- ``self`` - element of the upper half plane (if not,

raises a ValueError).

- ``omit_frac`` - (bool, default: ``False``), if ``True``,

omit the `e^{\pi i z / 12}` factor.

OUTPUT: a complex double number

ALGORITHM: Uses the PARI C library.

The `\eta` function is

.. MATH::

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

EXAMPLES:

We compute a few values of :meth:`eta()`::

sage: CDF(0,1).eta()

0.7682254223260566

sage: CDF(1,1).eta()

0.7420487758365647 + 0.1988313702299107*I

sage: CDF(25,1).eta()

0.7420487758365647 + 0.1988313702299107*I

:meth:`eta()` works even if the inputs are large::

sage: CDF(0, 10^15).eta()

0.0

sage: CDF(10^15, 0.1).eta() # abs tol 1e-10

-0.115342592727 - 0.19977923088*I

We compute a few values of :meth:`eta()`, but with the fractional power

of `e` omitted::

sage: CDF(0,1).eta(True)

0.9981290699259585

We compute :meth:`eta()` to low precision directly from the

definition::

sage: z = CDF(1,1); z.eta()

0.7420487758365647 + 0.1988313702299107*I

sage: i = CDF(0,1); pi = CDF(pi)

sage: exp(pi * i * z / 12) * prod([1-exp(2*pi*i*n*z) for n in range(1,10)])

0.7420487758365647 + 0.19883137022991068*I

The optional argument allows us to omit the fractional part::

sage: z.eta(omit_frac=True)

0.9981290699259585

sage: pi = CDF(pi)

sage: prod([1-exp(2*pi*i*n*z) for n in range(1,10)]) # abs tol 1e-12

0.998129069926 + 4.59084695545e-19*I

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

sage: z = CDF(1)

sage: z.eta()

Traceback (most recent call last):

...

ValueError: value must be in the upper half plane

You can also use functional notation::

sage: z = CDF(1,1)

sage: eta(z)

0.7420487758365647 + 0.1988313702299107*I

"""

cdef GEN a, b, c, y, t

if self._complex.dat[1] <= 0:

raise ValueError("value must be in the upper half plane")

if self._complex.dat[1] > 100000 and not omit_frac:

# To the precision of doubles for such large imaginary

# part, the answer is automatically 0. If we don't do

# this, PARI can easily underflow.

return ComplexDoubleElement(0,0)

cdef int flag = 0 if omit_frac else 1

return pari_to_cdf(self.__pari__().eta(flag))

def agm(self, right, algorithm="optimal"):

r"""

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 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{ab})`

where the sign is chosen so that `|a_1-b_1| \leq |a_1+b_1|`, or

equivalently `\Re(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{ab})`

where the sign is chosen so that `\Re(b_1/a_1) \geq 0` (the

so-called principal branch of the square root).

EXAMPLES::

sage: i = CDF(I)

sage: (1+i).agm(2-i) # rel tol 1e-15

1.6278054848727064 + 0.1368275483973686*I

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

parameter::

sage: a = CDF(-0.95,-0.65)

sage: b = CDF(0.683,0.747)

sage: a.agm(b, algorithm='optimal')

-0.3715916523517613 + 0.31989466020683*I

sage: a.agm(b, algorithm='principal') # rel tol 1e-15

0.33817546298618006 - 0.013532696956540503*I

sage: a.agm(b, algorithm='pari')

-0.37159165235176134 + 0.31989466020683005*I

Some degenerate cases::

sage: CDF(0).agm(a)

0.0

sage: a.agm(0)

0.0

sage: a.agm(-a)

0.0

"""

cdef double complex a, b, a1, b1, r

cdef double d, e, eps = 2.0**-51

if algorithm == "pari":

return pari_to_cdf(self.__pari__().agm(right))

if not isinstance(right, ComplexDoubleElement):

right = CDF(right)

a = extract_double_complex(self)

b = extract_double_complex(<ComplexDoubleElement>right)

if a == 0 or b == 0 or a == -b:

return ComplexDoubleElement(0, 0)

if algorithm=="optimal":

while True:

a1 = (a+b)/2

b1 = csqrt(a*b)

r = b1/a1

d = cabs(r-1)

e = cabs(r+1)

if e < d:

b1=-b1

d = e

if d < eps: return ComplexDoubleElement_from_doubles(a1.real, a1.imag)

a, b = a1, b1

elif algorithm=="principal":

while True:

a1 = (a+b)/2

b1 = csqrt(a*b)

if cabs((b1/a1)-1) < eps: return ComplexDoubleElement_from_doubles(a1.real, a1.imag)

a, b = a1, b1

else:

raise ValueError("agm algorithm must be one of 'pari', 'optimal', 'principal'")

def dilog(self):

r"""

Returns the principal branch of the dilogarithm of `x`, i.e., analytic

continuation of the power series

.. MATH::

\log_2(x) = \sum_{n \ge 1} x^n / n^2.

EXAMPLES::

sage: CDF(1,2).dilog()

-0.059474798673809476 + 2.0726479717747566*I

sage: CDF(10000000,10000000).dilog()

-134.411774490731 + 38.79396299904504*I

"""

return pari_to_cdf(self.__pari__().dilog())

def gamma(self):

r"""

Return the gamma function `\Gamma(z)` evaluated at ``self``, the

complex number `z`.

EXAMPLES::

sage: CDF(5,0).gamma()

24.0

sage: CDF(1,1).gamma()

0.49801566811835607 - 0.15494982830181067*I

sage: CDF(0).gamma()

Infinity

sage: CDF(-1,0).gamma()

Infinity

"""

if self._complex.dat[1] == 0:

if self._complex.dat[0] == 0:

from .infinity import unsigned_infinity

return unsigned_infinity

try:

from sage.rings.all import Integer, CC

if Integer(self._complex.dat[0]) < 0:

return CC(self).gamma()

except TypeError:

pass

return pari_to_cdf(self.__pari__().gamma())

def gamma_inc(self, t):

r"""

Return the incomplete gamma function evaluated at this complex number.

EXAMPLES::

sage: CDF(1,1).gamma_inc(CDF(2,3))

0.0020969148636468277 - 0.059981913655449706*I

sage: CDF(1,1).gamma_inc(5)

-0.001378130936215849 + 0.006519820023119819*I

sage: CDF(2,0).gamma_inc(CDF(1,1))

0.7070920963459381 - 0.4203536409598115*I

"""

return pari_to_cdf(self.__pari__().incgam(t))

def zeta(self):

"""

Return the Riemann zeta function evaluated at this complex number.

EXAMPLES::

sage: z = CDF(1, 1)

sage: z.zeta()

0.5821580597520036 - 0.9268485643308071*I

sage: zeta(z)

0.5821580597520036 - 0.9268485643308071*I

sage: zeta(CDF(1))

Infinity

"""

if self._complex.dat[0] == 1 and self._complex.dat[1] == 0:

from .infinity import unsigned_infinity

return unsigned_infinity

return pari_to_cdf(self.__pari__().zeta())

def algdep(self, long n):

"""

Returns a polynomial of degree at most `n` which is

approximately satisfied by this complex number. Note that the

returned polynomial need not be irreducible, and indeed usually

won't be if `z` is a good approximation to an algebraic

number of degree less than `n`.

ALGORITHM: Uses the PARI C-library algdep command.

EXAMPLES::

sage: z = (1/2)*(1 + RDF(sqrt(3)) *CDF.0); z # abs tol 1e-16

0.5 + 0.8660254037844387*I

sage: p = z.algdep(5); p

x^2 - x + 1

sage: abs(z^2 - z + 1) < 1e-14

True

sage: CDF(0,2).algdep(10)

x^2 + 4

sage: CDF(1,5).algdep(2)

x^2 - 2*x + 26

"""

from sage.arith.all import algdep

return algdep(self, n)

cdef class FloatToCDF(Morphism):

"""

Fast morphism from anything with a ``__float__`` method to a CDF element.

EXAMPLES::

sage: f = CDF.coerce_map_from(ZZ); f

Native morphism:

From: Integer Ring

To: Complex Double Field

sage: f(4)

4.0

sage: f = CDF.coerce_map_from(QQ); f

Native morphism:

From: Rational Field

To: Complex Double Field

sage: f(1/2)

0.5

sage: f = CDF.coerce_map_from(int); f

Native morphism:

From: Set of Python objects of class 'int'

To: Complex Double Field

sage: f(3r)

3.0

sage: f = CDF.coerce_map_from(float); f

Native morphism:

From: Set of Python objects of class 'float'

To: Complex Double Field

sage: f(3.5)

3.5

"""

def __init__(self, R):

"""

Initialize ``self``.

EXAMPLES::

sage: f = CDF.coerce_map_from(ZZ); f

Native morphism:

From: Integer Ring

To: Complex Double Field

"""

from sage.categories.homset import Hom

if isinstance(R, type):

from sage.structure.parent import Set_PythonType

R = Set_PythonType(R)

Morphism.__init__(self, Hom(R, CDF))

cpdef Element _call_(self, x):

"""

Create an :class:`ComplexDoubleElement`.

EXAMPLES::

sage: CDF((1,2)) # indirect doctest

1.0 + 2.0*I

sage: CDF('i') # indirect doctest

1.0*I

sage: CDF(2+i) # indirect doctest

2.0 + 1.0*I

"""

cdef ComplexDoubleElement z = <ComplexDoubleElement>ComplexDoubleElement.__new__(ComplexDoubleElement)

z._complex = gsl_complex_rect(x, 0)

return z

def _repr_type(self):

"""

Return string that describes the type of morphism.

EXAMPLES::

sage: sage.rings.complex_double.FloatToCDF(QQ)._repr_type()

'Native'

"""

return "Native"

cdef class ComplexToCDF(Morphism):

r"""

Fast morphism for anything such that the elements have attributes ``.real``

and ``.imag`` (e.g. numpy complex types).

EXAMPLES::

sage: import numpy

sage: f = CDF.coerce_map_from(numpy.complex_)

sage: f(numpy.complex_(I))

1.0*I

sage: f(numpy.complex_(I)).parent()

Complex Double Field

"""

def __init__(self, R):

from sage.categories.homset import Hom

if isinstance(R, type):

from sage.structure.parent import Set_PythonType

R = Set_PythonType(R)

Morphism.__init__(self, Hom(R, CDF))

cpdef Element _call_(self, x):

"""

Create an :class:`ComplexDoubleElement`.

EXAMPLES::

sage: import numpy

sage: CDF(numpy.complex_(I)) # indirect doctest

1.0*I

"""

cdef ComplexDoubleElement z = <ComplexDoubleElement>ComplexDoubleElement.__new__(ComplexDoubleElement)

z._complex = gsl_complex_rect(x.real, x.imag)

return z

def _repr_type(self):

"""

Return string that describes the type of morphism.

EXAMPLES::

sage: import numpy

sage: f = sage.rings.complex_double.ComplexToCDF(numpy.complex_)

sage: f._repr_type()

'Native'

"""

return "Native"

#####################################################

# unique objects

#####################################################

cdef ComplexDoubleField_class _CDF

_CDF = ComplexDoubleField_class()

CDF = _CDF # external interface

cdef ComplexDoubleElement I = ComplexDoubleElement(0,1)

def ComplexDoubleField():

"""

Returns the field of double precision complex numbers.

EXAMPLES::

sage: ComplexDoubleField()

Complex Double Field

sage: ComplexDoubleField() is CDF

True

"""

return _CDF

from sage.misc.parser import Parser

cdef cdf_parser = Parser(float, float, {"I" : _CDF.gen(), "i" : _CDF.gen()})

cdef inline double complex extract_double_complex(ComplexDoubleElement x):

"""

Return the value of ``x`` as a c99 complex double.

"""

cdef double complex z

z.real = x._complex.dat[0]

z.imag = x._complex.dat[1]

return z

cdef ComplexDoubleElement ComplexDoubleElement_from_doubles(double re, double im):

"""

Create a new :class:`ComplexDoubleElement` with the specified real and

imaginary parts.

"""

cdef ComplexDoubleElement z = <ComplexDoubleElement>ComplexDoubleElement.__new__(ComplexDoubleElement)

z._complex.dat[0] = re

z._complex.dat[1] = im

return z

#####

Coverage for local/lib/python2.7/site-packages/sage/rings/complex_double.pyx : 69%

495 statements 340 run 155 missing 0 excluded