add tests for fmpq_series

Author: oscarbenjamin

.gitignore

@@ -14,3 +14,4 @@ MANIFEST
 .local
 *.egg-info
 .coverage
+*.swp

src/flint/fmpq_series.pyx

@@ -19,6 +19,13 @@ cdef fmpq_series_coerce_operands(x, y):
             return acb_series(x), acb_series(y)
     return NotImplemented, NotImplemented
 
+cdef any_as_fmpq_series(obj):
+    if typecheck(obj, fmpq_series):
+        return obj
+    if typecheck(obj, fmpz_series):
+        return fmpq_series(obj)
+    return NotImplemented
+
 cdef class fmpq_series(flint_series):
 
     cdef fmpq_poly_t val
@@ -41,7 +48,7 @@ cdef class fmpq_series(flint_series):
         if val is not None:
             if typecheck(val, fmpq_series):
                 fmpq_poly_set(self.val, (<fmpq_series>val).val)
-                self.prec = min((<fmpz_series>val).prec, getcap())
+                self.prec = min((<fmpq_series>val).prec, getcap())
             elif typecheck(val, fmpz_series):
                 fmpq_poly_set_fmpz_poly(self.val, (<fmpz_series>val).val)
                 self.prec = min((<fmpz_series>val).prec, getcap())
@@ -62,6 +69,23 @@ cdef class fmpq_series(flint_series):
                 raise ZeroDivisionError("cannot create fmpq_series with zero denominator")
             fmpq_poly_scalar_div_fmpz(self.val, self.val, (<fmpz>den).val)
 
+    def __richcmp__(s, t, int op):
+        cdef bint r
+        if op != 2 and op != 3:
+            raise TypeError("series cannot be ordered")
+        s = any_as_fmpq_series(s)
+        if t is NotImplemented:
+            return s
+        t = any_as_fmpq_series(t)
+        if t is NotImplemented:
+            return t
+        r = fmpq_poly_equal((<fmpq_series>s).val, (<fmpq_series>t).val)
+        if r:
+            r = (<fmpq_series>s).prec == (<fmpq_series>t).prec
+        if op == 3:
+            r = not r
+        return r
+
     def __len__(self):
         return fmpq_poly_length(self.val)
 
@@ -197,7 +221,7 @@ cdef class fmpq_series(flint_series):
             u = fmpq_series.__new__(fmpq_series)
 
             if fmpq_poly_is_zero((<fmpq_series>s).val):
-                u.cap = cap
+                (<fmpq_series>u).prec = cap
                 return u
 
             sval = (<fmpq_series>s).valuation()
@@ -236,6 +260,7 @@ cdef class fmpq_series(flint_series):
         return fmpq_series._div_(s, t)
 
     # generic exponentiation (fallback code)
+    # XXX: use fmpq_poly_pow_trunc instead?
     def __pow__(s, ulong exp, mod):
         if mod is not None:
             raise NotImplementedError("modular exponentiation")
@@ -308,7 +333,7 @@ cdef class fmpq_series(flint_series):
     cdef bint one_constant_term(s):
         if fmpq_poly_is_zero((<fmpq_series>s).val):
             return False
-        if fmpz_is_one(&((<fmpq_series>s).val.coeffs[0])):
+        if fmpz_equal(&((<fmpq_series>s).val.coeffs[0]), (<fmpq_series>s).val.den):
             return True
         return False
 

test/test.py

@@ -969,8 +969,178 @@ def set_bad(i):
     assert M3.minpoly() == flint.fmpq_poly([1,-4,4]) / 4
 
 def test_fmpq_series():
