more updates (some depending on flint trunk)

Author: fredrik-johansson

src/acb.pyx

@@ -266,6 +266,23 @@ cdef class acb(flint_scalar):
         acb_neg_round((<acb>res).val, (<acb>self).val, getprec())
         return res
 
+    def neg(self, bint exact=False):
+        res = acb.__new__(acb)
+        if exact:
+            acb_set((<acb>res).val, (<acb>self).val)
+        else:
+            acb_set_round((<acb>res).val, (<acb>self).val, getprec())
+        return res
+
+    def conjugate(self, bint exact=False):
+        res = acb.__new__(acb)
+        if exact:
+            acb_conj((<acb>res).val, (<acb>self).val)
+        else:
+            acb_set_round((<acb>res).val, (<acb>self).val, getprec())
+            acb_conj((<acb>res).val, (<acb>res).val)
+        return res
+
     def __abs__(self):
         res = arb.__new__(arb)
         acb_abs((<arb>res).val, (<acb>self).val, getprec())
@@ -431,6 +448,12 @@ cdef class acb(flint_scalar):
         if ttype == FMPZ_TMP: acb_clear(tval)
         return u
 
+    def union(s, t):
+        v = acb.__new__(acb)
+        t = any_as_acb(t)
+        acb_union((<acb>v).val, (<acb>s).val, (<acb>t).val, getprec())
+        return v
+
     def pow(s, t, bint analytic=False):
         """
         Power `s^t`.

src/arb.pyx

@@ -230,6 +230,25 @@ cdef class arb(flint_scalar):
         arf_get_fmpz_2exp(man.val, exp.val, arb_midref(self.val))
         return man, exp
 
+    def fmpq(self):
+        cdef fmpq res
+        if not self.is_finite() or not self.is_exact():
+            raise ValueError("fmpq requires an exact, finite value")
+        res = fmpq()
+        arf_get_fmpq(res.val, arb_midref(self.val))
+        return res
+
+    def fmpz(self):
+        cdef fmpz res
+        if not self.is_integer():
+            raise ValueError("fmpz requires an exact, integer value")
+        res = fmpz()
+        arf_get_fmpz(res.val, arb_midref(self.val), ARF_RND_DOWN)
+        return res
+
+    cpdef bint is_integer(self):
+        return arb_is_int(self.val)
+
     def mid(self):
         """
         Returns the midpoint of *self* as an exact *arb*:
@@ -479,6 +498,14 @@ cdef class arb(flint_scalar):
     def contains_integer(self):
         return bool(arb_contains_int(self.val))
 
+    @property
+    def real(self):
+        return self
+
+    @property
+    def imag(self):
+        return arb()
+
     def __pos__(self):
         res = arb.__new__(arb)
         arb_set_round((<arb>res).val, (<arb>self).val, getprec())
@@ -489,6 +516,14 @@ cdef class arb(flint_scalar):
         arb_neg_round((<arb>res).val, (<arb>self).val, getprec())
         return res
 
+    def neg(self, bint exact=False):
+        res = arb.__new__(arb)
+        if exact:
+            arb_set((<arb>res).val, (<arb>self).val)
+        else:
+            arb_set_round((<arb>res).val, (<arb>self).val, getprec())
+        return res
+
     def __abs__(self):
         res = arb.__new__(arb)
         arb_abs((<arb>res).val, (<arb>self).val)

src/flint.pxd

@@ -180,6 +180,7 @@ cdef extern from "flint/nmod_mat.h":
 
 cdef extern from "flint/ulong_extras.h":
     ulong n_gcd(ulong n, ulong k)
+    int n_is_prime(ulong n)
 
 cdef extern from "flint/fmpz.h":
     ctypedef fmpz_struct fmpz_t[1]
@@ -210,6 +211,7 @@ cdef extern from "flint/fmpz.h":
     int fmpz_cmp_ui( fmpz_t f, ulong g)
     int fmpz_cmp_si( fmpz_t f, long g)
     int fmpz_cmpabs( fmpz_t f,  fmpz_t g)
+    int fmpz_equal_si(const fmpz_t f, long g)
     int fmpz_is_even(fmpz_t f)
     int fmpz_is_odd(fmpz_t f)
     mp_size_t fmpz_size(fmpz_t f)
@@ -235,6 +237,7 @@ cdef extern from "flint/fmpz.h":
     int fmpz_sqrtmod(fmpz_t b,  fmpz_t a,  fmpz_t p)
     void fmpz_sqrt(fmpz_t f,  fmpz_t g)
     void fmpz_sqrtrem(fmpz_t f, fmpz_t r,  fmpz_t g)
