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

ComplexIntervalField(64)(RIF64(RR64('0.769238901363972126565'), RR64('0.769238901363972126619')), RIF64(RR64('0.638961276313634801076'), RR64('0.638961276313634801184')))

sage: from sage.misc.sage_input import SageInputBuilder

sage: sib = SageInputBuilder()

sage: ComplexIntervalField(15)(3+I).log()._sage_input_(sib, False)

{call: {call: {atomic:ComplexIntervalField}({atomic:15})}({call: {call: {atomic:RealIntervalField}({atomic:15})}({call: {call: {atomic:RealField}({atomic:15})}({atomic:1.15125})}, {call: {call: {atomic:RealField}({atomic:15})}({atomic:1.15137})})}, {call: {call: {atomic:RealIntervalField}({atomic:15})}({call: {call: {atomic:RealField}({atomic:15})}({atomic:0.321655})}, {call: {call: {atomic:RealField}({atomic:15})}({atomic:0.321777})})})}

"""

# Interval printing could often be much prettier,

# but I'm feeling lazy :)

return sib(self.parent())(sib(self.real()), sib(self.imag()))

def prec(self):

"""

Return precision of this complex number.

EXAMPLES::

sage: i = ComplexIntervalField(2000).0

sage: i.prec()

2000

"""

return self._parent.prec()

def real(self):

"""

Return real part of ``self``.

EXAMPLES::

sage: i = ComplexIntervalField(100).0

sage: z = 2 + 3*i

sage: x = z.real(); x

sage: x.parent()

Real Interval Field with 100 bits of precision

"""

x = self._new_real()

mpfi_set(x.value, self.__re)

return x

def imag(self):

"""

Return imaginary part of ``self``.

EXAMPLES::

sage: i = ComplexIntervalField(100).0

sage: z = 2 + 3*i

sage: x = z.imag(); x

sage: x.parent()

Real Interval Field with 100 bits of precision

"""

x = self._new_real()

mpfi_set(x.value, self.__im)

return x

def __neg__(self):

"""

Return the negation of ``self``.

EXAMPLES::

sage: CIF(1.5, 2.5).__neg__()

-1.5000000000000000? - 2.5000000000000000?*I

"""

x = self._new()

mpfi_neg(x.__re, self.__re)

mpfi_neg(x.__im, self.__im)

return x

def __pos__(self):

"""

Return the "positive" of ``self``, which is just ``self``.

EXAMPLES::

sage: CIF(1.5, 2.5).__pos__()

1.5000000000000000? + 2.5000000000000000?*I

"""

return self

def __abs__(self):

"""

Return the absolute value of ``self``.

EXAMPLES::

sage: abs(CIF(1.5, 2.5))

2.915475947422650?

sage: CIF(1.5, 2.5).__abs__()

2.915475947422650?

"""

x = self._new_real()

cdef mpfi_t t

mpfi_init2(t, self._prec)

mpfi_sqr(x.value, self.__re)

mpfi_sqr(t, self.__im)

mpfi_add(x.value, x.value, t)

mpfi_sqrt(x.value, x.value)

mpfi_clear(t)

return x

def __invert__(self):

"""

Return the multiplicative inverse of ``self``.

EXAMPLES::

sage: I = CIF.0

sage: a = ~(5+I) # indirect doctest

sage: a * (5+I)

1.000000000000000? + -1.?e-16*I

sage: a = CIF((1, 2), (3, 4))

sage: c = a.__invert__()

sage: c.endpoints()

(0.0588235294117647 - 0.300000000000000*I,

0.153846153846154 - 0.200000000000000*I,

0.0588235294117647 - 0.200000000000000*I,

0.153846153846154 - 0.300000000000000*I)

TESTS:

Check that the code is valid in all kind of complex intervals::

sage: rpts = [0, -194323/42, -110/439423, -411923/122212, \

....: 15423/906, 337/59976, 145151/145112]

sage: rpts = [RIF(a, b) if a <= b else RIF(b,a) \

....: for a in rpts for b in rpts]

sage: cpts = [CIF(a, b) for a in rpts for b in rpts if not CIF(a, b).contains_zero()]

sage: for x in cpts:

....: assert (x * (~x) - 1).contains_zero()

REFERENCES:

.. [RL] \J. Rokne, P. Lancaster. Complex interval arithmetic.

Communications of the ACM 14. 1971.

"""

x = self._new()

cdef mpfr_t a, b, c, d

mpfr_init2(a, self._prec)

mpfr_init2(b, self._prec)

mpfr_init2(c, self._prec)

mpfr_init2(d, self._prec)

cdef mpfr_t rmin, rmax, imin, imax

mpfr_init2(rmin, self._prec)

mpfr_init2(rmax, self._prec)

mpfr_init2(imin, self._prec)

mpfr_init2(imax, self._prec)

cdef mpfr_t r

mpfr_init2(r, self._prec)

mpfi_get_left(a, self.__re)

mpfi_get_right(b, self.__re)

mpfi_get_left(c, self.__im)

mpfi_get_right(d, self.__im)

cdef mpfr_t a2, b2, d2, c2

mpfr_init2(a2, self._prec)

mpfr_init2(b2, self._prec)

mpfr_init2(c2, self._prec)

mpfr_init2(d2, self._prec)

cdef mpfr_t div1, div2, aux, aux2

mpfr_init2(div1, self._prec)

mpfr_init2(div2, self._prec)

mpfr_init2(aux, self._prec)

mpfr_init2(aux2, self._prec)

if mpfr_sgn(a) >= 0 and mpfr_sgn(c)>=0: #input interval lies in first quadrant

# left endpoint

mpfr_mul(a2, a, a, MPFR_RNDU)

mpfr_mul(b2, b, b, MPFR_RNDU)

mpfr_mul(d2, d, d, MPFR_RNDU)

mpfr_add(div1, a2, d2, MPFR_RNDU)

mpfr_add(div2, b2, d2, MPFR_RNDU)

mpfr_div(rmin, a, div1, MPFR_RNDD)

mpfr_div(aux, b, div2, MPFR_RNDD)

mpfr_min(rmin, rmin, aux, MPFR_RNDD)

#higher endpoint

mpfr_mul(c2, c, c, MPFR_RNDU)

mpfr_add(div1, b2, c2, MPFR_RNDU)

mpfr_div(imax, c, div1, MPFR_RNDU)

mpfr_set_si(aux, 0, MPFR_RNDD)

mpfr_sub(imax, aux, imax, MPFR_RNDU)

mpfr_div(aux2, d, div2, MPFR_RNDU)

mpfr_sub(aux2, aux, aux2, MPFR_RNDU)

mpfr_max(imax, aux2, imax, MPFR_RNDU)

# lower endpoint, it is the lowest point of the circle or one of

if mpfr_cmp(d, a) >=0 and mpfr_cmp(c, a) <= 0:

mpfr_add(imin, a, a, MPFR_RNDD)

mpfr_set_si(aux, -1, MPFR_RNDD)

mpfr_div(imin, aux, imin, MPFR_RNDD)

elif mpfr_cmp(c, a) > 0:

mpfr_mul(c2, c, c, MPFR_RNDD)

mpfr_mul(a2, a, a, MPFR_RNDD)

mpfr_add(div1, a2, c2, MPFR_RNDD)

mpfr_div(imin, c, div1, MPFR_RNDU)

mpfr_set_si(aux, 0, MPFR_RNDD)

mpfr_sub(imin, aux, imin, MPFR_RNDD)

else:

mpfr_mul(d2, d, d, MPFR_RNDD)

mpfr_mul(a2, a, a, MPFR_RNDD)

mpfr_add(div1, a2, d2, MPFR_RNDD)

mpfr_div(imin, d, div1, MPFR_RNDU)

mpfr_set_si(aux, 0, MPFR_RNDD)

mpfr_sub(imin, aux, imin, MPFR_RNDD)

#right endpoint

if mpfr_cmp(c, a) >=0 and mpfr_cmp(b, c) >= 0:

mpfr_add(rmax, c, c, MPFR_RNDD)

mpfr_set_si(aux, 1, MPFR_RNDU)

mpfr_div(rmax, aux, rmax, MPFR_RNDU)

elif mpfr_cmp(a,c) > 0:

mpfr_mul(a2, a, a, MPFR_RNDD)

mpfr_mul(c2, c, c, MPFR_RNDD)

mpfr_add(div1, a2, c2, MPFR_RNDD)

mpfr_div(rmax, a, div1, MPFR_RNDU)

else:

mpfr_mul(b2, b, b, MPFR_RNDD)

mpfr_mul(c2, c, c, MPFR_RNDD)

mpfr_add(div1, b2, c2, MPFR_RNDD)

mpfr_div(rmax, b, div1, MPFR_RNDU)

elif mpfr_sgn(c) > 0 and mpfr_sgn(b) > 0: #between first and second quadrant

# left endpoint

mpfr_abs(aux, a, MPFR_RNDU)

if mpfr_cmp(aux, c) >= 0:

mpfr_set_str(aux, '-0.5', 10, MPFR_RNDD)

mpfr_div(rmin, aux, c, MPFR_RNDD)

else:

mpfr_mul(a2, a, a, MPFR_RNDD)

mpfr_mul(c2, c, c, MPFR_RNDD)

mpfr_add(div1, a2, c2, MPFR_RNDD)

mpfr_div(rmin, a, div1, MPFR_RNDU)

# lower endpoint

mpfr_set_si(aux2, -1, MPFR_RNDD)

mpfr_div(imin, aux2, c, MPFR_RNDD)

#right endpoint

if mpfr_cmp(b, c) >=0:

mpfr_set_str(aux2, '0.5', 10, MPFR_RNDU)

mpfr_div(rmax, aux2, c, MPFR_RNDU)

else:

mpfr_mul(b2, b, b, MPFR_RNDD)

mpfr_mul(c2, c, c, MPFR_RNDD)

mpfr_add(div1, b2, c2, MPFR_RNDD)

mpfr_div(rmax, b, div1, MPFR_RNDU)

# upper endpoint

mpfr_mul(a2, a, a, MPFR_RNDU)

mpfr_mul(b2, b, b, MPFR_RNDU)

mpfr_mul(c2, c, c, MPFR_RNDU)

mpfr_mul(d2, d, d, MPFR_RNDU)

mpfr_add(div1, a2, c2, MPFR_RNDU)

mpfr_div(imax, c, div1, MPFR_RNDD)

mpfr_add(div1, b2, c2, MPFR_RNDU)

mpfr_div(aux, c, div1, MPFR_RNDD)

if mpfr_cmp(imax, aux) > 0:

mpfr_set(imax, aux, MPFR_RNDD)

mpfr_add(div1, a2, d2, MPFR_RNDU)

mpfr_div(aux, d, div1, MPFR_RNDD)

if mpfr_cmp(imax, aux) > 0:

mpfr_set(imax, aux, MPFR_RNDD)

mpfr_add(div1, b2, d2, MPFR_RNDU)

mpfr_div(aux, d, div1, MPFR_RNDD)

if mpfr_cmp(imax, aux) > 0:

mpfr_set(imax, aux, MPFR_RNDD)

mpfr_set_zero(aux, -1)

mpfr_sub(imax, aux, imax, MPFR_RNDU)

elif mpfr_sgn(b) <= 0 and mpfr_sgn(d) >=0: #second quadrant or between second and thirthd

I = self.parent().gen(0)

return -I*(-I*self).__invert__()

elif mpfr_sgn(a) <= 0 and mpfr_sgn(d) <= 0: # thirthd quadrant or between thirthd and fourth

return -(-self).__invert__()

elif mpfr_sgn(a) >=0: #fourth or between fourth and first

I = self.parent().gen(0)

return I*(I*self).__invert__()

mpfi_set_fr(x.__re, rmin)

mpfi_put_fr(x.__re, rmax)

mpfi_set_fr(x.__im, imin)

mpfi_put_fr(x.__im, imax)

mpfr_clear(a)

mpfr_clear(b)

mpfr_clear(c)

mpfr_clear(d)

mpfr_clear(imin)

mpfr_clear(imax)

mpfr_clear(rmin)

mpfr_clear(rmax)

mpfr_clear(r)

mpfr_clear(a2)

mpfr_clear(b2)

mpfr_clear(c2)

mpfr_clear(d2)

mpfr_clear(div1)

mpfr_clear(div2)

mpfr_clear(aux)

mpfr_clear(aux2)

return x

def _complex_mpfr_field_(self, field):

"""

Convert to a complex field.

EXAMPLES::

sage: re = RIF("1.2")

sage: im = RIF(2, 3)

sage: a = ComplexIntervalField(30)(re, im)

sage: CC(a)

1.20000000018626 + 2.50000000000000*I

"""

cdef ComplexNumber x = field(0)

mpfi_mid(x.__re, self.__re)

mpfi_mid(x.__im, self.__im)

return x

def __int__(self):

"""

Convert ``self`` to an ``int``.

EXAMPLES::

sage: int(CIF(1,1))

Traceback (most recent call last):

...

TypeError: can't convert complex interval to int

"""

raise TypeError("can't convert complex interval to int")

def __long__(self):

"""

Convert ``self`` to a ``lon``.

EXAMPLES::

sage: long(CIF(1,1))

Traceback (most recent call last):

...

TypeError: can't convert complex interval to long

"""

raise TypeError("can't convert complex interval to long")

def __float__(self):

"""

Convert ``self`` to a ``float``.

EXAMPLES::

sage: float(CIF(1))

1.0

sage: float(CIF(1,1))

Traceback (most recent call last):

...

TypeError: can't convert complex interval to float

"""

if self.imag() == 0:

return float(self.real().n(self._prec))

else:

raise TypeError("can't convert complex interval to float")

def __complex__(self):

"""

