def _dirichlet_test(g_n):
try:
ing_val = limit(Sum(g_n, (sym, interval.inf, m)).doit(), m, S.Infinity)
if ing_val.is_finite:
return S.true
except NotImplementedError:
pass
def test_limit2():
assert limit(x**x, x, 0, dir="+") == 1
assert limit((exp(x)-1)/x, x, 0) == 1
assert limit(1+1/x,x,oo) == 1
assert limit(-exp(1/x),x,oo) == -1
assert limit(x+exp(-x),x,oo) == oo
assert limit(x+exp(-x**2),x,oo) == oo
assert limit(x+exp(-exp(x)),x,oo) == oo
assert limit(13+1/x-exp(-x),x,oo) == 13
def _bounded_convergent_test(g1_n, g2_n):
try:
lim_val = limit(g1_n, sym, upper_limit)
if lim_val.is_finite or (isinstance(lim_val, AccumulationBounds)
and (lim_val.max - lim_val.min).is_finite):
if Sum(g2_n, (sym, lower_limit, upper_limit)).is_absolutely_convergent():
return S.true
except NotImplementedError:
pass
def test_limits():
k, x = symbols('k, x')
assert hyper((1,), (S(4)/3, S(5)/3), k**2).series(k) == \
hyper((1,), (S(4)/3, S(5)/3), 0) + \
9*k**2*hyper((2,), (S(7)/3, S(8)/3), 0)/20 + \
81*k**4*hyper((3,), (S(10)/3, S(11)/3), 0)/1120 + \
O(k**6) # issue 6350
assert limit(meijerg((), (), (1,), (0,), -x), x, 0) == \
meijerg(((), ()), ((1,), (0,)), 0) # issue 6052
def test_issue_4503():
dx = Symbol('dx')
assert limit((sqrt(1 + exp(x + dx)) - sqrt(1 + exp(x)))/dx, dx, 0) == \
exp(x)/(2*sqrt(exp(x) + 1))
def test_issue_6364():
a = Symbol('a')
e = z/(1 - sqrt(1 + z)*sin(a)**2 - sqrt(1 - z)*cos(a)**2)
assert limit(e, z, 0) == 1/(cos(a)**2 - S.Half)
def test_issue_7088():
a = Symbol('a')
assert limit(sqrt(x/(x + a)), x, oo) == 1
def test_issue_6366():
n = Symbol('n', integer=True, positive=True)
r = (n + 1)*x**(n + 1)/(x**(n + 1) - 1) - x/(x - 1)
assert limit(r, x, 1).cancel() == n/2
def test_rational():
assert limit(1/y - (1/(y + x) + x/(y + x)/y)/z, x, oo) == (z - 1)/(y*z)
assert limit(1/y - (1/(y + x) + x/(y + x)/y)/z, x, -oo) == (z - 1)/(y*z)
def test_issue_5436():
raises(NotImplementedError, lambda: limit(exp(x*y), x, oo))
raises(NotImplementedError, lambda: limit(exp(-x*y), x, oo))
def test_extended_real_line():
assert limit(x - oo, x, oo) == Limit(x - oo, x, oo)
assert limit(1/(x + sin(x)) - oo, x, 0) == Limit(1/(x + sin(x)) - oo, x, 0)
assert limit(oo/x, x, oo) == Limit(oo/x, x, oo)
assert limit(x - oo + 1/x, x, oo) == Limit(x - oo + 1/x, x, oo)
def test_issue_4090():
assert limit(1/(x + 3), x, 2) == Rational(1, 5)
assert limit(1/(x + pi), x, 2) == S.One/(2 + pi)
assert limit(log(x)/(x**2 + 3), x, 2) == log(2)/7
assert limit(log(x)/(x**2 + pi), x, 2) == log(2)/(4 + pi)
def test_issue_3792():
assert limit((1 - cos(x))/x**2, x, S.Half) == 4 - 4*cos(S.Half)
assert limit(sin(sin(x + 1) + 1), x, 0) == sin(1 + sin(1))
assert limit(abs(sin(x + 1) + 1), x, 0) == 1 + sin(1)
def test_issue_2929():
assert limit((x * exp(x))/(exp(x) - 1), x, -oo) == 0
def test_basic1():
assert limit(x, x, oo) is oo
assert limit(x, x, -oo) is -oo
assert limit(-x, x, oo) is -oo
assert limit(x**2, x, -oo) is oo
assert limit(-x**2, x, oo) is -oo
assert limit(x*log(x), x, 0, dir="+") == 0
assert limit(1/x, x, oo) == 0
assert limit(exp(x), x, oo) is oo
assert limit(-exp(x), x, oo) is -oo
assert limit(exp(x)/x, x, oo) is oo
assert limit(1/x - exp(-x), x, oo) == 0
assert limit(x + 1/x, x, oo) is oo
assert limit(x - x**2, x, oo) is -oo
assert limit((1 + x)**(1 + sqrt(2)), x, 0) == 1
assert limit((1 + x)**oo, x, 0) == Limit((x + 1)**oo, x, 0)
assert limit((1 + x)**oo, x, 0, dir='-') == Limit((x + 1)**oo, x, 0, dir='-')
assert limit((1 + x + y)**oo, x, 0, dir='-') == Limit((1 + x + y)**oo, x, 0, dir='-')
assert limit(y/x/log(x), x, 0) == -oo*sign(y)
assert limit(cos(x + y)/x, x, 0) == sign(cos(y))*oo
assert limit(gamma(1/x + 3), x, oo) == 2
assert limit(S.NaN, x, -oo) is S.NaN
assert limit(Order(2)*x, x, S.NaN) is S.NaN
assert limit(1/(x - 1), x, 1, dir="+") is oo
assert limit(1/(x - 1), x, 1, dir="-") is -oo
assert limit(1/(5 - x)**3, x, 5, dir="+") is -oo
assert limit(1/(5 - x)**3, x, 5, dir="-") is oo
assert limit(1/sin(x), x, pi, dir="+") is -oo
assert limit(1/sin(x), x, pi, dir="-") is oo
assert limit(1/cos(x), x, pi/2, dir="+") is -oo
assert limit(1/cos(x), x, pi/2, dir="-") is oo
assert limit(1/tan(x**3), x, (2*pi)**Rational(1, 3), dir="+") is oo
assert limit(1/tan(x**3), x, (2*pi)**Rational(1, 3), dir="-") is -oo
assert limit(1/cot(x)**3, x, (pi*Rational(3, 2)), dir="+") is -oo
assert limit(1/cot(x)**3, x, (pi*Rational(3, 2)), dir="-") is oo
assert limit(tan(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
assert limit(cot(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
assert limit(sec(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
assert limit(csc(x), x, oo) == AccumBounds(S.NegativeInfinity, S.Infinity)
# test bi-directional limits
assert limit(sin(x)/x, x, 0, dir="+-") == 1
assert limit(x**2, x, 0, dir="+-") == 0
assert limit(1/x**2, x, 0, dir="+-") is oo
# test failing bi-directional limits
assert limit(1/x, x, 0, dir="+-") is zoo
# approaching 0
# from dir="+"
assert limit(1 + 1/x, x, 0) is oo
# from dir='-'
# Add
assert limit(1 + 1/x, x, 0, dir='-') is -oo
# Pow
assert limit(x**(-2), x, 0, dir='-') is oo
assert limit(x**(-3), x, 0, dir='-') is -oo
assert limit(1/sqrt(x), x, 0, dir='-') == (-oo)*I
assert limit(x**2, x, 0, dir='-') == 0
assert limit(sqrt(x), x, 0, dir='-') == 0
assert limit(x**-pi, x, 0, dir='-') == oo/(-1)**pi
assert limit((1 + cos(x))**oo, x, 0) == Limit((cos(x) + 1)**oo, x, 0)
# test pull request 22491
assert limit(1/asin(x), x, 0, dir = '+') == oo
assert limit(1/asin(x), x, 0, dir = '-') == -oo
assert limit(1/sinh(x), x, 0, dir = '+') == oo
assert limit(1/sinh(x), x, 0, dir = '-') == -oo
assert limit(log(1/x) + 1/sin(x), x, 0, dir = '+') == oo
assert limit(log(1/x) + 1/x, x, 0, dir = '+') == oo
def test_exponential2():
n = Symbol('n')
assert limit((1 + x/(n + sin(n)))**n, n, oo) == exp(x)
def test_issue_3871():
z = Symbol("z", positive=True)
f = -1/z*exp(-z*x)
assert limit(f, x, oo) == 0
assert f.limit(x, oo) == 0
def test_limit4():
#issue 364
assert limit((3**x+5**x)**(1/x), x, oo) == 5
#issue 364
assert limit((3**(1/x)+5**(1/x))**x, x, 0) == 5
def test_issue_8229():
assert limit((x**Rational(1, 4) - 2)/(sqrt(x) - 4)**Rational(2, 3), x, 16) == 0
def test_limit3():
a = Symbol('a')
assert limit(x-log(1+exp(x)), x, oo) == 0
assert limit(x-log(a+exp(x)), x, oo) == 0
assert limit(exp(x)/(1+exp(x)), x, oo) == 1
assert limit(exp(x)/(a+exp(x)), x, oo) == 1
def test_issue_4547():
assert limit(cot(x), x, 0, dir='+') is oo
assert limit(cot(x), x, pi/2, dir='+') == 0
def test_order_oo():
x = Symbol('x', positive=True)
assert Order(x)*oo != Order(1, x)
assert limit(oo/(x**2 - 4), x, oo) is oo
def test_issue_5164():
assert limit(x**0.5, x, oo) == oo**0.5 is oo
assert limit(x**0.5, x, 16) == S(16)**0.5
assert limit(x**0.5, x, 0) == 0
assert limit(x**(-0.5), x, oo) == 0
assert limit(x**(-0.5), x, 4) == S(4)**(-0.5)
def test_polynomial():
assert limit((x + 1)**1000/((x + 1)**1000 + 1), x, oo) == 1
assert limit((x + 1)**1000/((x + 1)**1000 + 1), x, -oo) == 1
def test_issue_5383():
func = (1.0 * 1 + 1.0 * x)**(1.0 * 1 / x)
assert limit(func, x, 0) == E
def test_issue_5740():
assert limit(log(x)*z - log(2*x)*y, x, 0) == oo*sign(y - z)
def test_issue_14793():
expr = ((x + S(1)/2) * log(x) - x + log(2*pi)/2 - \
log(factorial(x)) + S(1)/(12*x))*x**3
assert limit(expr, x, oo) == S(1)/360
def test_issue_6560():
e = (5*x**3/4 - x*Rational(3, 4) + (y*(3*x**2/2 - S.Half) +
35*x**4/8 - 15*x**2/4 + Rational(3, 8))/(2*(y + 1)))
assert limit(e, y, oo) == 5*x**3/4 + 3*x**2/4 - 3*x/4 - Rational(1, 4)
def test_issue_5229():
assert limit((1 + y)**(1/y) - S.Exp1, y, 0) == 0
def test_branch_cuts():
assert limit(asin(I*x + 2), x, 0) == pi - asin(2)
assert limit(asin(I*x + 2), x, 0, '-') == asin(2)
assert limit(asin(I*x - 2), x, 0) == -asin(2)
assert limit(asin(I*x - 2), x, 0, '-') == -pi + asin(2)
assert limit(acos(I*x + 2), x, 0) == -acos(2)
assert limit(acos(I*x + 2), x, 0, '-') == acos(2)
assert limit(acos(I*x - 2), x, 0) == acos(-2)
assert limit(acos(I*x - 2), x, 0, '-') == 2*pi - acos(-2)
assert limit(atan(x + 2*I), x, 0) == I*atanh(2)
assert limit(atan(x + 2*I), x, 0, '-') == -pi + I*atanh(2)
assert limit(atan(x - 2*I), x, 0) == pi - I*atanh(2)
assert limit(atan(x - 2*I), x, 0, '-') == -I*atanh(2)
assert limit(atan(1/x), x, 0) == pi/2
assert limit(atan(1/x), x, 0, '-') == -pi/2
assert limit(atan(x), x, oo) == pi/2
assert limit(atan(x), x, -oo) == -pi/2
assert limit(acot(x + S(1)/2*I), x, 0) == pi - I*acoth(S(1)/2)
assert limit(acot(x + S(1)/2*I), x, 0, '-') == -I*acoth(S(1)/2)
assert limit(acot(x - S(1)/2*I), x, 0) == I*acoth(S(1)/2)
assert limit(acot(x - S(1)/2*I), x, 0, '-') == -pi + I*acoth(S(1)/2)
assert limit(acot(x), x, 0) == pi/2
assert limit(acot(x), x, 0, '-') == -pi/2
assert limit(asec(I*x + S(1)/2), x, 0) == asec(S(1)/2)
assert limit(asec(I*x + S(1)/2), x, 0, '-') == -asec(S(1)/2)
assert limit(asec(I*x - S(1)/2), x, 0) == 2*pi - asec(-S(1)/2)
assert limit(asec(I*x - S(1)/2), x, 0, '-') == asec(-S(1)/2)
assert limit(acsc(I*x + S(1)/2), x, 0) == acsc(S(1)/2)
assert limit(acsc(I*x + S(1)/2), x, 0, '-') == pi - acsc(S(1)/2)
assert limit(acsc(I*x - S(1)/2), x, 0) == -pi + acsc(S(1)/2)
assert limit(acsc(I*x - S(1)/2), x, 0, '-') == -acsc(S(1)/2)
assert limit(log(I*x - 1), x, 0) == I*pi
assert limit(log(I*x - 1), x, 0, '-') == -I*pi
assert limit(log(-I*x - 1), x, 0) == -I*pi
assert limit(log(-I*x - 1), x, 0, '-') == I*pi
assert limit(sqrt(I*x - 1), x, 0) == I
assert limit(sqrt(I*x - 1), x, 0, '-') == -I
assert limit(sqrt(-I*x - 1), x, 0) == -I
assert limit(sqrt(-I*x - 1), x, 0, '-') == I
assert limit(cbrt(I*x - 1), x, 0) == (-1)**(S(1)/3)
assert limit(cbrt(I*x - 1), x, 0, '-') == -(-1)**(S(2)/3)
assert limit(cbrt(-I*x - 1), x, 0) == -(-1)**(S(2)/3)
assert limit(cbrt(-I*x - 1), x, 0, '-') == (-1)**(S(1)/3)
def test_issue_3934():
assert limit((1 + x**log(3))**(1/x), x, 0) == 1
assert limit((5**(1/x) + 3**(1/x))**x, x, 0) == 5
def test_issue_4099():
a = Symbol('a')
assert limit(a/x, x, 0) == oo*sign(a)
assert limit(-a/x, x, 0) == -oo*sign(a)
assert limit(-a*x, x, oo) == -oo*sign(a)
assert limit(a*x, x, oo) == oo*sign(a)
def is_convergent(self):
r"""Checks for the convergence of a Sum.
We divide the study of convergence of infinite sums and products in
two parts.
First Part:
One part is the question whether all the terms are well defined, i.e.,
they are finite in a sum and also non-zero in a product. Zero
is the analogy of (minus) infinity in products as
:math:`e^{-\infty} = 0`.
Second Part:
The second part is the question of convergence after infinities,
and zeros in products, have been omitted assuming that their number
is finite. This means that we only consider the tail of the sum or
product, starting from some point after which all terms are well
defined.
For example, in a sum of the form:
.. math::
\sum_{1 \leq i < \infty} \frac{1}{n^2 + an + b}
where a and b are numbers. The routine will return true, even if there
are infinities in the term sequence (at most two). An analogous
product would be:
.. math::
\prod_{1 \leq i < \infty} e^{\frac{1}{n^2 + an + b}}
This is how convergence is interpreted. It is concerned with what
happens at the limit. Finding the bad terms is another independent
matter.
Note: It is responsibility of user to see that the sum or product
is well defined.
There are various tests employed to check the convergence like
divergence test, root test, integral test, alternating series test,
comparison tests, Dirichlet tests. It returns true if Sum is convergent
and false if divergent and NotImplementedError if it can not be checked.
References
==========
.. [1] https://en.wikipedia.org/wiki/Convergence_tests
Examples
========
>>> from sympy import factorial, S, Sum, Symbol, oo
>>> n = Symbol('n', integer=True)
>>> Sum(n/(n - 1), (n, 4, 7)).is_convergent()
True
>>> Sum(n/(2*n + 1), (n, 1, oo)).is_convergent()
False
>>> Sum(factorial(n)/5**n, (n, 1, oo)).is_convergent()
False
>>> Sum(1/n**(S(6)/5), (n, 1, oo)).is_convergent()
True
See Also
========
Sum.is_absolutely_convergent()
Product.is_convergent()
"""
from sympy import Interval, Integral, Limit, log, symbols, Ge, Gt, simplify
p, q = symbols('p q', cls=Wild)
sym = self.limits[0][0]
lower_limit = self.limits[0][1]
upper_limit = self.limits[0][2]
sequence_term = self.function
if len(sequence_term.free_symbols) > 1:
raise NotImplementedError("convergence checking for more than one symbol "
"containing series is not handled")
if lower_limit.is_finite and upper_limit.is_finite:
return S.true
# transform sym -> -sym and swap the upper_limit = S.Infinity
# and lower_limit = - upper_limit
if lower_limit is S.NegativeInfinity:
if upper_limit is S.Infinity:
return Sum(sequence_term, (sym, 0, S.Infinity)).is_convergent() and \
Sum(sequence_term, (sym, S.NegativeInfinity, 0)).is_convergent()
sequence_term = simplify(sequence_term.xreplace({sym: -sym}))
lower_limit = -upper_limit
upper_limit = S.Infinity
sym_ = Dummy(sym.name, integer=True, positive=True)
sequence_term = sequence_term.xreplace({sym: sym_})
sym = sym_
interval = Interval(lower_limit, upper_limit)
# Piecewise function handle
if sequence_term.is_Piecewise:
for func, cond in sequence_term.args:
# see if it represents something going to oo
if cond == True or cond.as_set().sup is S.Infinity:
s = Sum(func, (sym, lower_limit, upper_limit))
return s.is_convergent()
return S.true
### -------- Divergence test ----------- ###
try:
lim_val = limit(sequence_term, sym, upper_limit)
if lim_val.is_number and lim_val is not S.Zero:
return S.false
except NotImplementedError:
pass
try:
lim_val_abs = limit(abs(sequence_term), sym, upper_limit)
if lim_val_abs.is_number and lim_val_abs is not S.Zero:
return S.false
except NotImplementedError:
pass
order = O(sequence_term, (sym, S.Infinity))
### ----------- ratio test ---------------- ###
next_sequence_term = sequence_term.xreplace({sym: sym + 1})
ratio = combsimp(powsimp(next_sequence_term/sequence_term))
lim_ratio = limit(ratio, sym, upper_limit)
if lim_ratio.is_number:
if abs(lim_ratio) > 1:
return S.false
if abs(lim_ratio) < 1:
return S.true
### --------- p-series test (1/n**p) ---------- ###
p1_series_test = order.expr.match(sym**p)
if p1_series_test is not None:
if p1_series_test[p] < -1:
return S.true
if p1_series_test[p] >= -1:
return S.false
p2_series_test = order.expr.match((1/sym)**p)
if p2_series_test is not None:
if p2_series_test[p] > 1:
return S.true
if p2_series_test[p] <= 1:
return S.false
### ------------- Limit comparison test -----------###
# (1/n) comparison
try:
lim_comp = limit(sym*sequence_term, sym, S.Infinity)
if lim_comp.is_number and lim_comp > 0:
return S.false
except NotImplementedError:
pass
### ----------- root test ---------------- ###
lim = Limit(abs(sequence_term)**(1/sym), sym, S.Infinity)
lim_evaluated = lim.doit()
if lim_evaluated.is_number:
if lim_evaluated < 1:
return S.true
if lim_evaluated > 1:
return S.false
### ------------- alternating series test ----------- ###
dict_val = sequence_term.match((-1)**(sym + p)*q)
if not dict_val[p].has(sym) and is_decreasing(dict_val[q], interval):
return S.true
### ------------- comparison test ------------- ###
# (1/log(n)**p) comparison
log_test = order.expr.match(1/(log(sym)**p))
if log_test is not None:
return S.false
# (1/(n*log(n)**p)) comparison
log_n_test = order.expr.match(1/(sym*(log(sym))**p))
if log_n_test is not None:
if log_n_test[p] > 1:
return S.true
return S.false
# (1/(n*log(n)*log(log(n))*p)) comparison
log_log_n_test = order.expr.match(1/(sym*(log(sym)*log(log(sym))**p)))
if log_log_n_test is not None:
if log_log_n_test[p] > 1:
return S.true
return S.false
# (1/(n**p*log(n))) comparison
n_log_test = order.expr.match(1/(sym**p*log(sym)))
if n_log_test is not None:
if n_log_test[p] > 1:
return S.true
return S.false
### ------------- integral test -------------- ###
maxima = solveset(sequence_term.diff(sym), sym, interval)
if not maxima:
check_interval = interval
elif isinstance(maxima, FiniteSet) and maxima.sup.is_number:
check_interval = Interval(maxima.sup, interval.sup)
if (
is_decreasing(sequence_term, check_interval) or
is_decreasing(-sequence_term, check_interval)):
integral_val = Integral(
sequence_term, (sym, lower_limit, upper_limit))
try:
integral_val_evaluated = integral_val.doit()
if integral_val_evaluated.is_number:
return S(integral_val_evaluated.is_finite)
except NotImplementedError:
pass
### -------------- Dirichlet tests -------------- ###
if order.expr.is_Mul:
a_n, b_n = order.expr.args[0], order.expr.args[1]
m = Dummy('m', integer=True)
def _dirichlet_test(g_n):
try:
ing_val = limit(Sum(g_n, (sym, interval.inf, m)).doit(), m, S.Infinity)
if ing_val.is_finite:
return S.true
except NotImplementedError:
pass
if is_decreasing(a_n, interval):
dirich1 = _dirichlet_test(b_n)
if dirich1 is not None:
return dirich1
if is_decreasing(b_n, interval):
dirich2 = _dirichlet_test(a_n)
if dirich2 is not None:
return dirich2
_sym = self.limits[0][0]
sequence_term = sequence_term.xreplace({sym: _sym})
raise NotImplementedError("The algorithm to find the Sum convergence of %s "
"is not yet implemented" % (sequence_term))
def test_issue_8208():
assert limit(n**(Rational(1, 1e9) - 1), n, oo) == 0
def _limit_inf(expr, n):
try:
return limit(expr, n, S.Infinity)
except (NotImplementedError, PoleError):
return None
def test_calculate_series():
# needs gruntz calculate_series to go to n = 32
assert limit(x**Rational(77, 3)/(1 + x**Rational(77, 3)), x, oo) == 1
# needs gruntz calculate_series to go to n = 128
assert limit(x**101.1/(1 + x**101.1), x, oo) == 1
def test_limit1():
assert limit(x, x, oo) == oo
assert limit(x, x, -oo) == -oo
assert limit(-x, x, oo) == -oo
assert limit(x**2, x, -oo) == oo
assert limit(-x**2, x, oo) == -oo
assert limit(x*log(x), x, 0, dir="+") == 0
assert limit(1/x,x,oo) == 0
assert limit(exp(x),x,oo) == oo
assert limit(-exp(x),x,oo) == -oo
assert limit(exp(x)/x,x,oo) == oo
assert limit(1/x-exp(-x),x,oo) == 0
assert limit(x+1/x,x,oo) == oo
def limit(self, x, xlim, dir='+'):
""" Compute limit x->xlim.
"""
from sympy.series.limits import limit
return TupleArg(*[limit(f, x, xlim, dir) for f in self.args])
def test_issue_5955():
assert limit((x**16)/(1 + x**16), x, oo) == 1
assert limit((x**100)/(1 + x**100), x, oo) == 1
assert limit((x**1885)/(1 + x**1885), x, oo) == 1
assert limit((x**1000/((x + 1)**1000 + exp(-x))), x, oo) == 1
def test_newissue():
assert limit(exp(1/sin(x))/exp(cot(x)), x, 0) == 1
def is_convergent(self):
"""
Convergence tests are used for checking the convergence of
a series. There are various tests employed to check the convergence,
returns true if convergent and false if divergent and NotImplementedError
if can not be checked. Like divergence test, root test, integral test,
alternating series test, comparison tests, Dirichlet tests.
References
==========
.. [1] https://en.wikipedia.org/wiki/Convergence_tests
Examples
========
>>> from sympy import Interval, factorial, S, Sum, Symbol, oo
>>> n = Symbol('n', integer=True)
>>> Sum(n/(n - 1), (n, 4, 7)).is_convergent()
True
>>> Sum(n/(2*n + 1), (n, 1, oo)).is_convergent()
False
>>> Sum(factorial(n)/5**n, (n, 1, oo)).is_convergent()
False
>>> Sum(1/n**(S(6)/5), (n, 1, oo)).is_convergent()
True
See Also
========
Sum.is_absolute_convergent()
"""
from sympy import Interval, Integral, Limit, log, symbols, Ge, Gt, simplify
p, q = symbols('p q', cls=Wild)
sym = self.limits[0][0]
lower_limit = self.limits[0][1]
upper_limit = self.limits[0][2]
sequence_term = self.function
if len(sequence_term.free_symbols) > 1:
raise NotImplementedError("convergence checking for more that one symbol \
containing series is not handled")
if lower_limit.is_finite and upper_limit.is_finite:
return S.true
# transform sym -> -sym and swap the upper_limit = S.Infinity and lower_limit = - upper_limit
if lower_limit is S.NegativeInfinity:
if upper_limit is S.Infinity:
return Sum(sequence_term, (sym, 0, S.Infinity)).is_convergent() and \
Sum(sequence_term, (sym, S.NegativeInfinity, 0)).is_convergent()
sequence_term = simplify(sequence_term.xreplace({sym: -sym}))
lower_limit = -upper_limit
upper_limit = S.Infinity
interval = Interval(lower_limit, upper_limit)
# Piecewise function handle
if sequence_term.is_Piecewise:
for func_cond in sequence_term.args:
if func_cond[1].func is Ge or func_cond[1].func is Gt or func_cond[1] == True:
return Sum(func_cond[0], (sym, lower_limit, upper_limit)).is_convergent()
return S.true
### -------- Divergence test ----------- ###
try:
lim_val = limit(abs(sequence_term), sym, upper_limit)
if lim_val.is_number and lim_val != S.Zero:
return S.false
except NotImplementedError:
pass
order = O(sequence_term, (sym, S.Infinity))
### --------- p-series test (1/n**p) ---------- ###
p1_series_test = order.expr.match(sym**p)
if p1_series_test is not None:
if p1_series_test[p] < -1:
return S.true
if p1_series_test[p] > -1:
return S.false
p2_series_test = order.expr.match((1/sym)**p)
if p2_series_test is not None:
if p2_series_test[p] > 1:
return S.true
if p2_series_test[p] < 1:
return S.false
### ----------- root test ---------------- ###
lim = Limit(abs(sequence_term)**(1/sym), sym, S.Infinity)
lim_evaluated = lim.doit()
if lim_evaluated.is_number:
if lim_evaluated < 1:
return S.true
if lim_evaluated > 1:
return S.false
### ------------- alternating series test ----------- ###
d = symbols('d', cls=Dummy)
dict_val = sequence_term.match((-1)**(sym + p)*q)
if not dict_val[p].has(sym) and is_decreasing(dict_val[q], interval):
return S.true
### ------------- comparison test ------------- ###
# (1/log(n)**p) comparison
log_test = order.expr.match(1/(log(sym)**p))
if log_test is not None:
return S.false
# (1/(n*log(n)**p)) comparison
log_n_test = order.expr.match(1/(sym*(log(sym))**p))
if log_n_test is not None:
if log_n_test[p] > 1:
return S.true
return S.false
# (1/(n*log(n)*log(log(n))*p)) comparison
log_log_n_test = order.expr.match(1/(sym*(log(sym)*log(log(sym))**p)))
if log_log_n_test is not None:
if log_log_n_test[p] > 1:
return S.true
return S.false
# (1/(n**p*log(n))) comparison
n_log_test = order.expr.match(1/(sym**p*log(sym)))
if n_log_test is not None:
if n_log_test[p] > 1:
return S.true
return S.false
### ------------- integral test -------------- ###
if is_decreasing(sequence_term, interval):
integral_val = Integral(sequence_term, (sym, lower_limit, upper_limit))
try:
integral_val_evaluated = integral_val.doit()
if integral_val_evaluated.is_number:
return S(integral_val_evaluated.is_finite)
except NotImplementedError:
pass
### -------------- Dirichlet tests -------------- ###
if order.expr.is_Mul:
a_n, b_n = order.expr.args[0], order.expr.args[1]
m = Dummy('m', integer=True)
def _dirichlet_test(g_n):
try:
ing_val = limit(Sum(g_n, (sym, interval.inf, m)).doit(), m, S.Infinity)
if ing_val.is_finite:
return S.true
except NotImplementedError:
pass
if is_decreasing(a_n, interval):
dirich1 = _dirichlet_test(b_n)
if dirich1 is not None:
return dirich1
if is_decreasing(b_n, interval):
dirich2 = _dirichlet_test(a_n)
if dirich2 is not None:
return dirich2
raise NotImplementedError("The algorithm to find the convergence of %s "
"is not yet implemented" % (sequence_term))