-    Z = flint.fmpq_series
-    Z([1,2])
+    Qp = flint.fmpq_poly
+    Q = flint.fmpq_series
+    Zp = flint.fmpz_poly
+    Z = flint.fmpz_series
+    ctx = flint.ctx
+    assert ctx.cap == 10
+    s1 = Q([1,2])
+    s2 = Q([1,2])
+    s3 = Q([1,1])
+    s4 = Q([1,2],1,11)
+    p1 = Qp([1,2])
+    sz1 = Z([1,2])
+    sz2 = Z([1,1])
+    sz3 = Z([1,1],11)
+    assert (s1 == s2) is True
+    assert (s1 != s2) is False
+    assert (s1 == s3) is False
+    assert (s1 != s3) is True
+    assert (s1 == s4) is False
+    assert (s1 != s4) is True
+    assert (s1 == p1) is False
+    assert (s1 != p1) is True
+    assert (s1 == sz1) is True
+    assert (s1 != sz1) is False
+    assert (s1 == sz2) is False
+    assert (s1 != sz2) is True
+    assert (s1 == sz3) is False
+    assert (s1 != sz3) is True
+    assert (Q([1]) == flint.fmpq(1)) is False
+    assert (Q([1]) != flint.fmpq(1)) is True
+    assert (Q([1]) == 1) is False
+    assert (Q([1]) != 1) is True
+    # XXX: These are invalid power series. Should they compare "equal"?
+    assert (Q([],-1) == Q([],-1)) is True
+    assert (Q([],-1) != Q([],-1)) is False
+    assert (Q([],-2) == Q([],-1)) is True
+    assert (Q([],-2) != Q([],-1)) is False
+    assert (Q([],-1) == Q([],-2)) is True
+    assert (Q([],-1) != Q([],-2)) is False
+    # XXX: this gives a core dump:
+    # s = Q([1,2])
+    # s[10**10] = 1
+    assert Q([]) == Q([0])
+    assert Q([1]) != Q([0])
+    assert Q(Q([1])) == Q([1])
+    assert Q(Qp([1])) == Q([1])
+    assert Q(Zp([1])) == Q([1])
+    assert Q(Z([1])) == Q([1])
+    assert Q(1) == Q([1])
+    assert Q([1],1) == Q([1])
+    assert Q([1],2) == Q([flint.fmpq(1,2)])
+    assert Q([1],1,10) != Q([1],1,11)
+    assert Q([1,2],3) == Q([flint.fmpq(1,3), flint.fmpq(2,3)])
+    assert raises(lambda: Q([1],[]), TypeError)
+    assert raises(lambda: Q([1],0), ZeroDivisionError)
+    assert raises(lambda: Q([1]) < Q([1]), TypeError)
+    assert len(Q([1,2])) == 2
+    assert Q([1,2]).length() == 2
+    s5 = Q([1,2])
+    assert s5[1] == 2
+    assert s5[2] == 0
+    assert s5[-1] == 0
+    # XXX: This goes beyond cap. Should it give an error?
+    assert s5[100] == 0
+    s5[2] = -1
+    assert s5[2] == -1
+    assert s5 == Q([1,2,-1])
+    def set_bad():
+        s5[-1] = 3
+    assert raises(set_bad, ValueError)
+    assert Q([1,2,0,4]).str() == "1 + 2*x + 4*x^3 + O(x^10)"
+    assert Q([1,2,0,4]).repr() == "fmpq_series([1, 2, 0, 4], 1, prec=10)"
+    assert Q([],1,0).str() == "O(x^0)"
+    assert Q([],1,-1).str() == "(invalid power series)"
+    assert +Q([1,2]) == Q([1,2])
+    assert -Q([1,2]) == Q([-1,-2])
+    assert Q([1,2]) + Q([3,4,5]) == Q([4,6,5])
+    assert Q([1,2]) + 1 == Q([2,2])
+    assert Q([1,2]) + Qp([3,4,5]) == Q([4,6,5])
+    assert 1 + Q([1,2]) == Q([2,2])
+    assert Qp([1,2]) + Q([3,4,5]) == Q([4,6,5])
+    assert raises(lambda: Q([1,2]) + [], TypeError)
+    assert raises(lambda: [] + Q([1,2]), TypeError)
+    assert Q([1,2]) - Q([3,5]) == Q([-2,-3])
+    assert Q([1,2]) - 1 == Q([0,2])
+    assert 1 - Q([1,2]) == Q([0,-2])
+    assert raises(lambda: [] - Q([1,2]), TypeError)
+    assert raises(lambda: Q([1,2]) - [], TypeError)
+    assert Q([1,2]) * Q([1,2]) == Q([1,4,4])
+    assert 2 * Q([1,2]) == Q([2,4])
+    assert Q([1,2]) * 2 == Q([2,4])
+    assert raises(lambda: [] * Q([1,2]), TypeError)
+    assert raises(lambda: Q([1,2]) * [], TypeError)
+    assert Q([1,2]).valuation() == 0
+    assert Q([0,2]).valuation() == 1
+    assert Q([0,0]).valuation() == -1
+    assert Q([1,1]) / Q([1,-1]) == Q([1,2,2,2,2,2,2,2,2,2])
+    assert raises(lambda: Q([1,1]) / Q([]), ZeroDivisionError)
+    assert Q([],1) / Q([1,-1]) == Q([],1)
+    # quotient would not be a power series
+    assert raises(lambda: Q([1,1]) / Q([0,1]), ValueError)
+    assert Q([1,1]) / Q([2,1]) == Q([512, 256, -128, 64, -32, 16, -8, 4, -2, 1], 1024)
+    assert Q([0,1,1]) / Q([0,1,-1]) == Q([1,2,2,2,2,2,2,2,2],1,9)
+    assert Q([2,4]) / 2 == Q([1,2])
+    assert Q([1,4]) / 2 == Q([1,4],2)
+    assert Q([1,1]) / -1 == Q([-1,-1])
+    assert raises(lambda: Q([1,1]) / [], TypeError)
+    assert raises(lambda: [] / Q([1,1]), TypeError)
+    q = Q([1,2],3)
+    assert q ** 0 == Q([1])
+    assert q ** 1 == q
+    assert q ** 2 == Q([1,4,4],9)
+    assert q ** 3 == Q([1,6,12,8],27)
+    assert q ** 4 == Q([1, 8, 24, 32, 16], 81)
+    assert Q([1,2]) ** 2 == Q([1,4,4])
+    assert Q([1,2]) ** 2 == Q([1,4,4])
+    assert raises(lambda: pow(Q([1,2]), 3, 5), NotImplementedError)
+    assert Q([1,2])(Q([0,1,2])) == Q([1,2,4])
+    assert raises(lambda: Q([1,2])(Q([1,2])), ValueError)
+    assert raises(lambda: Q([1,2])([]), TypeError)
+    coeffs = [0, 1, -2, 8, -40, 224, -1344, 8448, -54912, 366080]
+    assert Q([0,1,2]).reversion() == Q(coeffs)
+    # power series reversion must have valuation 1
+    assert raises(lambda: Q([1,1]).reversion(), ValueError)
+    assert Q([0,2,1]).reversion() == \
+        Q([0,32768,-8192,4096,-2560,1792,-1344,1056,-858,715],65536,10)
+    x = Q([0,1])
+    expx = x.exp()
+    assert expx == Q([362880,362880,181440,60480,15120,3024,504,72,9,1],362880)
+    assert expx.inv() == Q([362880,-362880,181440,-60480,15120,-3024,504,-72,9,-1], 362880)
+    assert expx.derivative() == Q([40320,40320,20160,6720,1680,336,56,8,1],40320,prec=9)
+    assert Q([1,1]).integral() == Q([0,2,1],2)
+    assert expx.sqrt() == \
+        Q([185794560,92897280,23224320,3870720,483840,48384,4032,288,18,1],185794560)
+    assert expx.rsqrt() == \
+        Q([185794560,-92897280,23224320,-3870720,483840,-48384,4032,-288,18,-1],185794560)
+    assert expx.log() == x
+    zero = Q()
+    one = Q([1])
+    assert zero.exp() == one
+    assert one.log() == zero
+    assert x.atan() == Q([0,315,0,-105,0,63,0,-45,0,35],315)
+    assert x.atanh() == Q([0,315,0,105,0,63,0,45,0,35],315)
+    assert x.asin() == Q([0,40320,0,6720,0,3024,0,1800,0,1225],40320)
+    assert x.asinh() == Q([0,40320,0,-6720,0,3024,0,-1800,0,1225],40320)
+    assert x.sin() == Q([0,362880,0,-60480,0,3024,0,-72,0,1],362880)
+    assert x.cos() == Q([40320,0,-20160,0,1680,0,-56,0,1],40320)
+    assert x.tan() == Q([0,2835,0,945,0,378,0,153,0,62],2835)
+    assert x.sinh() == Q([0,362880,0,60480,0,3024,0,72,0,1],362880)
+    assert x.cosh() == Q([40320,0,20160,0,1680,0,56,0,1],40320)
+    assert x.tanh() == Q([0,2835,0,-945,0,378,0,-153,0,62],2835)
+    # Constant term must be nonzero
+    assert raises(lambda: Q([0,1]).inv(), ValueError)
+    # Constant term must be 1
+    assert raises(lambda: Q([2,1]).sqrt(), ValueError)
+    assert raises(lambda: Q([2,1]).rsqrt(), ValueError)
+    assert raises(lambda: Q([2,1]).log(), ValueError)
+    assert raises(lambda: Q([]).sqrt(), ValueError)
+    assert raises(lambda: Q([]).rsqrt(), ValueError)
+    assert raises(lambda: Q([]).log(), ValueError)
+    # Constant term must be 0
+    assert raises(lambda: Q([1,1]).exp(), ValueError)
+    assert raises(lambda: Q([1,1]).atan(), ValueError)
+    assert raises(lambda: Q([1,1]).atanh(), ValueError)
+    assert raises(lambda: Q([1,1]).asin(), ValueError)
+    assert raises(lambda: Q([1,1]).asinh(), ValueError)
+    assert raises(lambda: Q([1,1]).sin(), ValueError)
+    assert raises(lambda: Q([1,1]).cos(), ValueError)
+    assert raises(lambda: Q([1,1]).tan(), ValueError)
+    assert raises(lambda: Q([1,1]).sinh(), ValueError)
+    assert raises(lambda: Q([1,1]).cosh(), ValueError)
+    assert raises(lambda: Q([1,1]).tanh(), ValueError)
 
 def test_nmod():
     G = flint.nmod