Convert ``self`` to a ``complex``.

EXAMPLES::

sage: complex(CIF(1,1))

(1+1j)

"""

return complex(self.real().n(self._prec),

self.imag().n(self._prec))

def __nonzero__(self):

"""

Return ``True`` if ``self`` is not known to be exactly zero.

EXAMPLES::

sage: bool(CIF(RIF(0, 0), RIF(0, 0)))

False

sage: bool(CIF(RIF(1), RIF(0)))

True

sage: bool(CIF(RIF(0), RIF(1)))

True

sage: bool(CIF(RIF(1, 2), RIF(0)))

True

sage: bool(CIF(RIF(-1, 1), RIF(-1, 1)))

True

"""

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

cpdef _richcmp_(left, right, int op):

r"""

As with the real interval fields this never returns false positives.

Thus, `a == b` is ``True`` iff both `a` and `b` represent the same

one-point interval. Likewise `a != b` is ``True`` iff `x != y` for all

`x \in a, y \in b`.

EXAMPLES::

sage: CIF(0) == CIF(0)

True

sage: CIF(0) == CIF(1)

False

sage: CIF.gen() == CIF.gen()

True

sage: CIF(0) == CIF.gen()

False

sage: CIF(0) != CIF(1)

True

sage: -CIF(-3).sqrt() != CIF(-3).sqrt()

True

These intervals overlap, but contain unequal points::

sage: CIF(3).sqrt() == CIF(3).sqrt()

False

sage: CIF(3).sqrt() != CIF(3).sqrt()

False

In the future, complex interval elements may be unordered,

but or backwards compatibility we order them lexicographically::

sage: CDF(-1) < -CDF.gen() < CDF.gen() < CDF(1)

True

sage: CDF(1) >= CDF(1) >= CDF.gen() >= CDF.gen() >= 0 >= -CDF.gen() >= CDF(-1)

True

"""

cdef ComplexIntervalFieldElement lt, rt

lt = left

rt = right

if op == Py_EQ:

# intervals a == b iff a<=b and b <= a

# (this gives a result with two comparisons, where the

# obvious approach would use three)

return mpfr_lessequal_p(&lt.__re.right, &rt.__re.left) \

and mpfr_lessequal_p(&rt.__re.right, &lt.__re.left) \

and mpfr_lessequal_p(&lt.__im.right, &rt.__im.left) \

and mpfr_lessequal_p(&rt.__im.right, &lt.__im.left)

elif op == Py_NE:

return mpfr_less_p(&lt.__re.right, &rt.__re.left) \

or mpfr_less_p(&rt.__re.right, &lt.__re.left) \

or mpfr_less_p(&lt.__im.right, &rt.__im.left) \

or mpfr_less_p(&rt.__im.right, &lt.__im.left)

else:

# Eventually we probably want to disable comparison of complex

# intervals, just like python complexes will be unordered.

## raise TypeError("no ordering relation is defined for complex numbers")

diff = left - right

real_diff = diff.real()

imag_diff = diff.imag()

if op == Py_LT:

return real_diff < 0 or (real_diff == 0 and imag_diff < 0)

elif op == Py_LE:

return real_diff < 0 or (real_diff == 0 and imag_diff <= 0)

elif op == Py_GT:

return real_diff > 0 or (real_diff == 0 and imag_diff > 0)

elif op == Py_GE:

return real_diff > 0 or (real_diff == 0 and imag_diff >= 0)

def lexico_cmp(left, right):

"""

Intervals are compared lexicographically on the 4-tuple:

``(x.real().lower(), x.real().upper(),

x.imag().lower(), x.imag().upper())``

EXAMPLES::

sage: a = CIF(RIF(0,1), RIF(0,1))

sage: b = CIF(RIF(0,1), RIF(0,2))

sage: c = CIF(RIF(0,2), RIF(0,2))

sage: a.lexico_cmp(b)

-1

sage: b.lexico_cmp(c)

-1

sage: a.lexico_cmp(c)

-1

sage: a.lexico_cmp(a)

sage: b.lexico_cmp(a)

TESTS::

sage: tests = []

sage: for rl in (0, 1):

....: for ru in (rl, rl + 1):

....: for il in (0, 1):

....: for iu in (il, il + 1):

....: tests.append((CIF(RIF(rl, ru), RIF(il, iu)), (rl, ru, il, iu)))

sage: for (i1, t1) in tests:

....: for (i2, t2) in tests:

....: if t1 == t2:

....: assert(i1.lexico_cmp(i2) == 0)

....: elif t1 < t2:

....: assert(i1.lexico_cmp(i2) == -1)

....: elif t1 > t2:

....: assert(i1.lexico_cmp(i2) == 1)

