Question

我正在尝试让Sympy找到这个序列的极限

               ((-1)**(n))*(2**(-n))

使用PyCharm调试器和IPython控制台。

python模块是：

import numpy as np
from plotly.graph_objs import Scatter, Figure
from sympy import Symbol, srepr, limit_seq, oo
from sympy.abc import n

import plotly.plotly as py

py.sign_in('****', '****************')



sym_func = 1 + ((-1)**(n))*(2**(-n))

def rng_func(i):

    try:
        return 1 + np.power(-1, i)/(np.power(2,i))
    except ZeroDivisionError as e:
        raise ValueError('Invalid inputs') from e


class Sequence(object):

    def __init__(self, i):

        self.sum = 0
        self.dom = np.arange(1, i + 1, 1)
        self.rng = np.array([])
        self.is_positive = True
        self.is_alternating = True

        for i in self.dom:
            rng_val = rng_func(i)
            self.rng = np.append(self.rng, [rng_val])  
            self.sum += rng_val

        sign_array = np.sign(self.rng)

    for i in self.dom:

        if self.rng[i - 1] <= 0:
            self.is_positive = False
            break

    for i in self.dom:

        if sign_array[0] == -1:
            alt_sign = np.power(-1, i)
        else:
            alt_sign = np.power(-1, i-1)

        if alt_sign != sign_array[i-1]:
            self.is_alternating = False
            break


seq = Sequence(10)

data = [Scatter(x=seq.dom, y=seq.rng)]
fig = Figure(data=data)

py.image.save_as(fig, filename='plots/I3.png')

IPython控制台：

Connected to pydev debugger (build 171.4424.56)
Backend Qt5Agg is interactive backend. Turning interactive mode on.
import sys; print('Python %s on %s' % (sys.version, sys.platform))
Python 3.5.2 |Anaconda custom (64-bit)| (default, Jul  2 2016,    17:53:06) 
Type "copyright", "credits" or "license" for more information.
IPython 5.1.0 -- An enhanced Interactive Python.

In[1]: limit_seq(((-1)**(n))*(2**(-n)), n)
In[2]: limit_seq((1**(n))*(2**(-n)), n)
Out[3]: 
0

我的问题是为什么Sympy没有返回In [1]的限制值：但是对于In [2]：？差异是分子中的1对-1。在Sympy中创建交替符号有不同的方法吗？

Answer 1

截至目前（SymPy 1.1.1），limit_seq不支持振荡序列，例如(-1)**n的振荡序列。它的documentation以某种技术方式说明了这一点：

这些术语应该建立在不确定的n上的有理函数，无限总和和不确定的产品上。如果所有产品量词的范围都是渐近正的，则该术语是可以接受的。每个可接受的术语都是渐近单调的。

作为解决方法，您可以使用：

def mylimit_seq(seq, n):
    n_ = Dummy("n", integer=True, positive=True)
    L1 = limit_seq(seq.subs(n, 2*n_), n_)
    L2 = limit_seq(seq.subs(n, 2*n_ + 1), n_)
    if L1 == L2:
        return L1

然后mylimit_seq((-1)**n * 2**(-n), n)返回0.

在将来的版本中，limit_seq将适用于此类序列。您也可以通过从GitHub克隆SymPy来获得此功能。

Answer 2

我将系列分为偶数项和奇数项，我反映了包含关于x轴的奇数项的系列。这个系列成为：（1）*（2 **（ - n）），然后与包含偶数项的系列相同。

计算限制的函数保持不变：

def mylimit_seq(seq, n):

    try:
        L1 = limit_seq(seq.subs(n, 2*n), n)
        L2 = limit_seq(seq.subs(n, 2*n + 1), n)
    except:
        return np.NaN

    if L1 == L2:
        return L1
    else:
        return np.NaN

使用Sympy，计算其术语交替符号的序列限制

2 个答案: