Misc fixes

diofant/calculus/order.py

@@ -120,7 +120,7 @@ def __new__(cls, expr, var=None, point=0, **kwargs):
             x = var
 
         if expr.is_Add:
-            lst = expr.extract_leading_order([x])
+            lst = expr._extract_leading_order([x])
             expr = Add(*[f.expr for (e, f) in lst])
 
         elif expr:

diofant/core/add.py

@@ -575,20 +575,7 @@ def getO(self):
             return self._new_rawargs(*args)
 
     @cacheit
-    def extract_leading_order(self, symbols):
-        """Returns the leading term and its order.
-
-        Examples
-        ========
-
-        >>> (x + 1 + 1/x**5).extract_leading_order(x)
-        ((x**(-5), O(x**(-5))),)
-        >>> (1 + x).extract_leading_order(x)
-        ((1, O(1, x)),)
-        >>> (x + x**2).extract_leading_order(x)
-        ((x, O(x)),)
-
-        """
+    def _extract_leading_order(self, symbols):
         from ..calculus import Order
         lst = []
         symbols = list(symbols if is_sequence(symbols) else [symbols])
@@ -650,7 +637,7 @@ def _eval_as_leading_term(self, x):
 
         if not expr.is_Add:
             return expr
-        plain = expr.func(*[s for s, _ in expr.extract_leading_order(x)])
+        plain = expr.func(*[s for s, _ in expr._extract_leading_order(x)])
         rv = factor_terms(plain, fraction=False)
         rv_simplify = rv.simplify()
         # if it simplifies to an x-free expression, return that;

diofant/core/expr.py

@@ -2397,14 +2397,14 @@
             return rv.subs({xpos: x})
 
         if n is not None:  # nseries handling
-            s1 = self._eval_nseries(x, n=n, logx=logx)
+            s1 = self._eval_nseries(x, n, logx)
             cur_order = s1.getO() or Integer(0)
 
             # Now make sure the requested order is returned
             target_order = Order(x**n, x)
             ndo = n + 1
             while not target_order.contains(cur_order):
-                s1 = self._eval_nseries(x, n=ndo, logx=logx)
+                s1 = self._eval_nseries(x, ndo, logx)
                 ndo += 1
                 cur_order = s1.getO() or Integer(0)
 
@@ -2467,7 +2467,7 @@
         # override this method and implement much more efficient yielding of
         # terms.
         n = 0
-        series = self._eval_nseries(x, n=n, logx=logx)
+        series = self._eval_nseries(x, n, logx)
         if not series.is_Order:
             if series.is_Add:
                 yield series.removeO()
@@ -2477,13 +2477,13 @@
 
         while series.is_Order:
             n += 1
-            series = self._eval_nseries(x, n=n, logx=logx)
+            series = self._eval_nseries(x, n, logx)
         e = series.removeO()
         yield e
         while 1:
             while 1:
                 n += 1
-                series = self._eval_nseries(x, n=n, logx=logx).removeO()
+                series = self._eval_nseries(x, n, logx).removeO()
                 if e != series:
                     break
             yield series - e
@@ -2559,9 +2559,9 @@
 
         """
         from ..simplify import collect
         from .symbol import Dummy
         if x.is_positive and x.is_finite:
-            series = self._eval_nseries(x, n=n, logx=logx)
+            series = self._eval_nseries(x, n, logx)
             order = series.getO() or Integer(0)
             return collect(series.removeO(), x) + order
         p = Dummy('x', positive=True, finite=True)

diofant/core/function.py

@@ -1216,10 +1216,6 @@ def _subset(a, b):
 
         return Derivative(*(x._subs(old, new) for x in self.args))
 
-    def _eval_lseries(self, x, logx=None):
-        for term in self.expr.series(x, n=None, logx=logx):
-            yield self.func(term, *self.variables)
-
     def _eval_nseries(self, x, n, logx):
         arg = self.expr.nseries(x, n, logx)
         o = arg.getO()
@@ -1498,7 +1494,7 @@ def _eval_derivative(self, s):
                    *[p.diff(s)*self.func(self.expr.diff(v), *self.args[1:]).doit()
                      for v, p in zip(self.variables, self.point)])
 
-    def _eval_nseries(self, x, n, logx=None):
+    def _eval_nseries(self, x, n, logx):
         if x in self.point:
             v = self.variables[self.point.index(x)]
         else:

diofant/functions/elementary/complexes.py

@@ -492,7 +492,7 @@ def _eval_power(self, other):
 
     def _eval_nseries(self, x, n, logx):
         direction = self.args[0].as_leading_term(x).as_coeff_exponent(x)[0]
-        s = self.args[0]._eval_nseries(x, n=n, logx=logx)
+        s = self.args[0]._eval_nseries(x, n, logx)
         when, lim = Eq(direction, 0), direction.limit(x, 0)
         if lim.equals(0) is False:
             return s/sign(lim)

diofant/functions/elementary/exponential.py

@@ -504,4 +504,4 @@ def _eval_nseries(self, x, n, logx):
                 l += Add(*[Integer(-k)**(k - 1)*x**k/factorial(k)
                            for k in range(1, n)])
             return l + o
-        return super()._eval_nseries(x, n=n, logx=logx)
+        return super()._eval_nseries(x, n, logx)

diofant/functions/elementary/trigonometric.py

@@ -899,8 +899,8 @@ def taylor_term(n, x, *previous_terms):
     def _eval_nseries(self, x, n, logx):
         i = self.args[0].limit(x, 0)*2/pi
         if i and i.is_Integer:
-            return self.rewrite(cos)._eval_nseries(x, n=n, logx=logx)
-        return Function._eval_nseries(self, x, n=n, logx=logx)
+            return self.rewrite(cos)._eval_nseries(x, n, logx)
+        return Function._eval_nseries(self, x, n, logx)
 
     def _eval_rewrite_as_Pow(self, arg):
         if isinstance(arg, log):

diofant/functions/special/elliptic_integrals.py

@@ -71,7 +71,7 @@ def _eval_conjugate(self):
 
     def _eval_nseries(self, x, n, logx):
         from ...simplify import hyperexpand
-        return hyperexpand(self.rewrite(hyper)._eval_nseries(x, n=n, logx=logx))
+        return hyperexpand(self.rewrite(hyper)._eval_nseries(x, n, logx))
 
     def _eval_rewrite_as_hyper(self, m):
         return (pi/2)*hyper((Rational(1, 2), Rational(1, 2)), (1,), m)
@@ -233,8 +233,8 @@ def _eval_conjugate(self):
     def _eval_nseries(self, x, n, logx):
         from ...simplify import hyperexpand
         if len(self.args) == 1:
-            return hyperexpand(self.rewrite(hyper)._eval_nseries(x, n=n, logx=logx))
-        return super()._eval_nseries(x, n=n, logx=logx)
+            return hyperexpand(self.rewrite(hyper)._eval_nseries(x, n, logx))
+        return super()._eval_nseries(x, n, logx)
 
     def _eval_rewrite_as_hyper(self, *args):
         if len(args) == 1:

diofant/functions/special/gamma_functions.py

@@ -840,7 +840,7 @@ def _eval_expand_func(self, **hints):
 
         return self
 
-    def _eval_nseries(self, x, n, logx=None):
+    def _eval_nseries(self, x, n, logx):
         x0 = self.args[0].limit(x, 0)
         if x0 == 0:
             f = self._eval_rewrite_as_intractable(*self.args)

diofant/tests/calculus/test_lseries.py

@@ -40,7 +40,7 @@ def test_simple():
     assert list(x.series(n=None)) == [x]
     assert list(Integer(1).series(x, n=None)) == [1]
     assert not next((x/(x + y)).series(y, n=None)).has(O)
-    assert [t.doit() for t in Derivative(1 + x, x).series(x, n=None)] == [0, 1]
+    assert [t.doit() for t in Derivative(1 + x, x).series(x, n=None)] == [1]
 
     # issue sympy/sympy#5183
     s = (x + 1/x).series(n=None)

diofant/tests/calculus/test_order.py

@@ -150,19 +150,19 @@ def test_sympyissue_3468():
 
 
 def test_leading_order():
-    assert (x + 1 + 1/x**5).extract_leading_order(x) == ((1/x**5, O(1/x**5)),)
-    assert (1 + 1/x).extract_leading_order(x) == ((1/x, O(1/x)),)
-    assert (1 + x).extract_leading_order(x) == ((1, O(1, x)),)
-    assert (1 + x**2).extract_leading_order(x) == ((1, O(1, x)),)
-    assert (2 + x**2).extract_leading_order(x) == ((2, O(1, x)),)
-    assert (x + x**2).extract_leading_order(x) == ((x, O(x)),)
+    assert (x + 1 + 1/x**5)._extract_leading_order(x) == ((1/x**5, O(1/x**5)),)
+    assert (1 + 1/x)._extract_leading_order(x) == ((1/x, O(1/x)),)
+    assert (1 + x)._extract_leading_order(x) == ((1, O(1, x)),)
+    assert (1 + x**2)._extract_leading_order(x) == ((1, O(1, x)),)
+    assert (2 + x**2)._extract_leading_order(x) == ((2, O(1, x)),)
+    assert (x + x**2)._extract_leading_order(x) == ((x, O(x)),)
 
 
 def test_leading_order2():
-    assert set((2 + pi + x**2).extract_leading_order(x)) == {(pi, O(1, x)),
-                                                             (2, O(1, x))}
-    assert set((2*x + pi*x + x**2).extract_leading_order(x)) == {(2*x, O(x)),
-                                                                 (x*pi, O(x))}
+    assert set((2 + pi + x**2)._extract_leading_order(x)) == {(pi, O(1, x)),
+                                                              (2, O(1, x))}
+    assert set((2*x + pi*x + x**2)._extract_leading_order(x)) == {(2*x, O(x)),
+                                                                  (x*pi, O(x))}
 
 
 def test_order_leadterm():

diofant/tests/functions/test_gamma_functions.py

@@ -399,7 +399,7 @@ def test_loggamma():
     assert loggamma(w).is_extended_real is None
 
     def tN(N, M):
-        assert loggamma(1/x)._eval_nseries(x, n=N).getn() == M
+        assert loggamma(1/x)._eval_nseries(x, N, None).getn() == M
     tN(0, -1)
     tN(1, +1)
     tN(2, +3)

docs/release/notes-0.14.rst

@@ -31,6 +31,7 @@ Compatibility breaks
 * Removed ``diofant.plotting`` module, see :pull:`1284`.
 * Removed unused ``prefixes``, ``postfixes``, ``capture`` and ``variations`` functions, see :pull:`1282` and :pull:`1290`.
 * Drop support for multivariate :class:`~diofant.calculus.order.Order` notion, see :pull:`1296`.
+* Removed ``Add.extract_leading_order`` method, see :pull:`1292`.
 
 Minor changes
 =============