more additions

Author: fredrik-johansson

src/acb.pyx

@@ -184,6 +184,10 @@ cdef class acb(flint_scalar):
         other = any_as_acb(other)
         return bool(acb_contains(self.val, (<acb>other).val))
 
+    def contains_interior(self, other):
+        other = any_as_acb(other)
+        return bool(acb_contains_interior(self.val, (<acb>other).val))
+
     def overlaps(self, other):
         other = any_as_acb(other)
         return bool(acb_overlaps((<acb>self).val, (<acb>other).val))

src/arb.pyx

@@ -491,6 +491,10 @@ cdef class arb(flint_scalar):
         other = any_as_arb(other)
         return bool(arb_contains(self.val, (<arb>other).val))
 
+    def contains_interior(self, other):
+        other = any_as_arb(other)
+        return bool(arb_contains_interior(self.val, (<arb>other).val))
+
     def overlaps(self, other):
         other = any_as_arb(other)
         return bool(arb_overlaps((<arb>self).val, (<arb>other).val))

src/dirichlet.pyx

@@ -31,6 +31,9 @@ cdef class dirichlet_group(object):
     def q(self):
         return fmpz(self.val.q)
 
+    def exponent(self):
+        return fmpz(self.val.expo)
+
     def __repr__(self):
         return "Dirichlet group mod q = %s" % self.q
 
@@ -95,6 +98,9 @@ cdef class dirichlet_char(object):
         assert 1 <= l <= max(q,2)-1 and n_gcd(q, l) == 1
         dirichlet_char_log(self.val, self.G.val, l)
 
+    def group(self):
+        return self.G
+
     def index(self):
         return dirichlet_index_char(self.G.val, self.val)
 
@@ -143,6 +149,17 @@ cdef class dirichlet_char(object):
         acb_dirichlet_chi((<acb>v).val, self.G.val, self.val, fmpz_get_ui(m.val), getprec())
         return v
 
+    def chi_exponent(self, n):
+        cdef fmpz m
+        cdef ulong v
+        m = fmpz(n) % self.G.q
+        expo = self.G.exponent()
+        v = dirichlet_chi(self.G.val, self.val, fmpz_get_ui(m.val))
+        if v == DIRICHLET_CHI_NULL:
+            return None
+        else:
+            return fmpz(v)
+
     def l(self, s):
         """
         Evaluates the Dirichlet L-function of this character at the given

src/flint.pxd

@@ -273,6 +273,7 @@ cdef extern from "flint/fmpz.h":
     void fmpz_rfac_ui(fmpz_t r, const fmpz_t x, ulong n)
     void fmpz_rfac_uiui(fmpz_t r, ulong x, ulong n)
     void fmpz_primorial(fmpz_t res, ulong n)
+    int fmpz_is_perfect_power(fmpz_t root, const fmpz_t f)
 
 cdef extern from "flint/fmpz_factor.h":
     ctypedef struct fmpz_factor_struct:
@@ -285,6 +286,10 @@ cdef extern from "flint/fmpz_factor.h":
     void fmpz_factor_init(fmpz_factor_t factor)
     void fmpz_factor_clear(fmpz_factor_t factor)
     void fmpz_factor(fmpz_factor_t factor, fmpz_t n)
+    int fmpz_factor_trial_range(fmpz_factor_t factor, const fmpz_t n, ulong start, ulong num_primes)
+    void fmpz_factor_expand(fmpz_t n, const fmpz_factor_t factor)
+    void _fmpz_factor_append(fmpz_factor_t factor, const fmpz_t p, ulong exp)
+
 
 cdef extern from "flint/fmpz_poly.h":
     ctypedef struct fmpz_poly_struct:
@@ -945,6 +950,7 @@ cdef extern from "arb.h":
     int arb_contains_si(const arb_t x, long y)
     int arb_overlaps(const arb_t x, const arb_t y)
     int arb_contains(const arb_t x, const arb_t y)
+    int arb_contains_interior(const arb_t x, const arb_t y)
     void arb_get_interval_fmpz_2exp(fmpz_t a, fmpz_t b, fmpz_t exp, const arb_t x)
     int arb_get_unique_fmpz(fmpz_t z, const arb_t x)
     void arb_get_fmpz_mid_rad_10exp(fmpz_t mid, fmpz_t rad, fmpz_t exp, const arb_t x, long n)
@@ -1182,6 +1188,7 @@ cdef extern from "acb.h":
     int acb_contains_fmpq(const acb_t x, const fmpq_t y)
     int acb_contains_fmpz(const acb_t x, const fmpz_t y)
     int acb_contains(const acb_t x, const acb_t y)
+    int acb_contains_interior(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)

src/fmpq.pyx

@@ -302,3 +302,21 @@ cdef class fmpq(flint_scalar):
         else:
             return max(b1, b2)
 
+    def __pow__(self, n, z):
+        cdef fmpq v
+        cdef long e
+        assert z is None
+        e = n
+        if type(self) is fmpq:
+            v = fmpq.__new__(fmpq)
+            if e >= 0:
+                fmpz_pow_ui(fmpq_numref(v.val), fmpq_numref((<fmpq>self).val), e)
+                fmpz_pow_ui(fmpq_denref(v.val), fmpq_denref((<fmpq>self).val), e)
+            else:
+                if fmpq_is_zero((<fmpq>self).val):
+                    raise ZeroDivisionError
+                fmpz_pow_ui(fmpq_denref(v.val), fmpq_numref((<fmpq>self).val), -e)
+                fmpz_pow_ui(fmpq_numref(v.val), fmpq_denref((<fmpq>self).val), -e)
+            return v
+        return NotImplemented
+

src/fmpq_mat.pyx

@@ -432,3 +432,26 @@ cdef class fmpq_mat(flint_mat):
         fmpq_mat_minpoly(u.val, self.val)
         return u
 
+    def __pow__(self, n, z):
+        cdef fmpq_mat v
+        assert z is None
+        n = int(n)
+        if n == 0:
+            r, c = self.nrows(), self.ncols()
+            assert r == c
+            v = fmpq_mat(r, c)
+            fmpq_mat_one(v.val)
+            return v
+        if n == 1:
+            return self
+        if n == 2:
+            return self * self
+        if n < 0:
+            return self.inv() ** (-n)
+        v = self ** (n // 2)
+        v = v * v
+        if n % 2:
+            v *= self
+        return v
+
+

src/fmpz.pyx

@@ -316,9 +316,9 @@ cdef class fmpz(flint_scalar):
             fmpz_clear(tval)
         return u
 
-    def factor(self):
+    def factor(self, trial_limit=None):
         """