"""

cdef int a, b

a = mpfi_nan_p(left.__re)

b = mpfi_nan_p((<ComplexIntervalFieldElement>right).__re)

if a != b:

return -1

cdef int i

i = mpfr_cmp(&left.__re.left, &(<ComplexIntervalFieldElement>right).__re.left)

if i < 0:

return -1

elif i > 0:

return 1

i = mpfr_cmp(&left.__re.right, &(<ComplexIntervalFieldElement>right).__re.right)

if i < 0:

return -1

elif i > 0:

return 1

i = mpfr_cmp(&left.__im.left, &(<ComplexIntervalFieldElement>right).__im.left)

if i < 0:

return -1

elif i > 0:

return 1

i = mpfr_cmp(&left.__im.right, &(<ComplexIntervalFieldElement>right).__im.right)

if i < 0:

return -1

elif i > 0:

return 1

return 0

cpdef int _cmp_(self, other) except -2:

"""

Deprecated method (:trac:`23133`)

EXAMPLES::

sage: a = CIF(RIF(0,1), RIF(0,1))

sage: a._cmp_(a)

doctest:...: DeprecationWarning: for CIF elements, do not use cmp

See http://trac.sagemath.org/23133 for details.

"""

from sage.misc.superseded import deprecation

deprecation(23133, 'for CIF elements, do not use cmp')

return self.lexico_cmp(other)

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

# Transcendental (and other) functions

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

def argument(self):

r"""

The argument (angle) of the complex number, normalized

so that `-\pi < \theta.lower() \leq \pi`.

We raise a ``ValueError`` if the interval strictly contains 0,

or if the interval contains only 0.

.. WARNING::

We do not always use the standard branch cut for

argument! If the interval crosses the negative real axis,

then the argument will be an interval whose lower bound is

less than `\pi` and whose upper bound is more than `\pi`; in

effect, we move the branch cut away from the interval.

EXAMPLES::

sage: i = CIF.0

sage: (i^2).argument()

3.141592653589794?

sage: (1+i).argument()

0.785398163397449?

sage: i.argument()

1.570796326794897?

sage: (-i).argument()

-1.570796326794897?

sage: (RR('-0.001') - i).argument()

-1.571796326461564?

sage: CIF(2).argument()

sage: CIF(-2).argument()

3.141592653589794?

Here we see that if the interval crosses the negative real

axis, then the argument can exceed `\pi`, and we

we violate the standard interval guarantees in the process::

sage: CIF(-2, RIF(-0.1, 0.1)).argument().str(style='brackets')

'[3.0916342578678501 .. 3.1915510493117365]'

sage: CIF(-2, -0.1).argument()

-3.091634257867851?

"""

if mpfi_has_zero(self.__re) and mpfi_has_zero(self.__im):

if mpfi_is_zero(self.__re) and mpfi_is_zero(self.__im):

raise ValueError("Can't take the argument of complex zero")

if not mpfi_is_nonpos(self.__re) and not mpfi_is_nonneg(self.__re) \

and not mpfi_is_nonpos(self.__im) and not mpfi_is_nonneg(self.__im):

raise ValueError("Can't take the argument of interval strictly containing zero")

# Now if we exclude zero from the interval, we know that the

# argument of the remaining points is bounded. Check which

# axes the interval extends along (we can deduce information

# about the quadrants from information about the axes).

which_axes = [False, False, False, False]

if not mpfi_is_nonpos(self.__re):

which_axes[0] = True

if not mpfi_is_nonpos(self.__im):

which_axes[1] = True

if not mpfi_is_nonneg(self.__re):

which_axes[2] = True

if not mpfi_is_nonneg(self.__im):

which_axes[3] = True

lower = None

for i in range(-1, 3):

if which_axes[i % 4] and not which_axes[(i - 1) % 4]:

if lower is not None:

raise ValueError("Can't take the argument of line-segment interval strictly containing zero")

lower = i

for i in range(lower, lower+4):

if which_axes[i % 4] and not which_axes[(i + 1) % 4]:

upper = i

break

fld = self._parent.real_field()

return fld.pi() * fld(lower, upper) * fld(0.5)

else:

# OK, we know that the interval is bounded away from zero

# in either the real or the imaginary direction (or both).

# We'll handle the "bounded away in the imaginary direction"

# case first.

fld = self._parent.real_field()

if mpfi_is_strictly_pos(self.__im):

return (-self.real() / self.imag()).arctan() + fld.pi()/2

if mpfi_is_strictly_neg(self.__im):

return (-self.real() / self.imag()).arctan() - fld.pi()/2

if mpfi_is_strictly_pos(self.__re):

return (self.imag() / self.real()).arctan()

# The only remaining case is that self.__re is strictly

# negative and self.__im contains 0. In that case, we

# return an interval containing pi.

return (self.imag() / self.real()).arctan() + fld.pi()

def arg(self):

"""

