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

""" 

Optimized Quadratic Number Field Elements 

This file defines a Cython class ``NumberFieldElement_quadratic`` to speed up 

computations in quadratic extensions of `\QQ`. 

AUTHORS: 

- Robert Bradshaw (2007-09): Initial version 

- David Harvey (2007-10): fix up a few bugs, polish around the edges 

- David Loeffler (2009-05): add more documentation and tests 

- Vincent Delecroix (2012-07): comparisons for quadratic number fields 

(:trac:`13213`), abs, floor and ceil functions (:trac:`13256`) 

.. TODO:: 

The ``_new()`` method should be overridden in this class to copy the ``D`` 

and ``standard_embedding`` attributes 

""" 

#***************************************************************************** 

# Copyright (C) 2007 Robert Bradshaw <robertwb@math.washington.edu> 

# 

# This program is free software: you can redistribute it and/or modify 

# it under the terms of the GNU General Public License as published by 

# the Free Software Foundation, either version 2 of the License, or 

# (at your option) any later version. 

# http://www.gnu.org/licenses/ 

#***************************************************************************** 

from __future__ import absolute_import, division 

include "sage/libs/ntl/decl.pxi" 

from cpython.object cimport Py_EQ, Py_NE, Py_LE, Py_GE, Py_LT, Py_GT 

from cysignals.signals cimport sig_on, sig_off 

from sage.libs.gmp.mpz cimport * 

from sage.libs.gmp.mpq cimport * 

from sage.libs.flint.fmpz cimport * 

from sage.libs.arb.arb cimport * 

from sage.libs.arb.acb cimport * 

from sage.libs.ntl.ntl_ZZ cimport ntl_ZZ 

from sage.libs.ntl.ntl_ZZX cimport ntl_ZZX 

from sage.libs.mpfi cimport * 

from sage.structure.parent_base cimport ParentWithBase 

from sage.structure.element cimport Element 

from sage.structure.richcmp cimport rich_to_bool_sgn 

from sage.rings.rational cimport Rational 

from sage.rings.integer_ring import ZZ 

from sage.rings.rational_field import QQ 

from sage.rings.real_double import RDF 

from sage.rings.complex_double import CDF 

from sage.categories.morphism cimport Morphism 

from sage.rings.number_field.number_field_element import _inverse_mod_generic 

from sage.rings.real_mpfi cimport RealIntervalField_class 

from sage.rings.complex_interval cimport ComplexIntervalFieldElement 

from sage.rings.real_arb cimport RealBall 

from sage.rings.complex_arb cimport ComplexBall 

from sage.libs.gmp.pylong cimport mpz_pythonhash 

def __make_NumberFieldElement_quadratic0(parent, a, b, denom): 

""" 

Used in unpickling elements of number fields. 

TESTS:: 

sage: K.<a> = NumberField(x^2-x+13) 

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

True 

""" 

return NumberFieldElement_quadratic(parent, (a, b, denom)) 

def __make_NumberFieldElement_quadratic1(parent, cls, a, b, denom): 

""" 

Used in unpickling elements of number fields. 

TESTS:: 

sage: K.<a> = NumberField(x^2-x+13) 

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

True 

We test that :trac:`6462` is fixed:: 

sage: L = QuadraticField(-11,'a'); OL = L.maximal_order(); w = OL.0 

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

True 

""" 

return cls(parent, (a, b, denom)) 

cdef class NumberFieldElement_quadratic(NumberFieldElement_absolute): 

r""" 

A NumberFieldElement_quadratic object gives an efficient representation of 

an element of a quadratic extension of `\QQ`. 

Elements are represented internally as triples `(a, b, c)` of integers, 

where `{\rm gcd}(a, b, c) = 1` and `c > 0`, representing the element `(a + 

b \sqrt{D}) / c`. Note that if the discriminant `D` is `1 \bmod 4`, 

integral elements do not necessarily have `c = 1`. 

TESTS:: 

sage: from sage.rings.number_field.number_field_element_quadratic import NumberFieldElement_quadratic 

We set up some fields:: 

sage: K.<a> = NumberField(x^2+23) 

sage: a.parts() 

(0, 1) 

sage: F.<b> = NumberField(x^2-x+7) 

sage: b.parts() 

(1/2, 3/2) 

We construct elements of these fields in various ways - firstly, from 

polynomials:: 

sage: NumberFieldElement_quadratic(K, x-1) 

a - 1 

sage: NumberFieldElement_quadratic(F, x-1) 

b - 1 

From triples of Integers:: 

sage: NumberFieldElement_quadratic(K, (1,2,3)) 

2/3*a + 1/3 

sage: NumberFieldElement_quadratic(F, (1,2,3)) 

4/9*b + 1/9 

sage: NumberFieldElement_quadratic(F, (1,2,3)).parts() 

(1/3, 2/3) 

From pairs of Rationals:: 

sage: NumberFieldElement_quadratic(K, (1/2,1/3)) 

1/3*a + 1/2 

sage: NumberFieldElement_quadratic(F, (1/2,1/3)) 

2/9*b + 7/18 

sage: NumberFieldElement_quadratic(F, (1/2,1/3)).parts() 

(1/2, 1/3) 

Direct from Rationals:: 

sage: NumberFieldElement_quadratic(K, 2/3) 

2/3 

sage: NumberFieldElement_quadratic(F, 2/3) 

2/3 

This checks a bug when converting from lists:: 

sage: w = CyclotomicField(3)([1/2,1]) 

sage: w == w.__invert__().__invert__() 

True 

""" 

def __init__(self, parent, f): 

""" 

Standard initialisation function. 

EXAMPLES:: 

sage: F.<a> = QuadraticField(-7) 

sage: c = a + 7 

sage: type(c) # indirect doctest 

<type 'sage.rings.number_field.number_field_element_quadratic.NumberFieldElement_quadratic'> 

""" 

self.D = parent._D 

cdef Integer a, b, denom 

cdef Rational ad, bd 

cdef NumberFieldElement_quadratic gen 

if isinstance(f, NumberFieldElement_quadratic): 

self._parent = parent # NOTE: We do *not* call NumberFieldElement_absolute.__init__, for speed reasons. 

mpz_set(self.a, (<NumberFieldElement_quadratic>f).a) 

mpz_set(self.b, (<NumberFieldElement_quadratic>f).b) 

mpz_set(self.denom, (<NumberFieldElement_quadratic>f).denom) 

elif type(f) is tuple and len(f) == 2: 

NumberFieldElement_absolute.__init__(self, parent, None) 

ad, bd = f 

mpz_lcm(self.denom, mpq_denref(ad.value), mpq_denref(bd.value)) 

mpz_divexact(self.a, self.denom, mpq_denref(ad.value)) 

mpz_mul(self.a, self.a, mpq_numref(ad.value)) 

mpz_divexact(self.b, self.denom, mpq_denref(bd.value)) 

mpz_mul(self.b, self.b, mpq_numref(bd.value)) 

elif type(f) is tuple and len(f) == 3: 

NumberFieldElement_absolute.__init__(self, parent, None) 

a, b, denom = f 

mpz_set(self.a, a.value) 

mpz_set(self.b, b.value) 

mpz_set(self.denom, denom.value) 

self._reduce_c_() 

else: 

NumberFieldElement_absolute.__init__(self, parent, f) 

# poly is in gen (which may not be sqrt(d)) 

self._ntl_coeff_as_mpz(self.a, 0) 

self._ntl_coeff_as_mpz(self.b, 1) 

if mpz_cmp_ui(self.a, 0) or mpz_cmp_ui(self.b, 0): 

gen = parent.gen() # should this be cached? 

self._ntl_denom_as_mpz(self.denom) 

if mpz_cmp_ui(self.b, 0): 

mpz_mul(self.a, self.a, gen.denom) 

mpz_addmul(self.a, self.b, gen.a) 

mpz_mul(self.b, self.b, gen.b) 

mpz_mul(self.denom, self.denom, gen.denom) 

else: 

mpz_set_ui(self.denom, 1) 

self._reduce_c_() 

# set the attribute standard embedding which is used in the methods 

# __cmp__, sign, real, imag, floor, ceil, ... 

self.standard_embedding = parent._standard_embedding 

cdef _new(self): 

""" 

Quickly creates a new initialized NumberFieldElement_quadratic with the 

same parent as self. 

EXAMPLES:: 

sage: F.<b> = CyclotomicField(3) 

sage: b + b # indirect doctest 

2*b 

""" 

cdef type t = type(self) 

cdef NumberFieldElement_quadratic x = <NumberFieldElement_quadratic>t.__new__(t) 

x._parent = self._parent 

x.standard_embedding = self.standard_embedding 

x.D = self.D 

return x 

cdef number_field(self): 

r""" 

Return the number field to which this element belongs. Since this is a 

Cython cdef method, it is not directly accessible by the user, but the 

function "_number_field" calls this one. 

EXAMPLES:: 

sage: F.<b> = QuadraticField(-7) 

sage: b._number_field() # indirect doctest 

Number Field in b with defining polynomial x^2 + 7 

""" 

return self._parent 

def _maxima_init_(self, I=None): 

""" 

EXAMPLES:: 

sage: K.<a> = QuadraticField(-1) 

sage: f = 1 + a 

sage: f._maxima_init_() 

'1+%i*1' 

""" 

a = self.parent().gen() 

if a**2 == -1: 

x0, x1 = self 

return str(x0) + "+" + "%i*" + str(x1) 

else: 

NumberFieldElement_absolute._maxima_init_(self, I) 

def _polymake_init_(self): 

""" 

EXAMPLES:: 

sage: K.<sqrt5> = QuadraticField(5) 

sage: polymake(3+2*sqrt5) # optional - polymake 

3+2r5 

sage: K.<i> = QuadraticField(-1) 

sage: polymake(i) # optional - polymake 

Traceback (most recent call last): 

... 

TypeError: Negative values for the root of the extension ... Bad Thing... 

""" 

x0, x1 = self 

return "new QuadraticExtension({}, {}, {})".format(x0, x1, self.D) 

def __copy__(self): 

r""" 

Returns a new copy of self. 

TESTS:: 

sage: K.<a> = QuadraticField(-3) 

sage: b = a + 3 

sage: c = b.__copy__() 

sage: b 

a + 3 

sage: c 

a + 3 

sage: b is c 

False 

sage: b == c 

True 

""" 

cdef NumberFieldElement_quadratic x = <NumberFieldElement_quadratic>self._new() 

mpz_set(x.a, self.a) 

mpz_set(x.b, self.b) 

mpz_set(x.denom, self.denom) 

return x 

def __cinit__(self): 

r""" 

Initialisation function. 

EXAMPLES:: 

sage: QuadraticField(-3, 'a').gen() # indirect doctest 

a 

""" 

mpz_init(self.a) 

mpz_init(self.b) 

mpz_init(self.denom) 

def __dealloc__(self): 

mpz_clear(self.a) 

mpz_clear(self.b) 

mpz_clear(self.denom) 

def __reduce__(self): 

""" 

Used for pickling. 

TESTS: 

sage: K.<a> = NumberField(x^2-13) 

sage: loads(dumps(a)) == a 

True 

sage: loads(dumps(a/3+5)) == a/3+5 

True 

""" 

cdef Integer a = Integer.__new__(Integer) 

cdef Integer b = Integer.__new__(Integer) 

cdef Integer denom = Integer.__new__(Integer) 

mpz_set(a.value, self.a) 

mpz_set(b.value, self.b) 

mpz_set(denom.value, self.denom) 

return __make_NumberFieldElement_quadratic1, (self._parent, type(self), a, b, denom) 

cdef int _randomize(self, num_bound, den_bound, distribution) except -1: 

cdef Integer temp, denom1, denom2 

# in theory, we could just generate two random numerators and 

# a random denominator. however, this would mean that we were 

# extraordinarily unlikely to run into results of the form 

# 1/3 + 1/5*sqrt(D), which are often some of the best examples 

# for testing out code. since this is probably the primary use 

# of the random element code, it's worth doing slightly more 

# work to make this possible. 

# normalize denominator bound 

if den_bound is None or den_bound < 1: 

den_bound = 1 

# generate denominators 

denom1 = <Integer>(ZZ.random_element(x=1, 

y=den_bound+1, 

distribution=distribution)) 

denom2 = <Integer>(ZZ.random_element(x=1, 

y=den_bound+1, 

distribution=distribution)) 

# set a, b 

temp = <Integer>(ZZ.random_element(x=num_bound, distribution=distribution)) 

mpz_mul(self.a, temp.value, denom2.value) 

temp = <Integer>(ZZ.random_element(x=num_bound, distribution=distribution)) 

mpz_mul(self.b, temp.value, denom1.value) 

# set denom 

mpz_mul(self.denom, denom1.value, denom2.value) 

self._reduce_c_() 

return 0 # No error 

def _lift_cyclotomic_element(self, new_parent, bint check=True, int rel=0): 

""" 

Creates an element of the passed field from this field. This 

is specific to creating elements in a cyclotomic field from 

elements in another cyclotomic field, in the case that 

self.number_field()._n() divides new_parent()._n(). This 

function aims to make this common coercion extremely fast! 

More general coercion (i.e. of zeta6 into CyclotomicField(3)) 

is implemented in the _coerce_from_other_cyclotomic_field 

method of a CyclotomicField. 

EXAMPLES:: 

sage: C.<zeta4>=CyclotomicField(4) 

sage: CyclotomicField(20)(zeta4+1) # The function _lift_cyclotomic_element does the heavy lifting in the background 

zeta20^5 + 1 

sage: (zeta4+1)._lift_cyclotomic_element(CyclotomicField(40)) # There is rarely a purpose to call this function directly 

zeta40^10 + 1 

sage: cf3 = CyclotomicField(3) ; z3 = cf3.0 

sage: cf6 = CyclotomicField(6) ; z6 = cf6.0 

sage: z6._lift_cyclotomic_element(cf3) 

Traceback (most recent call last): 

... 

TypeError: The zeta_order of the new field must be a multiple of the zeta_order of the original. 

sage: cf3(z6) 

zeta3 + 1 

sage: z3._lift_cyclotomic_element(cf6) 

zeta6 - 1 

Verify embeddings are respected:: 

sage: cf6c = CyclotomicField(6, embedding=CDF(exp(-pi*I/3))) ; z6c = cf6c.0 

sage: cf3(z6c) 

-zeta3 

sage: cf6c(z3) 

-zeta6 

AUTHOR: 

- Joel B. Mohler (original version) 

- Craig Citro (reworked for quadratic elements) 

""" 

if check: 

from .number_field import NumberField_cyclotomic 

if not isinstance(self.number_field(), NumberField_cyclotomic) \ 

or not isinstance(new_parent, NumberField_cyclotomic): 

raise TypeError("The field and the new parent field must both be cyclotomic fields.") 

if rel == 0: 

small_order = self.number_field()._n() 

large_order = new_parent._n() 

try: 

rel = ZZ(large_order / small_order) 

except TypeError: 

raise TypeError("The zeta_order of the new field must be a multiple of the zeta_order of the original.") 

cdef NumberFieldElement_quadratic x2 

cdef int n = self._parent._n() 

if new_parent.degree() == 2: 

## since self is a *quadratic* element, we can only get 

## here if self.parent() and new_parent are: 

