new wrappers

Author: fredrik-johansson

src/acb.pyx

@@ -585,7 +585,10 @@ cdef class acb(flint_scalar):
             acb_agm1((<acb>u).val, (<acb>s).val, getprec())
             return u
         else:
-            return (s / t).agm() * t
+            t = acb(t)
+            u = acb.__new__(acb)
+            acb_agm((<acb>u).val, (<acb>s).val, (<acb>t).val, getprec())
+            return u
 
     def gamma(s):
         """

src/flint.pxd

@@ -279,6 +279,16 @@ cdef class fmpq(flint_scalar):
         fmpq_harmonic_ui(v.val, n)
         return v
 
+    @staticmethod
+    def dedekind_sum(n, k):
+        cdef fmpz nv, kv
+        cdef fmpq v
+        nv = fmpz(n)
+        kv = fmpz(k)
+        v = fmpq()
+        fmpq_dedekind_sum(v.val, nv.val, kv.val)
+        return v
+
     def floor(self):
         cdef fmpz r = fmpz.__new__(fmpz)
         fmpz_fdiv_q(r.val, fmpq_numref(self.val), fmpq_denref(self.val))

src/fmpq.pyx

@@ -298,6 +298,17 @@ cdef class fmpq_poly(flint_poly):
         fmpq_poly_gcd(res.val, self.val, (<fmpq_poly>other).val)
         return res
 
+    def xgcd(self, other):
+        cdef fmpq_poly res1, res2, res3
+        other = any_as_fmpq_poly(other)
+        if other is NotImplemented:
+            raise TypeError("cannot convert input to fmpq_poly")
+        res1 = fmpq_poly.__new__(fmpq_poly)
+        res2 = fmpq_poly.__new__(fmpq_poly)
+        res3 = fmpq_poly.__new__(fmpq_poly)
+        fmpq_poly_xgcd(res1.val, res2.val, res3.val, self.val, (<fmpq_poly>other).val)
+        return (res1, res2, res3)
+
     def factor(self):
         """
         Factors *self* into irreducible polynomials. Returns (*c*, *factors*)

src/fmpq_poly.pyx

@@ -316,6 +316,24 @@ cdef class fmpz(flint_scalar):
             fmpz_clear(tval)
         return u
 
+    def lcm(self, other):
+        """
+        Returns the greatest common divisor of self and other.
+
+            >>> fmpz(30).gcd(45)
+            15
+        """
+        cdef fmpz_struct tval[1]
+        cdef int ttype = FMPZ_UNKNOWN
+        ttype = fmpz_set_any_ref(tval, other)
+        if ttype == FMPZ_UNKNOWN:
+            raise TypeError("input must be an integer")
+        u = fmpz.__new__(fmpz)
+        fmpz_lcm((<fmpz>u).val, self.val, tval)
+        if ttype == FMPZ_TMP:
+            fmpz_clear(tval)
+        return u
+
     def factor(self, trial_limit=None):
         """
         Factors self into prime numbers, returning a list of
@@ -366,6 +384,26 @@ cdef class fmpz(flint_scalar):
         fmpz_factor_clear(fac)
         return res
 
+    def factor_smooth(self, bits=15, int proved=-1):
+        cdef fmpz_factor_t fac
+        cdef int i
+        fmpz_factor_init(fac)
+        fmpz_factor_smooth(fac, self.val, bits, proved)
+        res = [0] * fac.num
+        for 0 <= i < fac.num:
+            u = fmpz.__new__(fmpz)
+            fmpz_set((<fmpz>u).val, &fac.p[i])
+            exp = <long> fac.exp[i]
+            res[i] = (u, exp)
+        fmpz_factor_clear(fac)
+        return res
+
+    def is_prime(self):
+        return fmpz_is_prime(self.val)
+
+    def is_probable_prime(self):
+        return fmpz_is_probabprime(self.val)
+
     def is_perfect_power(self):
         cdef int k
         cdef fmpz v = fmpz()
@@ -563,6 +601,15 @@ cdef class fmpz(flint_scalar):
         fmpz_sqrtrem(u.val, v.val, self.val)
         return u, v
 
+    # warning: m should be prime!
+    def sqrtmod(self, m):
+        cdef fmpz v
+        v = fmpz()
+        m = fmpz(m)
+        if not fmpz_sqrtmod(v.val, self.val, (<fmpz>m).val):
+            raise ValueError("unable to compute modular square root")
+        return v
+
     def root(self, long n):
         cdef fmpz v
         if fmpz_sgn(self.val) < 0:
@@ -573,3 +620,15 @@ cdef class fmpz(flint_scalar):
         fmpz_root(v.val, self.val, n)
         return v
 
+    def jacobi(self, other):
+        cdef fmpz_struct tval[1]
+        cdef int ttype = FMPZ_UNKNOWN
+        ttype = fmpz_set_any_ref(tval, other)
+        if ttype == FMPZ_UNKNOWN:
+            raise TypeError("input must be an integer")
+        u = fmpz.__new__(fmpz)
+        v = fmpz_jacobi(self.val, tval)
+        if ttype == FMPZ_TMP:
+            fmpz_clear(tval)
+        return fmpz(v)
+