Same as :meth:`argument()`.

EXAMPLES::

sage: i = CIF.0

sage: (i^2).arg()

3.141592653589794?

"""

return self.argument()

def crosses_log_branch_cut(self):

"""

Returns ``True`` if this interval crosses the standard branch cut

for :meth:`log()` (and hence for exponentiation) and for argument.

(Recall that this branch cut is infinitesimally below the

negative portion of the real axis.)

EXAMPLES::

sage: z = CIF(1.5, 2.5) - CIF(0, 2.50000000000000001); z

1.5000000000000000? + -1.?e-15*I

sage: z.crosses_log_branch_cut()

False

sage: CIF(-2, RIF(-0.1, 0.1)).crosses_log_branch_cut()

True

"""

if mpfi_is_nonneg(self.__re):

return False

if mpfi_is_nonneg(self.__im):

return False

if mpfi_is_neg(self.__im):

return False

return True

def conjugate(self):

"""

Return the complex conjugate of this complex number.

EXAMPLES::

sage: i = CIF.0

sage: (1+i).conjugate()

1 - 1*I

"""

x = self._new()

mpfi_set(x.__re, self.__re)

mpfi_neg(x.__im, self.__im)

return x

def exp(self):

r"""

Compute `e^z` or `\exp(z)` where `z` is the complex number ``self``.

EXAMPLES::

sage: i = ComplexIntervalField(300).0

sage: z = 1 + i

sage: z.exp()

1.46869393991588515713896759732660426132695673662900872279767567631093696585951213872272450? + 2.28735528717884239120817190670050180895558625666835568093865811410364716018934540926734485?*I

"""

mag = self.real().exp()

theta = self.imag()

re = theta.cos() * mag

im = theta.sin() * mag

return ComplexIntervalFieldElement(self._parent, re, im)

def log(self, base=None):

"""

Complex logarithm of `z`.

.. WARNING::

This does always not use the standard branch cut for complex log!

See the docstring for :meth:`argument()` to see what we do instead.

EXAMPLES::

sage: a = CIF(RIF(3, 4), RIF(13, 14))

sage: a.log().str(style='brackets')

'[2.5908917751460420 .. 2.6782931373360067] + [1.2722973952087170 .. 1.3597029935721503]*I'

sage: a.log().exp().str(style='brackets')

'[2.7954667135098274 .. 4.2819545928390213] + [12.751682453911920 .. 14.237018048974635]*I'

sage: a in a.log().exp()

True

If the interval crosses the negative real axis, then we don't

use the standard branch cut (and we violate the interval guarantees)::

sage: CIF(-3, RIF(-1/4, 1/4)).log().str(style='brackets')

'[1.0986122886681095 .. 1.1020725100903968] + [3.0584514217013518 .. 3.2247338854782349]*I'

sage: CIF(-3, -1/4).log()

1.102072510090397? - 3.058451421701352?*I

Usually if an interval contains zero, we raise an exception::

sage: CIF(RIF(-1,1),RIF(-1,1)).log()

Traceback (most recent call last):

...

ValueError: Can't take the argument of interval strictly containing zero

But we allow the exact input zero::

sage: CIF(0).log()

[-infinity .. -infinity]

If a base is passed from another function, we can accommodate this::

sage: CIF(-1,1).log(2)

0.500000000000000? + 3.39927010637040?*I

"""

if not self:

from .real_mpfi import RIF

return RIF(0).log()

re = abs(self).log()

im = self.argument()

if base == 'e':

base = None

if base is not None:

base = self._parent._real_field()(base)

f = base.log()

re /= f

im /= f

return ComplexIntervalFieldElement(self._parent, re, im)

def sqrt(self, bint all=False, **kwds):

"""

The square root function.

.. WARNING::

We approximate the standard branch cut along the negative real

axis, with ``sqrt(-r^2) = i*r`` for positive real ``r``; but if

the interval crosses the negative real axis, we pick the root with

positive imaginary component for the entire interval.

INPUT:

- ``all`` -- bool (default: ``False``); if ``True``, return a list

of all square roots.

EXAMPLES::

sage: CIF(-1).sqrt()^2

-1

sage: sqrt(CIF(2))

1.414213562373095?

sage: sqrt(CIF(-1))

1*I

sage: sqrt(CIF(2-I))^2

2.00000000000000? - 1.00000000000000?*I

sage: CC(-2-I).sqrt()^2

-2.00000000000000 - 1.00000000000000*I