## - CyclotomicField(3) and CyclotomicField(6) 

## - CyclotomicField(3) and CyclotomicField(3) 

## - CyclotomicField(6) and CyclotomicField(6) 

## - CyclotomicField(4) and CyclotomicField(4) 

## In all cases, conversion of elements is trivial! 

if n == <int>new_parent._n(): 

conjugate = rel != 1 

else: 

# n = 3, new_n = 6 

conjugate = rel == 4 

x2 = <NumberFieldElement_quadratic>(self._new()) 

x2._parent = new_parent 

mpz_set(x2.a, self.a) 

if conjugate: 

mpz_neg(x2.b, self.b) 

else: 

mpz_set(x2.b, self.b) 

mpz_set(x2.denom, self.denom) 

x2.D = self.D 

return x2 

cdef NumberFieldElement x 

cdef ZZX_c elt_num 

cdef ZZ_c elt_den, tmp_coeff 

cdef mpz_t tmp_mpz 

cdef long tmp_const 

x = <NumberFieldElement_absolute>NumberFieldElement_absolute.__new__(NumberFieldElement_absolute) 

mpz_to_ZZ(&elt_den, self.denom) 

mpz_init(tmp_mpz) 

## set the two terms in the polynomial 

if n == 4: 

mpz_to_ZZ(&tmp_coeff, self.a) 

ZZX_SetCoeff(elt_num, 0, tmp_coeff) 

mpz_to_ZZ(&tmp_coeff, self.b) 

ZZX_SetCoeff(elt_num, 1, tmp_coeff) 

elif n == 3: 

## num[0] = a + b 

mpz_add(tmp_mpz, tmp_mpz, self.a) 

mpz_add(tmp_mpz, tmp_mpz, self.b) 

mpz_to_ZZ(&tmp_coeff, tmp_mpz) 

ZZX_SetCoeff(elt_num, 0, tmp_coeff) 

## num[1] = 2*b 

mpz_sub(tmp_mpz, tmp_mpz, self.a) 

tmp_const = 2 

mpz_mul_si(tmp_mpz, tmp_mpz, tmp_const) 

mpz_to_ZZ(&tmp_coeff, tmp_mpz) 

ZZX_SetCoeff(elt_num, 1, tmp_coeff) 

elif n == 6: 

## num[0] = a - b 

mpz_add(tmp_mpz, tmp_mpz, self.a) 

mpz_sub(tmp_mpz, tmp_mpz, self.b) 

mpz_to_ZZ(&tmp_coeff, tmp_mpz) 

ZZX_SetCoeff(elt_num, 0, tmp_coeff) 

## num[1] = 2*b 

mpz_sub(tmp_mpz, tmp_mpz, self.a) 

tmp_const = -2 

mpz_mul_si(tmp_mpz, tmp_mpz, tmp_const) 

mpz_to_ZZ(&tmp_coeff, tmp_mpz) 

ZZX_SetCoeff(elt_num, 1, tmp_coeff) 

mpz_clear(tmp_mpz) 

x._parent = <ParentWithBase>new_parent 

x.__fld_numerator, x.__fld_denominator = new_parent.polynomial_ntl() 

x.__denominator = elt_den 

cdef ZZX_c result 

cdef ZZ_c tmp 

cdef int i 

cdef ntl_ZZX _num 

cdef ntl_ZZ _den 

_num, _den = new_parent.polynomial_ntl() 

for i from 0 <= i <= ZZX_deg(elt_num): 

tmp = ZZX_coeff(elt_num, i) 

ZZX_SetCoeff(result, i*rel, tmp) 

ZZX_rem(x.__numerator, result, _num.x) 

(<NumberFieldElement_absolute>x)._reduce_c_() 

return x 

def _real_mpfi_(self, R): 