+    void fmpz_root(fmpz_t r, const fmpz_t f, long n)
     ulong fmpz_fdiv_ui(fmpz_t g, ulong h)
     ulong fmpz_mod_ui(fmpz_t f,  fmpz_t g, ulong h)
     void fmpz_mod(fmpz_t f,  fmpz_t g,  fmpz_t h)
@@ -393,6 +396,8 @@ cdef extern from "flint/fmpz_poly.h":
     void fmpz_poly_cos_minpoly(fmpz_poly_t, ulong)
     void fmpz_poly_swinnerton_dyer(fmpz_poly_t, ulong)
 
+    int fmpz_poly_sqrt(fmpz_poly_t b, const fmpz_poly_t a)
+
 cdef extern from "flint/fmpz_poly_factor.h":
     void fmpz_poly_factor_init(fmpz_poly_factor_t fac)
     void fmpz_poly_factor_clear(fmpz_poly_factor_t fac)
@@ -451,6 +456,9 @@ cdef extern from "flint/fmpz_mat.h":
     void fmpz_mat_snf(fmpz_mat_t S, const fmpz_mat_t A)
     int fmpz_mat_is_in_snf(const fmpz_mat_t A)
 
+    void fmpz_mat_charpoly(fmpz_poly_t cp, const fmpz_mat_t mat)
+    void fmpz_mat_minpoly(fmpz_poly_t cp, const fmpz_mat_t mat)
+
 cdef extern from "flint/fmpz_lll.h":
     ctypedef struct fmpz_lll_struct:
         double delta
@@ -675,6 +683,9 @@ cdef extern from "flint/fmpq_mat.h":
     long fmpq_mat_rref(fmpq_mat_t B, fmpq_mat_t A)
     void fmpq_mat_transpose(fmpq_mat_t B, fmpq_mat_t A)
 
+    void fmpq_mat_charpoly(fmpq_poly_t cp, const fmpq_mat_t mat)
+    void fmpq_mat_minpoly(fmpq_poly_t cp, const fmpq_mat_t mat)
+
 cdef extern from "flint/arith.h":
     void arith_number_of_partitions(fmpz_t res, ulong n)
     int arith_moebius_mu(fmpz_t n)
@@ -722,6 +733,9 @@ cdef extern from "arf.h":
     ctypedef int arf_rnd_t
     cdef arf_rnd_t ARF_RND_DOWN
     cdef arf_rnd_t ARF_RND_NEAR
+    cdef arf_rnd_t ARF_RND_FLOOR
+    cdef arf_rnd_t ARF_RND_CEIL
+    cdef arf_rnd_t ARF_RND_UP
 
     void arf_init(arf_t x)
     void arf_clear(arf_t x)
@@ -1170,6 +1184,7 @@ cdef extern from "acb.h":
     int acb_contains(const acb_t x, const acb_t y)
     int acb_get_unique_fmpz(fmpz_t z, const acb_t x)
     int acb_contains_int(const acb_t x)
+    void acb_union(acb_t z, const acb_t x, const acb_t y, long prec)
     void acb_set_ui(acb_t z, ulong c)
     void acb_set_si(acb_t z, long c)
     void acb_set_fmpz(acb_t z, const fmpz_t c)
@@ -2183,6 +2198,8 @@ cdef extern from "arb_fmpz_poly.h":
     void arb_fmpz_poly_evaluate_arb(arb_t res, const fmpz_poly_t poly, const arb_t x, long prec)
     void arb_fmpz_poly_evaluate_acb(acb_t res, const fmpz_poly_t poly, const acb_t x, long prec)
     void arb_fmpz_poly_complex_roots(acb_ptr roots, const fmpz_poly_t poly, int flags, long prec)
+    ulong arb_fmpz_poly_deflation(const fmpz_poly_t poly)
+    void arb_fmpz_poly_deflate(fmpz_poly_t res, const fmpz_poly_t poly, ulong deflation)
 
 cdef extern from "acb_dft.h":
     void acb_dft(acb_ptr w, acb_srcptr v, long n, long prec)

src/fmpq.pyx

@@ -74,7 +74,13 @@ cdef class fmpq(flint_scalar):
                 res = not res
             return res
         else:
-            raise NotImplementedError("fmpq comparisons")
+            # todo: use fmpq_cmp when available
+            if op == 0: res = (s-t).p < 0
+            elif op == 1: res = (s-t).p <= 0
+            elif op == 4: res = (s-t).p > 0
+            elif op == 5: res = (s-t).p >= 0
+            else: raise ValueError
+            return res
 
     def numer(self):
         """
@@ -272,3 +278,27 @@ cdef class fmpq(flint_scalar):
         cdef fmpq v = fmpq()
         fmpq_harmonic_ui(v.val, n)
         return v
+
+    def floor(self):
+        cdef fmpz r = fmpz.__new__(fmpz)
+        fmpz_fdiv_q(r.val, fmpq_numref(self.val), fmpq_denref(self.val))
+        return r
+
+    def ceil(self):
+        cdef fmpz r = fmpz.__new__(fmpz)
+        fmpz_cdiv_q(r.val, fmpq_numref(self.val), fmpq_denref(self.val))
+        return r
+
+    def __hash__(self):
+        from fractions import Fraction
+        return hash(Fraction(int(self.p), int(self.q), _normalize=False))
+
+    def height_bits(self, bint signed=False):
+        cdef long b1, b2
+        b1 = fmpz_bits(fmpq_numref(self.val))
+        b2 = fmpz_bits(fmpq_denref(self.val))
+        if signed and fmpz_sgn(fmpq_numref(self.val)) < 0:
+            return -max(b1, b2)
+        else:
+            return max(b1, b2)
+

src/fmpq_mat.pyx

@@ -417,3 +417,18 @@ cdef class fmpq_mat(flint_mat):
         den = fmpz()
         fmpq_mat_get_fmpz_mat_matwise(num.val, den.val, self.val)
         return num, den
+
+    def charpoly(self):
+        cdef fmpq_poly u
+        u = fmpq_poly.__new__(fmpq_poly)
+        fmpq_poly_init(u.val)
+        fmpq_mat_charpoly(u.val, self.val)
+        return u
+
+    def minpoly(self):
+        cdef fmpq_poly u
+        u = fmpq_poly.__new__(fmpq_poly)
+        fmpq_poly_init(u.val)
+        fmpq_mat_minpoly(u.val, self.val)
+        return u
+

src/fmpq_poly.pyx

@@ -158,6 +158,16 @@ cdef class fmpq_poly(flint_poly):
             return v
         raise TypeError("cannot call fmpq_poly with input of type %s", type(other))
 
+    def derivative(self):
+        cdef fmpq_poly res = fmpq_poly.__new__(fmpq_poly)
+        fmpq_poly_derivative(res.val, self.val)
+        return res
+
+    def integral(self):
+        cdef fmpq_poly res = fmpq_poly.__new__(fmpq_poly)
+        fmpq_poly_integral(res.val, self.val)
+        return res
+
     def __pos__(self):
         return self
 

src/fmpz.pyx

@@ -508,3 +508,40 @@ cdef class fmpz(flint_scalar):
         cdef fmpz v = fmpz()
         arith_euler_phi(v.val, n.val)
         return v
+
+    def __hash__(self):
+        return hash(int(self))
+
+    def height_bits(self, bint signed=False):
+        if signed and fmpz_sgn(self.val) < 0:
+            return -self.bit_length()
+        else:
+            return self.bit_length()
+
+    def isqrt(self):
+        cdef fmpz v
+        if fmpz_sgn(self.val) < 0:
+            raise ValueError("integer square root of a negative number")
+        v = fmpz()
+        fmpz_sqrt(v.val, self.val)
+        return v
+
+    def sqrtrem(self):
+        cdef fmpz u, v
+        if fmpz_sgn(self.val) < 0:
+            raise ValueError("integer square root of a negative number")
+        u = fmpz()
+        v = fmpz()
+        fmpz_sqrtrem(u.val, v.val, self.val)
+        return u, v
+
+    def root(self, long n):
+        cdef fmpz v
+        if fmpz_sgn(self.val) < 0:
+            raise ValueError("integer root of a negative number")
+        if n <= 0:
+            raise ValueError("n >= 1 is required")
+        v = fmpz()
+        fmpz_root(v.val, self.val, n)
+        return v
+

src/fmpz_mat.pyx

@@ -690,3 +690,18 @@ cdef class fmpz_mat(flint_mat):
             True
         """
         return bool(fmpz_mat_is_in_snf(self.val))
+
+    def charpoly(self):
+        cdef fmpz_poly u
+        u = fmpz_poly.__new__(fmpz_poly)
+        fmpz_poly_init(u.val)
+        fmpz_mat_charpoly(u.val, self.val)
+        return u
+
+    def minpoly(self):
+        cdef fmpz_poly u
+        u = fmpz_poly.__new__(fmpz_poly)
+        fmpz_poly_init(u.val)
+        fmpz_mat_minpoly(u.val, self.val)
+        return u
+