Here, we select a non-principal root for part of the interval, and

violate the standard interval guarantees::

sage: CIF(-5, RIF(-1, 1)).sqrt().str(style='brackets')

'[-0.22250788030178321 .. 0.22250788030178296] + [2.2251857651053086 .. 2.2581008643532262]*I'

sage: CIF(-5, -1).sqrt()

0.222507880301783? - 2.247111425095870?*I

"""

if self.is_zero():

return [self] if all else self

if mpfi_is_zero(self.__im) and not mpfi_has_zero(self.__re):

if mpfr_sgn(&self.__re.left) > 0:

x = ComplexIntervalFieldElement(self._parent, self.real().sqrt(), 0)

else:

x = ComplexIntervalFieldElement(self._parent, 0, (-self.real()).sqrt())

else:

theta = self.argument()/2

rho = abs(self).sqrt()

x = ComplexIntervalFieldElement(self._parent, rho*theta.cos(), rho*theta.sin())

if all:

return [x, -x]

else:

return x

def is_square(self):

r"""

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

EXAMPLES::

sage: CIF(2, 1).is_square()

True

"""

return True

def is_NaN(self):

r"""

Return ``True`` if this is not-a-number.

EXAMPLES::

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

False

sage: CIF(NaN).is_NaN()

True

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

True

"""

return mpfi_nan_p(self.__re) or mpfi_nan_p(self.__im)

def cos(self):

r"""

Compute the cosine of this complex interval.

EXAMPLES::

sage: CIF(1,1).cos()

0.833730025131149? - 0.988897705762865?*I

sage: CIF(3).cos()

-0.9899924966004455?

sage: CIF(0,2).cos()

3.762195691083632?

Check that :trac:`17285` is fixed::

sage: CIF(cos(2/3))

0.7858872607769480?

ALGORITHM:

The implementation uses the following trigonometric identity

.. MATH::

\cos(x + iy) = \cos(x) \cosh(y) - i \sin(x) \sinh(y)

"""

res = self._new()

cdef mpfi_t tmp

mpfi_init2(tmp, self._parent.prec())

sig_on()

mpfi_cos(res.__re, self.__re)

mpfi_cosh(tmp, self.__im)

mpfi_mul(res.__re, res.__re, tmp)

mpfi_sin(res.__im, self.__re)

mpfi_sinh(tmp, self.__im)

mpfi_mul(res.__im, res.__im, tmp)

mpfi_neg(res.__im, res.__im)

sig_off()

mpfi_clear(tmp)

return res

def sin(self):

r"""

Compute the sine of this complex interval.

EXAMPLES::

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

1.298457581415978? + 0.634963914784736?*I

sage: CIF(2).sin()

0.909297426825682?

sage: CIF(0,2).sin()

3.626860407847019?*I

Check that :trac:`17825` is fixed::

sage: CIF(sin(2/3))

0.618369803069737?

ALGORITHM:

The implementation uses the following trigonometric identity

.. MATH::

\sin(x + iy) = \sin(x) \cosh(y) + i \cos (x) \sinh(y)

"""

res = self._new()

cdef mpfi_t tmp

mpfi_init2(tmp, self._parent.prec())

sig_on()

mpfi_sin(res.__re, self.__re)

mpfi_cosh(tmp, self.__im)

mpfi_mul(res.__re, res.__re, tmp)

mpfi_cos(res.__im, self.__re)

mpfi_sinh(tmp, self.__im)

mpfi_mul(res.__im, res.__im, tmp)

sig_off()

mpfi_clear(tmp)

return res

def tan(self):

r"""

Return the tangent of this complex interval.

EXAMPLES::

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

0.27175258531952? + 1.08392332733870?*I

sage: CIF(2).tan()

-2.185039863261519?

sage: CIF(0,2).tan()

0.964027580075817?*I

"""

return self.sin() / self.cos()

def cosh(self):

r"""

Return the hyperbolic cosine of this complex interval.

EXAMPLES::

sage: CIF(1,1).cosh()

0.833730025131149? + 0.988897705762865?*I

sage: CIF(2).cosh()

3.762195691083632?

sage: CIF(0,2).cosh()

-0.4161468365471424?

ALGORITHM:

The implementation uses the following trigonometric identity

.. MATH::

\cosh(x+iy) = \cos(y) \cosh(x) + i \sin(y) \sinh(x)

"""

res = self._new()

cdef mpfi_t tmp

mpfi_init2(tmp, self._parent.prec())

sig_on()

mpfi_cos(res.__re, self.__im)

mpfi_cosh(tmp, self.__re)

mpfi_mul(res.__re, res.__re, tmp)

mpfi_sin(res.__im, self.__im)

mpfi_sinh(tmp, self.__re)

mpfi_mul(res.__im, res.__im, tmp)

sig_off()

mpfi_clear(tmp)

return res

def sinh(self):

r"""