r""" 

Conversion to a real interval field 

TESTS:: 

sage: K1 = QuadraticField(2) 

sage: RIF(K1.gen()) 

1.414213562373095? 

sage: RIF(K1(1/5)) 

0.2000000000000000? 

sage: RIF(3/5*K1.gen() + 1/5) 

1.048528137423857? 

sage: K2 = QuadraticField(2, embedding=-RLF(2).sqrt()) 

sage: RIF(K2.gen()) 

-1.414213562373095? 

sage: K3 = QuadraticField(-1) 

sage: RIF(K3.gen()) 

Traceback (most recent call last): 

... 

ValueError: unable to convert complex algebraic number a to real interval 

sage: RIF(K3(2)) 

2 

Check that :trac:`21979` is fixed:: 

sage: a = QuadraticField(5).gen() 

sage: u = -573147844013817084101/2*a + 1281597540372340914251/2 

sage: RealIntervalField(128)(u) 

0.?e-17 

sage: RealIntervalField(128)(u).is_zero() 

False 

This was fixed in :trac:`24371`:: 

sage: RIF.convert_map_from(QuadraticField(5)) 

Conversion via _real_mpfi_ method map: 

From: Number Field in a with defining polynomial x^2 - 5 

To: Real Interval Field with 53 bits of precision 

""" 

ans = (<RealIntervalField_class?>R)._new() 

if mpz_cmp_ui(self.b, 0): 

if mpz_cmp_ui(self.D.value, 0) < 0: 

raise ValueError(f"unable to convert complex algebraic number {self!r} to real interval") 

mpfi_set_z(ans.value, self.D.value) 

mpfi_sqrt(ans.value, ans.value) 

if not self.standard_embedding: 

mpfi_neg(ans.value, ans.value) 

mpfi_mul_z(ans.value, ans.value, self.b) 

mpfi_add_z(ans.value, ans.value, self.a) 

else: 

mpfi_set_z(ans.value, self.a) 

mpfi_div_z(ans.value, ans.value, self.denom) 

return ans 

def _complex_mpfi_(self, R): 

r""" 

Conversion to a complex interval field 

TESTS:: 

sage: K.<a> = QuadraticField(2) 

sage: CIF(a) 

1.414213562373095? 

sage: CIF(K(1/5)) 

0.2000000000000000? 

sage: CIF(1/5 + 3/5*a) 

1.048528137423857? 

sage: K.<a> = QuadraticField(-2) 

sage: CIF(a) 

1.414213562373095?*I 

sage: CIF(K(1/5)) 

0.2000000000000000? 

sage: CIF(1/5 + 3/5*a) 

0.2000000000000000? + 0.848528137423857?*I 

sage: K.<a> = QuadraticField(-2, embedding=-CLF(-2).sqrt()) 

sage: CIF(a) 

-1.414213562373095?*I 

This was fixed in :trac:`24371`:: 

sage: CIF.convert_map_from(QuadraticField(-5)) 

Conversion via _complex_mpfi_ method map: 

From: Number Field in a with defining polynomial x^2 + 5 

To: Complex Interval Field with 53 bits of precision 

""" 

ans = <ComplexIntervalFieldElement>ComplexIntervalFieldElement.__new__(ComplexIntervalFieldElement, R) 

if mpz_cmp_ui(self.b, 0): 

mpfi_set_z(ans.__re, self.D.value) 

if mpfi_is_neg(ans.__re): 

# Imaginary quadratic 

mpfi_neg(ans.__re, ans.__re) 

mpfi_sqrt(ans.__im, ans.__re) 

if not self.standard_embedding: 

mpfi_neg(ans.__im, ans.__im) 

mpfi_set_z(ans.__re, self.a) 

mpfi_mul_z(ans.__im, ans.__im, self.b) 

mpfi_div_z(ans.__im, ans.__im, self.denom) 

else: 

# Real quadratic 

mpfi_sqrt(ans.__re, ans.__re) 

if not self.standard_embedding: 

mpfi_neg(ans.__re, ans.__re) 

mpfi_mul_z(ans.__re, ans.__re, self.b) 