-        Factors self into pseudoprimes, returning a list of
+        Factors self into prime numbers, returning a list of
         (prime, exp) pairs. The sign is ignored.
 
             >>> fmpz(5040).factor()
@@ -330,11 +330,33 @@ cdef class fmpz(flint_scalar):
 
         Warning: factoring large integers can be slow unless all
         prime factors are small.
+
+        If *trial_limit* is set, perform trial division with at most
+        this many primes, returning an incomplete factorization in which
+        the largest factor may be composite. Factors largers than the trial
+        division limit may still be found if it is cheap to do so, but no
+        expensive algorithms will be run.
+
+            >>> fmpz(2**128+10).factor()
+            [(2, 1), (7, 1), (23, 1), (677, 1), (2957, 1), (1042733, 1), (506256324715258822390969, 1)]
+            >>> fmpz(2**128+10).factor(trial_limit=200)
+            [(2, 1), (7, 1), (23, 1), (677, 1), (1560971251139657345905734136865089, 1)]
         """
         cdef fmpz_factor_t fac
+        cdef fmpz_t tmp
         cdef int i
         fmpz_factor_init(fac)
-        fmpz_factor(fac, self.val)
+        if trial_limit is not None:
+            fmpz_factor_trial_range(fac, self.val, 0, trial_limit)
+            fmpz_init(tmp)
+            fmpz_factor_expand(tmp, fac)
+            fmpz_divexact(tmp, self.val, tmp)
+            fmpz_abs(tmp, tmp)
+            if not fmpz_is_one(tmp):
+                _fmpz_factor_append(fac, tmp, 1)
+            fmpz_clear(tmp)
+        else:
+            fmpz_factor(fac, self.val)
         res = [0] * fac.num
         for 0 <= i < fac.num:
             u = fmpz.__new__(fmpz)
@@ -344,6 +366,12 @@ cdef class fmpz(flint_scalar):
         fmpz_factor_clear(fac)
         return res
 
+    def is_perfect_power(self):
+        cdef int k
+        cdef fmpz v = fmpz()
+        k = fmpz_is_perfect_power(v.val, self.val)
+        return k != 0
+
     def partitions_p(n):
         r"""
         Returns `p(n)`, the number of partitions of `n`, as an *fmpz*.