Return the hyperbolic sine of this complex interval.

EXAMPLES::

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

0.634963914784736? + 1.298457581415978?*I

sage: CIF(2).sinh()

3.626860407847019?

sage: CIF(0,2).sinh()

0.909297426825682?*I

ALGORITHM:

The implementation uses the following trigonometric identity

.. MATH::

\sinh(x+iy) = \cos(y) \sinh(x) + i \sin(y) \cosh(x)

"""

res = self._new()

cdef mpfi_t tmp

mpfi_init2(tmp, self._parent.prec())

sig_on()

mpfi_cos(res.__re, self.__im)

mpfi_sinh(tmp, self.__re)

mpfi_mul(res.__re, res.__re, tmp)

mpfi_sin(res.__im, self.__im)

mpfi_cosh(tmp, self.__re)

mpfi_mul(res.__im, res.__im, tmp)

sig_off()

mpfi_clear(tmp)

return res

def tanh(self):

r"""

Return the hyperbolic tangent of this complex interval.

EXAMPLES::

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

1.08392332733870? + 0.27175258531952?*I

sage: CIF(2).tanh()

0.964027580075817?

sage: CIF(0,2).tanh()

-2.185039863261519?*I

"""

return self.sinh() / self.cosh()

def zeta(self, a=None):

"""

Return the image of this interval by the Hurwitz zeta function.

For ``a = 1`` (or ``a = None``), this computes the Riemann zeta function.

EXAMPLES::

sage: zeta(CIF(2, 3))

0.7980219851462757? - 0.1137443080529385?*I

sage: _.parent()

Complex Interval Field with 53 bits of precision

sage: CIF(2, 3).zeta(1/2)

-1.955171567161496? + 3.123301509220897?*I

"""

from sage.rings.complex_arb import ComplexBallField

return ComplexBallField(self.prec())(self).zeta(a).\

_complex_mpfi_(self._parent)

def make_ComplexIntervalFieldElement0( fld, re, im ):

"""

Construct a :class:`ComplexIntervalFieldElement` for pickling.

TESTS::

sage: a = CIF(1 + I)

sage: loads(dumps(a)) == a # indirect doctest

True

"""

return fld(re, im)

def create_ComplexIntervalFieldElement(s_real, s_imag=None, int pad=0, min_prec=53):

r"""

Return the complex number defined by the strings ``s_real`` and ``s_imag``

as an element of ``ComplexIntervalField(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: ComplexIntervalFieldElement('2.3')

2.300000000000000?

sage: ComplexIntervalFieldElement('2.3','1.1')

2.300000000000000? + 1.100000000000000?*I

sage: ComplexIntervalFieldElement(10)

sage: ComplexIntervalFieldElement(10,10)

10 + 10*I

sage: ComplexIntervalFieldElement(1.000000000000000000000000000,2)

1 + 2*I

sage: ComplexIntervalFieldElement(1,2.000000000000000000000)

1 + 2*I

sage: ComplexIntervalFieldElement(1.234567890123456789012345, 5.4321098654321987654321)

1.234567890123456789012350? + 5.432109865432198765432000?*I

TESTS:

Make sure we've rounded up ``log(10,2)`` enough to guarantee

sufficient precision (:trac:`10164`). This is a little tricky

because at the time of writing, we don't support intervals long

enough to trip the error. However, at least we can make sure that

we either do it correctly or fail noisily::

sage: c_CIFE = sage.rings.complex_interval.create_ComplexIntervalFieldElement

sage: for kp in range(2,6):

....: s = '1.' + '0'*10**kp + '1'

....: try:

....: assert c_CIFE(s,0).real()-1 != 0

....: assert c_CIFE(0,s).imag()-1 != 0

....: except TypeError:

....: pass

"""

if s_imag is None:

s_imag = 0

if not isinstance(s_real, str):

s_real = str(s_real).strip()

if not isinstance(s_imag, str):

s_imag = str(s_imag).strip()

#if base == 10:

bits = max(int(LOG_TEN_TWO_PLUS_EPSILON*len(s_real)),

int(LOG_TEN_TWO_PLUS_EPSILON*len(s_imag)))

#else:

# bits = max(int(math.log(base,2)*len(s_imag)),int(math.log(base,2)*len(s_imag)))

from .complex_interval_field import ComplexIntervalField

C = ComplexIntervalField(prec=max(bits+pad, min_prec))

return ComplexIntervalFieldElement(C, s_real, s_imag)

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

649 statements 563 run 86 missing 0 excluded