mpfi_add_z(ans.__re, ans.__re, self.a) 

mpfi_set_ui(ans.__im, 0) 

else: 

mpfi_set_z(ans.__re, self.a) 

mpfi_set_ui(ans.__im, 0) 

mpfi_div_z(ans.__re, ans.__re, self.denom) 

return ans 

cdef int arb_set_real(self, arb_t x, long prec) except -1: 

"Set x to the real part of this element" 

cdef fmpz_t tmpz 

cdef arb_t rootD 

cdef long prec2 

fmpz_init(tmpz) 

if mpz_sgn(self.D.value) > 0: 

# To mitigate the effect of cancellations between 

# a and b*sqrt(D) we perform a loop with increasing 

# working precision 

arb_init(rootD) 

prec2 = prec 

sig_on() 

while True: 

fmpz_set_mpz(tmpz, self.a) 

arb_set_fmpz(x, tmpz) 

fmpz_set_mpz(tmpz, self.D.value) 

arb_sqrt_fmpz(rootD, tmpz, prec2) 

fmpz_set_mpz(tmpz, self.b) 

if self.standard_embedding: 

arb_addmul_fmpz(x, rootD, tmpz, prec2) 

else: 

arb_submul_fmpz(x, rootD, tmpz, prec2) 

if arb_rel_accuracy_bits(x) < prec - 4: 

prec2 *= 2 

continue 

else: 

break 

sig_off() 

arb_clear(rootD) 

else: 

fmpz_set_mpz(tmpz, self.a) 

arb_set_fmpz(x, tmpz) 

fmpz_set_mpz(tmpz, self.denom) 

arb_div_fmpz(x, x, tmpz, prec) 

fmpz_clear(tmpz) 

return 0 

cdef void arb_set_imag(self, arb_t x, long prec): 

"Set x to the imaginary part of this element" 

cdef fmpz_t tmpz 

cdef arb_t rootD 

if mpz_sgn(self.D.value) < 0 and mpz_sgn(self.b): 

arb_init(rootD) 

fmpz_init(tmpz) 

fmpz_set_mpz(tmpz, self.D.value) 

fmpz_neg(tmpz, tmpz) 

arb_sqrt_fmpz(rootD, tmpz, prec) 

fmpz_set_mpz(tmpz, self.b) 

if self.standard_embedding: 

arb_addmul_fmpz(x, rootD, tmpz, prec) 

else: 

arb_submul_fmpz(x, rootD, tmpz, prec) 

fmpz_set_mpz(tmpz, self.denom) 

arb_div_fmpz(x, x, tmpz, prec) 

fmpz_clear(tmpz) 

arb_clear(rootD) 

def _arb_(self, R): 

r""" 

Conversion to a real ball with parent ``R``. 

EXAMPLES:: 

sage: a = QuadraticField(7).gen() 

sage: a._arb_(RBF) 

[2.645751311064590 +/- 7.17e-16] 

sage: RBF(a) 

[2.645751311064590 +/- 7.17e-16] 

sage: a = QuadraticField(7, embedding=-AA(7).sqrt()).gen() 

sage: a._arb_(RBF) 

[-2.645751311064590 +/- 7.17e-16] 

sage: a = QuadraticField(-1).gen() 

sage: RBF(a) 

Traceback (most recent call last): 

... 

ValueError: nonzero imaginary part 

This conversion takes care of cancellations:: 

sage: K.<a> = QuadraticField(3) 

sage: b = (a - 1)**1000 

sage: RBF(b) 

[3.477155118441024e-136 +/- 8.45e-152] 

TESTS: 

Check that coercions and conversions go throuh this method:: 

sage: RBF.convert_map_from(QuadraticField(5)) 

Conversion via _arb_ method map: 

From: Number Field in a with defining polynomial x^2 - 5 

To: Real ball field with 53 bits of precision 

sage: RBF.coerce_map_from(QuadraticField(5, embedding=-AA(5).sqrt())) 

Conversion via _arb_ method map: 

From: Number Field in a with defining polynomial x^2 - 5 

To: Real ball field with 53 bits of precision 

""" 

cdef RealBall res = RealBall.__new__(RealBall) 

res._parent = R 

if mpz_sgn(self.D.value) < 0 and mpz_sgn(self.b): 

raise ValueError('nonzero imaginary part') 

self.arb_set_real(res.value, R._prec) 

return res 

def _acb_(self, R): 

r""" 

Conversion to complex ball with parent ``R``. 

EXAMPLES:: 

sage: K.<a> = QuadraticField(-3) 

sage: CBF(1/7 + 3/2 * a) 

[0.1428571428571428 +/- 7.70e-17] + [2.59807621135332 +/- 6.17e-15]*I 

sage: CBF(1/7) + CBF(3/2) * CBF(a) 

[0.1428571428571428 +/- 7.70e-17] + [2.59807621135332 +/- 5.21e-15]*I 

sage: a._acb_(CBF) 

[1.732050807568877 +/- 4.16e-16]*I 

TESTS: 

Check that coercions and conversions go through this method:: 

sage: CBF.convert_map_from(QuadraticField(-3)) 

Conversion via _acb_ method map: 

From: Number Field in a with defining polynomial x^2 + 3 

To: Complex ball field with 53 bits of precision 

sage: CBF.coerce_map_from(QuadraticField(-3, embedding=-QQbar(-3).sqrt())) 

Conversion via _acb_ method map: 

From: Number Field in a with defining polynomial x^2 + 3 

To: Complex ball field with 53 bits of precision 

""" 

cdef ComplexBall res = ComplexBall.__new__(ComplexBall) 

res._parent = R 

self.arb_set_real(acb_realref(res.value), R._prec) 

self.arb_set_imag(acb_imagref(res.value), R._prec) 

return res 

def parts(self): 

""" 

This function returns a pair of rationals `a` and `b` such that self `= 

a+b\sqrt{D}`. 

This is much closer to the internal storage format of the 

elements than the polynomial representation coefficients (the output of 

``self.list()``), unless the generator with which this number field was 

constructed was equal to `\sqrt{D}`. See the last example below. 

EXAMPLES:: 

sage: K.<a> = NumberField(x^2-13) 

sage: K.discriminant() 

13 

sage: a.parts() 

(0, 1) 

sage: (a/2-4).parts() 

(-4, 1/2) 

sage: K.<a> = NumberField(x^2-7) 

sage: K.discriminant() 

28 

sage: a.parts() 

(0, 1) 

sage: K.<a> = NumberField(x^2-x+7) 

sage: a.parts() 

(1/2, 3/2) 

sage: a._coefficients() 

[0, 1] 

""" 

cdef Rational ad = <Rational>Rational.__new__(Rational) 

cdef Rational bd = <Rational>Rational.__new__(Rational) 

if mpz_cmp_ui(self.a, 0) == 0: 

mpq_set_ui(ad.value, 0, 1) 

else: 

mpz_set(mpq_numref(ad.value), self.a) 

mpz_set(mpq_denref(ad.value), self.denom) 

mpq_canonicalize(ad.value) 

if mpz_cmp_ui(self.b, 0) == 0: 

mpq_set_ui(bd.value, 0, 1) 

else: 

mpz_set(mpq_numref(bd.value), self.b) 

mpz_set(mpq_denref(bd.value), self.denom) 

mpq_canonicalize(bd.value) 

return ad, bd 

cdef bint is_sqrt_disc(self): 

r""" 

Returns true if self is `\sqrt{D}`. 

EXAMPLES:: 

sage: F.<b> = NumberField(x^2 - x + 7) 

sage: b.denominator() # indirect doctest 

1 

""" 

return mpz_cmp_ui(self.denom, 1)==0 and mpz_cmp_ui(self.a, 0)==0 and mpz_cmp_ui(self.b, 1)==0