chore: 添加虚拟环境到仓库
- 添加 backend_service/venv 虚拟环境 - 包含所有Python依赖包 - 注意：虚拟环境约393MB，包含12655个文件
This commit is contained in:
@@ -0,0 +1,499 @@
|
||||
from sympy.concrete import Sum
|
||||
from sympy.concrete.delta import deltaproduct as dp, deltasummation as ds, _extract_delta
|
||||
from sympy.core import Eq, S, symbols, oo
|
||||
from sympy.functions import KroneckerDelta as KD, Piecewise, piecewise_fold
|
||||
from sympy.logic import And
|
||||
from sympy.testing.pytest import raises
|
||||
|
||||
i, j, k, l, m = symbols("i j k l m", integer=True, finite=True)
|
||||
x, y = symbols("x y", commutative=False)
|
||||
|
||||
|
||||
def test_deltaproduct_trivial():
|
||||
assert dp(x, (j, 1, 0)) == 1
|
||||
assert dp(x, (j, 1, 3)) == x**3
|
||||
assert dp(x + y, (j, 1, 3)) == (x + y)**3
|
||||
assert dp(x*y, (j, 1, 3)) == (x*y)**3
|
||||
assert dp(KD(i, j), (k, 1, 3)) == KD(i, j)
|
||||
assert dp(x*KD(i, j), (k, 1, 3)) == x**3*KD(i, j)
|
||||
assert dp(x*y*KD(i, j), (k, 1, 3)) == (x*y)**3*KD(i, j)
|
||||
|
||||
|
||||
def test_deltaproduct_basic():
|
||||
assert dp(KD(i, j), (j, 1, 3)) == 0
|
||||
assert dp(KD(i, j), (j, 1, 1)) == KD(i, 1)
|
||||
assert dp(KD(i, j), (j, 2, 2)) == KD(i, 2)
|
||||
assert dp(KD(i, j), (j, 3, 3)) == KD(i, 3)
|
||||
assert dp(KD(i, j), (j, 1, k)) == KD(i, 1)*KD(k, 1) + KD(k, 0)
|
||||
assert dp(KD(i, j), (j, k, 3)) == KD(i, 3)*KD(k, 3) + KD(k, 4)
|
||||
assert dp(KD(i, j), (j, k, l)) == KD(i, l)*KD(k, l) + KD(k, l + 1)
|
||||
|
||||
|
||||
def test_deltaproduct_mul_x_kd():
|
||||
assert dp(x*KD(i, j), (j, 1, 3)) == 0
|
||||
assert dp(x*KD(i, j), (j, 1, 1)) == x*KD(i, 1)
|
||||
assert dp(x*KD(i, j), (j, 2, 2)) == x*KD(i, 2)
|
||||
assert dp(x*KD(i, j), (j, 3, 3)) == x*KD(i, 3)
|
||||
assert dp(x*KD(i, j), (j, 1, k)) == x*KD(i, 1)*KD(k, 1) + KD(k, 0)
|
||||
assert dp(x*KD(i, j), (j, k, 3)) == x*KD(i, 3)*KD(k, 3) + KD(k, 4)
|
||||
assert dp(x*KD(i, j), (j, k, l)) == x*KD(i, l)*KD(k, l) + KD(k, l + 1)
|
||||
|
||||
|
||||
def test_deltaproduct_mul_add_x_y_kd():
|
||||
assert dp((x + y)*KD(i, j), (j, 1, 3)) == 0
|
||||
assert dp((x + y)*KD(i, j), (j, 1, 1)) == (x + y)*KD(i, 1)
|
||||
assert dp((x + y)*KD(i, j), (j, 2, 2)) == (x + y)*KD(i, 2)
|
||||
assert dp((x + y)*KD(i, j), (j, 3, 3)) == (x + y)*KD(i, 3)
|
||||
assert dp((x + y)*KD(i, j), (j, 1, k)) == \
|
||||
(x + y)*KD(i, 1)*KD(k, 1) + KD(k, 0)
|
||||
assert dp((x + y)*KD(i, j), (j, k, 3)) == \
|
||||
(x + y)*KD(i, 3)*KD(k, 3) + KD(k, 4)
|
||||
assert dp((x + y)*KD(i, j), (j, k, l)) == \
|
||||
(x + y)*KD(i, l)*KD(k, l) + KD(k, l + 1)
|
||||
|
||||
|
||||
def test_deltaproduct_add_kd_kd():
|
||||
assert dp(KD(i, k) + KD(j, k), (k, 1, 3)) == 0
|
||||
assert dp(KD(i, k) + KD(j, k), (k, 1, 1)) == KD(i, 1) + KD(j, 1)
|
||||
assert dp(KD(i, k) + KD(j, k), (k, 2, 2)) == KD(i, 2) + KD(j, 2)
|
||||
assert dp(KD(i, k) + KD(j, k), (k, 3, 3)) == KD(i, 3) + KD(j, 3)
|
||||
assert dp(KD(i, k) + KD(j, k), (k, 1, l)) == KD(l, 0) + \
|
||||
KD(i, 1)*KD(l, 1) + KD(j, 1)*KD(l, 1) + \
|
||||
KD(i, 1)*KD(j, 2)*KD(l, 2) + KD(j, 1)*KD(i, 2)*KD(l, 2)
|
||||
assert dp(KD(i, k) + KD(j, k), (k, l, 3)) == KD(l, 4) + \
|
||||
KD(i, 3)*KD(l, 3) + KD(j, 3)*KD(l, 3) + \
|
||||
KD(i, 2)*KD(j, 3)*KD(l, 2) + KD(i, 3)*KD(j, 2)*KD(l, 2)
|
||||
assert dp(KD(i, k) + KD(j, k), (k, l, m)) == KD(l, m + 1) + \
|
||||
KD(i, m)*KD(l, m) + KD(j, m)*KD(l, m) + \
|
||||
KD(i, m)*KD(j, m - 1)*KD(l, m - 1) + KD(i, m - 1)*KD(j, m)*KD(l, m - 1)
|
||||
|
||||
|
||||
def test_deltaproduct_mul_x_add_kd_kd():
|
||||
assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, 3)) == 0
|
||||
assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, 1)) == x*(KD(i, 1) + KD(j, 1))
|
||||
assert dp(x*(KD(i, k) + KD(j, k)), (k, 2, 2)) == x*(KD(i, 2) + KD(j, 2))
|
||||
assert dp(x*(KD(i, k) + KD(j, k)), (k, 3, 3)) == x*(KD(i, 3) + KD(j, 3))
|
||||
assert dp(x*(KD(i, k) + KD(j, k)), (k, 1, l)) == KD(l, 0) + \
|
||||
x*KD(i, 1)*KD(l, 1) + x*KD(j, 1)*KD(l, 1) + \
|
||||
x**2*KD(i, 1)*KD(j, 2)*KD(l, 2) + x**2*KD(j, 1)*KD(i, 2)*KD(l, 2)
|
||||
assert dp(x*(KD(i, k) + KD(j, k)), (k, l, 3)) == KD(l, 4) + \
|
||||
x*KD(i, 3)*KD(l, 3) + x*KD(j, 3)*KD(l, 3) + \
|
||||
x**2*KD(i, 2)*KD(j, 3)*KD(l, 2) + x**2*KD(i, 3)*KD(j, 2)*KD(l, 2)
|
||||
assert dp(x*(KD(i, k) + KD(j, k)), (k, l, m)) == KD(l, m + 1) + \
|
||||
x*KD(i, m)*KD(l, m) + x*KD(j, m)*KD(l, m) + \
|
||||
x**2*KD(i, m - 1)*KD(j, m)*KD(l, m - 1) + \
|
||||
x**2*KD(i, m)*KD(j, m - 1)*KD(l, m - 1)
|
||||
|
||||
|
||||
def test_deltaproduct_mul_add_x_y_add_kd_kd():
|
||||
assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 3)) == 0
|
||||
assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 1)) == \
|
||||
(x + y)*(KD(i, 1) + KD(j, 1))
|
||||
assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 2, 2)) == \
|
||||
(x + y)*(KD(i, 2) + KD(j, 2))
|
||||
assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 3, 3)) == \
|
||||
(x + y)*(KD(i, 3) + KD(j, 3))
|
||||
assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, 1, l)) == KD(l, 0) + \
|
||||
(x + y)*KD(i, 1)*KD(l, 1) + (x + y)*KD(j, 1)*KD(l, 1) + \
|
||||
(x + y)**2*KD(i, 1)*KD(j, 2)*KD(l, 2) + \
|
||||
(x + y)**2*KD(j, 1)*KD(i, 2)*KD(l, 2)
|
||||
assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, l, 3)) == KD(l, 4) + \
|
||||
(x + y)*KD(i, 3)*KD(l, 3) + (x + y)*KD(j, 3)*KD(l, 3) + \
|
||||
(x + y)**2*KD(i, 2)*KD(j, 3)*KD(l, 2) + \
|
||||
(x + y)**2*KD(i, 3)*KD(j, 2)*KD(l, 2)
|
||||
assert dp((x + y)*(KD(i, k) + KD(j, k)), (k, l, m)) == KD(l, m + 1) + \
|
||||
(x + y)*KD(i, m)*KD(l, m) + (x + y)*KD(j, m)*KD(l, m) + \
|
||||
(x + y)**2*KD(i, m - 1)*KD(j, m)*KD(l, m - 1) + \
|
||||
(x + y)**2*KD(i, m)*KD(j, m - 1)*KD(l, m - 1)
|
||||
|
||||
|
||||
def test_deltaproduct_add_mul_x_y_mul_x_kd():
|
||||
assert dp(x*y + x*KD(i, j), (j, 1, 3)) == (x*y)**3 + \
|
||||
x*(x*y)**2*KD(i, 1) + (x*y)*x*(x*y)*KD(i, 2) + (x*y)**2*x*KD(i, 3)
|
||||
assert dp(x*y + x*KD(i, j), (j, 1, 1)) == x*y + x*KD(i, 1)
|
||||
assert dp(x*y + x*KD(i, j), (j, 2, 2)) == x*y + x*KD(i, 2)
|
||||
assert dp(x*y + x*KD(i, j), (j, 3, 3)) == x*y + x*KD(i, 3)
|
||||
assert dp(x*y + x*KD(i, j), (j, 1, k)) == \
|
||||
(x*y)**k + Piecewise(
|
||||
((x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
|
||||
(0, True)
|
||||
)
|
||||
assert dp(x*y + x*KD(i, j), (j, k, 3)) == \
|
||||
(x*y)**(-k + 4) + Piecewise(
|
||||
((x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
|
||||
(0, True)
|
||||
)
|
||||
assert dp(x*y + x*KD(i, j), (j, k, l)) == \
|
||||
(x*y)**(-k + l + 1) + Piecewise(
|
||||
((x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
|
||||
(0, True)
|
||||
)
|
||||
|
||||
|
||||
def test_deltaproduct_mul_x_add_y_kd():
|
||||
assert dp(x*(y + KD(i, j)), (j, 1, 3)) == (x*y)**3 + \
|
||||
x*(x*y)**2*KD(i, 1) + (x*y)*x*(x*y)*KD(i, 2) + (x*y)**2*x*KD(i, 3)
|
||||
assert dp(x*(y + KD(i, j)), (j, 1, 1)) == x*(y + KD(i, 1))
|
||||
assert dp(x*(y + KD(i, j)), (j, 2, 2)) == x*(y + KD(i, 2))
|
||||
assert dp(x*(y + KD(i, j)), (j, 3, 3)) == x*(y + KD(i, 3))
|
||||
assert dp(x*(y + KD(i, j)), (j, 1, k)) == \
|
||||
(x*y)**k + Piecewise(
|
||||
((x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
|
||||
(0, True)
|
||||
).expand()
|
||||
assert dp(x*(y + KD(i, j)), (j, k, 3)) == \
|
||||
((x*y)**(-k + 4) + Piecewise(
|
||||
((x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
|
||||
(0, True)
|
||||
)).expand()
|
||||
assert dp(x*(y + KD(i, j)), (j, k, l)) == \
|
||||
((x*y)**(-k + l + 1) + Piecewise(
|
||||
((x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
|
||||
(0, True)
|
||||
)).expand()
|
||||
|
||||
|
||||
def test_deltaproduct_mul_x_add_y_twokd():
|
||||
assert dp(x*(y + 2*KD(i, j)), (j, 1, 3)) == (x*y)**3 + \
|
||||
2*x*(x*y)**2*KD(i, 1) + 2*x*y*x*x*y*KD(i, 2) + 2*(x*y)**2*x*KD(i, 3)
|
||||
assert dp(x*(y + 2*KD(i, j)), (j, 1, 1)) == x*(y + 2*KD(i, 1))
|
||||
assert dp(x*(y + 2*KD(i, j)), (j, 2, 2)) == x*(y + 2*KD(i, 2))
|
||||
assert dp(x*(y + 2*KD(i, j)), (j, 3, 3)) == x*(y + 2*KD(i, 3))
|
||||
assert dp(x*(y + 2*KD(i, j)), (j, 1, k)) == \
|
||||
(x*y)**k + Piecewise(
|
||||
(2*(x*y)**(i - 1)*x*(x*y)**(k - i), And(1 <= i, i <= k)),
|
||||
(0, True)
|
||||
).expand()
|
||||
assert dp(x*(y + 2*KD(i, j)), (j, k, 3)) == \
|
||||
((x*y)**(-k + 4) + Piecewise(
|
||||
(2*(x*y)**(i - k)*x*(x*y)**(3 - i), And(k <= i, i <= 3)),
|
||||
(0, True)
|
||||
)).expand()
|
||||
assert dp(x*(y + 2*KD(i, j)), (j, k, l)) == \
|
||||
((x*y)**(-k + l + 1) + Piecewise(
|
||||
(2*(x*y)**(i - k)*x*(x*y)**(l - i), And(k <= i, i <= l)),
|
||||
(0, True)
|
||||
)).expand()
|
||||
|
||||
|
||||
def test_deltaproduct_mul_add_x_y_add_y_kd():
|
||||
assert dp((x + y)*(y + KD(i, j)), (j, 1, 3)) == ((x + y)*y)**3 + \
|
||||
(x + y)*((x + y)*y)**2*KD(i, 1) + \
|
||||
(x + y)*y*(x + y)**2*y*KD(i, 2) + \
|
||||
((x + y)*y)**2*(x + y)*KD(i, 3)
|
||||
assert dp((x + y)*(y + KD(i, j)), (j, 1, 1)) == (x + y)*(y + KD(i, 1))
|
||||
assert dp((x + y)*(y + KD(i, j)), (j, 2, 2)) == (x + y)*(y + KD(i, 2))
|
||||
assert dp((x + y)*(y + KD(i, j)), (j, 3, 3)) == (x + y)*(y + KD(i, 3))
|
||||
assert dp((x + y)*(y + KD(i, j)), (j, 1, k)) == \
|
||||
((x + y)*y)**k + Piecewise(
|
||||
(((x + y)*y)**(-1)*((x + y)*y)**i*(x + y)*((x + y)*y
|
||||
)**k*((x + y)*y)**(-i), (i >= 1) & (i <= k)), (0, True))
|
||||
assert dp((x + y)*(y + KD(i, j)), (j, k, 3)) == (
|
||||
(x + y)*y)**4*((x + y)*y)**(-k) + Piecewise((((x + y)*y)**i*(
|
||||
(x + y)*y)**(-k)*(x + y)*((x + y)*y)**3*((x + y)*y)**(-i),
|
||||
(i >= k) & (i <= 3)), (0, True))
|
||||
assert dp((x + y)*(y + KD(i, j)), (j, k, l)) == \
|
||||
(x + y)*y*((x + y)*y)**l*((x + y)*y)**(-k) + Piecewise(
|
||||
(((x + y)*y)**i*((x + y)*y)**(-k)*(x + y)*((x + y)*y
|
||||
)**l*((x + y)*y)**(-i), (i >= k) & (i <= l)), (0, True))
|
||||
|
||||
|
||||
def test_deltaproduct_mul_add_x_kd_add_y_kd():
|
||||
assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, 3)) == \
|
||||
KD(i, 1)*(KD(i, k) + x)*((KD(i, k) + x)*y)**2 + \
|
||||
KD(i, 2)*(KD(i, k) + x)*y*(KD(i, k) + x)**2*y + \
|
||||
KD(i, 3)*((KD(i, k) + x)*y)**2*(KD(i, k) + x) + \
|
||||
((KD(i, k) + x)*y)**3
|
||||
assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, 1)) == \
|
||||
(x + KD(i, k))*(y + KD(i, 1))
|
||||
assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 2, 2)) == \
|
||||
(x + KD(i, k))*(y + KD(i, 2))
|
||||
assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 3, 3)) == \
|
||||
(x + KD(i, k))*(y + KD(i, 3))
|
||||
assert dp((x + KD(i, k))*(y + KD(i, j)), (j, 1, k)) == \
|
||||
((KD(i, k) + x)*y)**k + Piecewise(
|
||||
(((KD(i, k) + x)*y)**(-1)*((KD(i, k) + x)*y)**i*(KD(i, k) + x
|
||||
)*((KD(i, k) + x)*y)**k*((KD(i, k) + x)*y)**(-i), (i >= 1
|
||||
) & (i <= k)), (0, True))
|
||||
assert dp((x + KD(i, k))*(y + KD(i, j)), (j, k, 3)) == (
|
||||
(KD(i, k) + x)*y)**4*((KD(i, k) + x)*y)**(-k) + Piecewise(
|
||||
(((KD(i, k) + x)*y)**i*((KD(i, k) + x)*y)**(-k)*(KD(i, k)
|
||||
+ x)*((KD(i, k) + x)*y)**3*((KD(i, k) + x)*y)**(-i),
|
||||
(i >= k) & (i <= 3)), (0, True))
|
||||
assert dp((x + KD(i, k))*(y + KD(i, j)), (j, k, l)) == (
|
||||
KD(i, k) + x)*y*((KD(i, k) + x)*y)**l*((KD(i, k) + x)*y
|
||||
)**(-k) + Piecewise((((KD(i, k) + x)*y)**i*((KD(i, k) + x
|
||||
)*y)**(-k)*(KD(i, k) + x)*((KD(i, k) + x)*y)**l*((KD(i, k) + x
|
||||
)*y)**(-i), (i >= k) & (i <= l)), (0, True))
|
||||
|
||||
|
||||
def test_deltasummation_trivial():
|
||||
assert ds(x, (j, 1, 0)) == 0
|
||||
assert ds(x, (j, 1, 3)) == 3*x
|
||||
assert ds(x + y, (j, 1, 3)) == 3*(x + y)
|
||||
assert ds(x*y, (j, 1, 3)) == 3*x*y
|
||||
assert ds(KD(i, j), (k, 1, 3)) == 3*KD(i, j)
|
||||
assert ds(x*KD(i, j), (k, 1, 3)) == 3*x*KD(i, j)
|
||||
assert ds(x*y*KD(i, j), (k, 1, 3)) == 3*x*y*KD(i, j)
|
||||
|
||||
|
||||
def test_deltasummation_basic_numerical():
|
||||
n = symbols('n', integer=True, nonzero=True)
|
||||
assert ds(KD(n, 0), (n, 1, 3)) == 0
|
||||
|
||||
# return unevaluated, until it gets implemented
|
||||
assert ds(KD(i**2, j**2), (j, -oo, oo)) == \
|
||||
Sum(KD(i**2, j**2), (j, -oo, oo))
|
||||
|
||||
assert Piecewise((KD(i, k), And(1 <= i, i <= 3)), (0, True)) == \
|
||||
ds(KD(i, j)*KD(j, k), (j, 1, 3)) == \
|
||||
ds(KD(j, k)*KD(i, j), (j, 1, 3))
|
||||
|
||||
assert ds(KD(i, k), (k, -oo, oo)) == 1
|
||||
assert ds(KD(i, k), (k, 0, oo)) == Piecewise((1, S.Zero <= i), (0, True))
|
||||
assert ds(KD(i, k), (k, 1, 3)) == \
|
||||
Piecewise((1, And(1 <= i, i <= 3)), (0, True))
|
||||
assert ds(k*KD(i, j)*KD(j, k), (k, -oo, oo)) == j*KD(i, j)
|
||||
assert ds(j*KD(i, j), (j, -oo, oo)) == i
|
||||
assert ds(i*KD(i, j), (i, -oo, oo)) == j
|
||||
assert ds(x, (i, 1, 3)) == 3*x
|
||||
assert ds((i + j)*KD(i, j), (j, -oo, oo)) == 2*i
|
||||
|
||||
|
||||
def test_deltasummation_basic_symbolic():
|
||||
assert ds(KD(i, j), (j, 1, 3)) == \
|
||||
Piecewise((1, And(1 <= i, i <= 3)), (0, True))
|
||||
assert ds(KD(i, j), (j, 1, 1)) == Piecewise((1, Eq(i, 1)), (0, True))
|
||||
assert ds(KD(i, j), (j, 2, 2)) == Piecewise((1, Eq(i, 2)), (0, True))
|
||||
assert ds(KD(i, j), (j, 3, 3)) == Piecewise((1, Eq(i, 3)), (0, True))
|
||||
assert ds(KD(i, j), (j, 1, k)) == \
|
||||
Piecewise((1, And(1 <= i, i <= k)), (0, True))
|
||||
assert ds(KD(i, j), (j, k, 3)) == \
|
||||
Piecewise((1, And(k <= i, i <= 3)), (0, True))
|
||||
assert ds(KD(i, j), (j, k, l)) == \
|
||||
Piecewise((1, And(k <= i, i <= l)), (0, True))
|
||||
|
||||
|
||||
def test_deltasummation_mul_x_kd():
|
||||
assert ds(x*KD(i, j), (j, 1, 3)) == \
|
||||
Piecewise((x, And(1 <= i, i <= 3)), (0, True))
|
||||
assert ds(x*KD(i, j), (j, 1, 1)) == Piecewise((x, Eq(i, 1)), (0, True))
|
||||
assert ds(x*KD(i, j), (j, 2, 2)) == Piecewise((x, Eq(i, 2)), (0, True))
|
||||
assert ds(x*KD(i, j), (j, 3, 3)) == Piecewise((x, Eq(i, 3)), (0, True))
|
||||
assert ds(x*KD(i, j), (j, 1, k)) == \
|
||||
Piecewise((x, And(1 <= i, i <= k)), (0, True))
|
||||
assert ds(x*KD(i, j), (j, k, 3)) == \
|
||||
Piecewise((x, And(k <= i, i <= 3)), (0, True))
|
||||
assert ds(x*KD(i, j), (j, k, l)) == \
|
||||
Piecewise((x, And(k <= i, i <= l)), (0, True))
|
||||
|
||||
|
||||
def test_deltasummation_mul_add_x_y_kd():
|
||||
assert ds((x + y)*KD(i, j), (j, 1, 3)) == \
|
||||
Piecewise((x + y, And(1 <= i, i <= 3)), (0, True))
|
||||
assert ds((x + y)*KD(i, j), (j, 1, 1)) == \
|
||||
Piecewise((x + y, Eq(i, 1)), (0, True))
|
||||
assert ds((x + y)*KD(i, j), (j, 2, 2)) == \
|
||||
Piecewise((x + y, Eq(i, 2)), (0, True))
|
||||
assert ds((x + y)*KD(i, j), (j, 3, 3)) == \
|
||||
Piecewise((x + y, Eq(i, 3)), (0, True))
|
||||
assert ds((x + y)*KD(i, j), (j, 1, k)) == \
|
||||
Piecewise((x + y, And(1 <= i, i <= k)), (0, True))
|
||||
assert ds((x + y)*KD(i, j), (j, k, 3)) == \
|
||||
Piecewise((x + y, And(k <= i, i <= 3)), (0, True))
|
||||
assert ds((x + y)*KD(i, j), (j, k, l)) == \
|
||||
Piecewise((x + y, And(k <= i, i <= l)), (0, True))
|
||||
|
||||
|
||||
def test_deltasummation_add_kd_kd():
|
||||
assert ds(KD(i, k) + KD(j, k), (k, 1, 3)) == piecewise_fold(
|
||||
Piecewise((1, And(1 <= i, i <= 3)), (0, True)) +
|
||||
Piecewise((1, And(1 <= j, j <= 3)), (0, True)))
|
||||
assert ds(KD(i, k) + KD(j, k), (k, 1, 1)) == piecewise_fold(
|
||||
Piecewise((1, Eq(i, 1)), (0, True)) +
|
||||
Piecewise((1, Eq(j, 1)), (0, True)))
|
||||
assert ds(KD(i, k) + KD(j, k), (k, 2, 2)) == piecewise_fold(
|
||||
Piecewise((1, Eq(i, 2)), (0, True)) +
|
||||
Piecewise((1, Eq(j, 2)), (0, True)))
|
||||
assert ds(KD(i, k) + KD(j, k), (k, 3, 3)) == piecewise_fold(
|
||||
Piecewise((1, Eq(i, 3)), (0, True)) +
|
||||
Piecewise((1, Eq(j, 3)), (0, True)))
|
||||
assert ds(KD(i, k) + KD(j, k), (k, 1, l)) == piecewise_fold(
|
||||
Piecewise((1, And(1 <= i, i <= l)), (0, True)) +
|
||||
Piecewise((1, And(1 <= j, j <= l)), (0, True)))
|
||||
assert ds(KD(i, k) + KD(j, k), (k, l, 3)) == piecewise_fold(
|
||||
Piecewise((1, And(l <= i, i <= 3)), (0, True)) +
|
||||
Piecewise((1, And(l <= j, j <= 3)), (0, True)))
|
||||
assert ds(KD(i, k) + KD(j, k), (k, l, m)) == piecewise_fold(
|
||||
Piecewise((1, And(l <= i, i <= m)), (0, True)) +
|
||||
Piecewise((1, And(l <= j, j <= m)), (0, True)))
|
||||
|
||||
|
||||
def test_deltasummation_add_mul_x_kd_kd():
|
||||
assert ds(x*KD(i, k) + KD(j, k), (k, 1, 3)) == piecewise_fold(
|
||||
Piecewise((x, And(1 <= i, i <= 3)), (0, True)) +
|
||||
Piecewise((1, And(1 <= j, j <= 3)), (0, True)))
|
||||
assert ds(x*KD(i, k) + KD(j, k), (k, 1, 1)) == piecewise_fold(
|
||||
Piecewise((x, Eq(i, 1)), (0, True)) +
|
||||
Piecewise((1, Eq(j, 1)), (0, True)))
|
||||
assert ds(x*KD(i, k) + KD(j, k), (k, 2, 2)) == piecewise_fold(
|
||||
Piecewise((x, Eq(i, 2)), (0, True)) +
|
||||
Piecewise((1, Eq(j, 2)), (0, True)))
|
||||
assert ds(x*KD(i, k) + KD(j, k), (k, 3, 3)) == piecewise_fold(
|
||||
Piecewise((x, Eq(i, 3)), (0, True)) +
|
||||
Piecewise((1, Eq(j, 3)), (0, True)))
|
||||
assert ds(x*KD(i, k) + KD(j, k), (k, 1, l)) == piecewise_fold(
|
||||
Piecewise((x, And(1 <= i, i <= l)), (0, True)) +
|
||||
Piecewise((1, And(1 <= j, j <= l)), (0, True)))
|
||||
assert ds(x*KD(i, k) + KD(j, k), (k, l, 3)) == piecewise_fold(
|
||||
Piecewise((x, And(l <= i, i <= 3)), (0, True)) +
|
||||
Piecewise((1, And(l <= j, j <= 3)), (0, True)))
|
||||
assert ds(x*KD(i, k) + KD(j, k), (k, l, m)) == piecewise_fold(
|
||||
Piecewise((x, And(l <= i, i <= m)), (0, True)) +
|
||||
Piecewise((1, And(l <= j, j <= m)), (0, True)))
|
||||
|
||||
|
||||
def test_deltasummation_mul_x_add_kd_kd():
|
||||
assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, 3)) == piecewise_fold(
|
||||
Piecewise((x, And(1 <= i, i <= 3)), (0, True)) +
|
||||
Piecewise((x, And(1 <= j, j <= 3)), (0, True)))
|
||||
assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, 1)) == piecewise_fold(
|
||||
Piecewise((x, Eq(i, 1)), (0, True)) +
|
||||
Piecewise((x, Eq(j, 1)), (0, True)))
|
||||
assert ds(x*(KD(i, k) + KD(j, k)), (k, 2, 2)) == piecewise_fold(
|
||||
Piecewise((x, Eq(i, 2)), (0, True)) +
|
||||
Piecewise((x, Eq(j, 2)), (0, True)))
|
||||
assert ds(x*(KD(i, k) + KD(j, k)), (k, 3, 3)) == piecewise_fold(
|
||||
Piecewise((x, Eq(i, 3)), (0, True)) +
|
||||
Piecewise((x, Eq(j, 3)), (0, True)))
|
||||
assert ds(x*(KD(i, k) + KD(j, k)), (k, 1, l)) == piecewise_fold(
|
||||
Piecewise((x, And(1 <= i, i <= l)), (0, True)) +
|
||||
Piecewise((x, And(1 <= j, j <= l)), (0, True)))
|
||||
assert ds(x*(KD(i, k) + KD(j, k)), (k, l, 3)) == piecewise_fold(
|
||||
Piecewise((x, And(l <= i, i <= 3)), (0, True)) +
|
||||
Piecewise((x, And(l <= j, j <= 3)), (0, True)))
|
||||
assert ds(x*(KD(i, k) + KD(j, k)), (k, l, m)) == piecewise_fold(
|
||||
Piecewise((x, And(l <= i, i <= m)), (0, True)) +
|
||||
Piecewise((x, And(l <= j, j <= m)), (0, True)))
|
||||
|
||||
|
||||
def test_deltasummation_mul_add_x_y_add_kd_kd():
|
||||
assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 3)) == piecewise_fold(
|
||||
Piecewise((x + y, And(1 <= i, i <= 3)), (0, True)) +
|
||||
Piecewise((x + y, And(1 <= j, j <= 3)), (0, True)))
|
||||
assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, 1)) == piecewise_fold(
|
||||
Piecewise((x + y, Eq(i, 1)), (0, True)) +
|
||||
Piecewise((x + y, Eq(j, 1)), (0, True)))
|
||||
assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 2, 2)) == piecewise_fold(
|
||||
Piecewise((x + y, Eq(i, 2)), (0, True)) +
|
||||
Piecewise((x + y, Eq(j, 2)), (0, True)))
|
||||
assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 3, 3)) == piecewise_fold(
|
||||
Piecewise((x + y, Eq(i, 3)), (0, True)) +
|
||||
Piecewise((x + y, Eq(j, 3)), (0, True)))
|
||||
assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, 1, l)) == piecewise_fold(
|
||||
Piecewise((x + y, And(1 <= i, i <= l)), (0, True)) +
|
||||
Piecewise((x + y, And(1 <= j, j <= l)), (0, True)))
|
||||
assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, l, 3)) == piecewise_fold(
|
||||
Piecewise((x + y, And(l <= i, i <= 3)), (0, True)) +
|
||||
Piecewise((x + y, And(l <= j, j <= 3)), (0, True)))
|
||||
assert ds((x + y)*(KD(i, k) + KD(j, k)), (k, l, m)) == piecewise_fold(
|
||||
Piecewise((x + y, And(l <= i, i <= m)), (0, True)) +
|
||||
Piecewise((x + y, And(l <= j, j <= m)), (0, True)))
|
||||
|
||||
|
||||
def test_deltasummation_add_mul_x_y_mul_x_kd():
|
||||
assert ds(x*y + x*KD(i, j), (j, 1, 3)) == \
|
||||
Piecewise((3*x*y + x, And(1 <= i, i <= 3)), (3*x*y, True))
|
||||
assert ds(x*y + x*KD(i, j), (j, 1, 1)) == \
|
||||
Piecewise((x*y + x, Eq(i, 1)), (x*y, True))
|
||||
assert ds(x*y + x*KD(i, j), (j, 2, 2)) == \
|
||||
Piecewise((x*y + x, Eq(i, 2)), (x*y, True))
|
||||
assert ds(x*y + x*KD(i, j), (j, 3, 3)) == \
|
||||
Piecewise((x*y + x, Eq(i, 3)), (x*y, True))
|
||||
assert ds(x*y + x*KD(i, j), (j, 1, k)) == \
|
||||
Piecewise((k*x*y + x, And(1 <= i, i <= k)), (k*x*y, True))
|
||||
assert ds(x*y + x*KD(i, j), (j, k, 3)) == \
|
||||
Piecewise(((4 - k)*x*y + x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
|
||||
assert ds(x*y + x*KD(i, j), (j, k, l)) == Piecewise(
|
||||
((l - k + 1)*x*y + x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
|
||||
|
||||
|
||||
def test_deltasummation_mul_x_add_y_kd():
|
||||
assert ds(x*(y + KD(i, j)), (j, 1, 3)) == \
|
||||
Piecewise((3*x*y + x, And(1 <= i, i <= 3)), (3*x*y, True))
|
||||
assert ds(x*(y + KD(i, j)), (j, 1, 1)) == \
|
||||
Piecewise((x*y + x, Eq(i, 1)), (x*y, True))
|
||||
assert ds(x*(y + KD(i, j)), (j, 2, 2)) == \
|
||||
Piecewise((x*y + x, Eq(i, 2)), (x*y, True))
|
||||
assert ds(x*(y + KD(i, j)), (j, 3, 3)) == \
|
||||
Piecewise((x*y + x, Eq(i, 3)), (x*y, True))
|
||||
assert ds(x*(y + KD(i, j)), (j, 1, k)) == \
|
||||
Piecewise((k*x*y + x, And(1 <= i, i <= k)), (k*x*y, True))
|
||||
assert ds(x*(y + KD(i, j)), (j, k, 3)) == \
|
||||
Piecewise(((4 - k)*x*y + x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
|
||||
assert ds(x*(y + KD(i, j)), (j, k, l)) == Piecewise(
|
||||
((l - k + 1)*x*y + x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
|
||||
|
||||
|
||||
def test_deltasummation_mul_x_add_y_twokd():
|
||||
assert ds(x*(y + 2*KD(i, j)), (j, 1, 3)) == \
|
||||
Piecewise((3*x*y + 2*x, And(1 <= i, i <= 3)), (3*x*y, True))
|
||||
assert ds(x*(y + 2*KD(i, j)), (j, 1, 1)) == \
|
||||
Piecewise((x*y + 2*x, Eq(i, 1)), (x*y, True))
|
||||
assert ds(x*(y + 2*KD(i, j)), (j, 2, 2)) == \
|
||||
Piecewise((x*y + 2*x, Eq(i, 2)), (x*y, True))
|
||||
assert ds(x*(y + 2*KD(i, j)), (j, 3, 3)) == \
|
||||
Piecewise((x*y + 2*x, Eq(i, 3)), (x*y, True))
|
||||
assert ds(x*(y + 2*KD(i, j)), (j, 1, k)) == \
|
||||
Piecewise((k*x*y + 2*x, And(1 <= i, i <= k)), (k*x*y, True))
|
||||
assert ds(x*(y + 2*KD(i, j)), (j, k, 3)) == Piecewise(
|
||||
((4 - k)*x*y + 2*x, And(k <= i, i <= 3)), ((4 - k)*x*y, True))
|
||||
assert ds(x*(y + 2*KD(i, j)), (j, k, l)) == Piecewise(
|
||||
((l - k + 1)*x*y + 2*x, And(k <= i, i <= l)), ((l - k + 1)*x*y, True))
|
||||
|
||||
|
||||
def test_deltasummation_mul_add_x_y_add_y_kd():
|
||||
assert ds((x + y)*(y + KD(i, j)), (j, 1, 3)) == Piecewise(
|
||||
(3*(x + y)*y + x + y, And(1 <= i, i <= 3)), (3*(x + y)*y, True))
|
||||
assert ds((x + y)*(y + KD(i, j)), (j, 1, 1)) == \
|
||||
Piecewise(((x + y)*y + x + y, Eq(i, 1)), ((x + y)*y, True))
|
||||
assert ds((x + y)*(y + KD(i, j)), (j, 2, 2)) == \
|
||||
Piecewise(((x + y)*y + x + y, Eq(i, 2)), ((x + y)*y, True))
|
||||
assert ds((x + y)*(y + KD(i, j)), (j, 3, 3)) == \
|
||||
Piecewise(((x + y)*y + x + y, Eq(i, 3)), ((x + y)*y, True))
|
||||
assert ds((x + y)*(y + KD(i, j)), (j, 1, k)) == Piecewise(
|
||||
(k*(x + y)*y + x + y, And(1 <= i, i <= k)), (k*(x + y)*y, True))
|
||||
assert ds((x + y)*(y + KD(i, j)), (j, k, 3)) == Piecewise(
|
||||
((4 - k)*(x + y)*y + x + y, And(k <= i, i <= 3)),
|
||||
((4 - k)*(x + y)*y, True))
|
||||
assert ds((x + y)*(y + KD(i, j)), (j, k, l)) == Piecewise(
|
||||
((l - k + 1)*(x + y)*y + x + y, And(k <= i, i <= l)),
|
||||
((l - k + 1)*(x + y)*y, True))
|
||||
|
||||
|
||||
def test_deltasummation_mul_add_x_kd_add_y_kd():
|
||||
assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, 3)) == piecewise_fold(
|
||||
Piecewise((KD(i, k) + x, And(1 <= i, i <= 3)), (0, True)) +
|
||||
3*(KD(i, k) + x)*y)
|
||||
assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, 1)) == piecewise_fold(
|
||||
Piecewise((KD(i, k) + x, Eq(i, 1)), (0, True)) +
|
||||
(KD(i, k) + x)*y)
|
||||
assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 2, 2)) == piecewise_fold(
|
||||
Piecewise((KD(i, k) + x, Eq(i, 2)), (0, True)) +
|
||||
(KD(i, k) + x)*y)
|
||||
assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 3, 3)) == piecewise_fold(
|
||||
Piecewise((KD(i, k) + x, Eq(i, 3)), (0, True)) +
|
||||
(KD(i, k) + x)*y)
|
||||
assert ds((x + KD(i, k))*(y + KD(i, j)), (j, 1, k)) == piecewise_fold(
|
||||
Piecewise((KD(i, k) + x, And(1 <= i, i <= k)), (0, True)) +
|
||||
k*(KD(i, k) + x)*y)
|
||||
assert ds((x + KD(i, k))*(y + KD(i, j)), (j, k, 3)) == piecewise_fold(
|
||||
Piecewise((KD(i, k) + x, And(k <= i, i <= 3)), (0, True)) +
|
||||
(4 - k)*(KD(i, k) + x)*y)
|
||||
assert ds((x + KD(i, k))*(y + KD(i, j)), (j, k, l)) == piecewise_fold(
|
||||
Piecewise((KD(i, k) + x, And(k <= i, i <= l)), (0, True)) +
|
||||
(l - k + 1)*(KD(i, k) + x)*y)
|
||||
|
||||
|
||||
def test_extract_delta():
|
||||
raises(ValueError, lambda: _extract_delta(KD(i, j) + KD(k, l), i))
|
||||
@@ -0,0 +1,204 @@
|
||||
"""Tests for Gosper's algorithm for hypergeometric summation. """
|
||||
|
||||
from sympy.core.numbers import (Rational, pi)
|
||||
from sympy.core.singleton import S
|
||||
from sympy.core.symbol import Symbol
|
||||
from sympy.functions.combinatorial.factorials import (binomial, factorial)
|
||||
from sympy.functions.elementary.exponential import (exp, log)
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.functions.special.gamma_functions import gamma
|
||||
from sympy.polys.polytools import Poly
|
||||
from sympy.simplify.simplify import simplify
|
||||
from sympy.concrete.gosper import gosper_normal, gosper_sum, gosper_term
|
||||
from sympy.abc import a, b, j, k, m, n, r, x
|
||||
|
||||
|
||||
def test_gosper_normal():
|
||||
eq = 4*n + 5, 2*(4*n + 1)*(2*n + 3), n
|
||||
assert gosper_normal(*eq) == \
|
||||
(Poly(Rational(1, 4), n), Poly(n + Rational(3, 2)), Poly(n + Rational(1, 4)))
|
||||
assert gosper_normal(*eq, polys=False) == \
|
||||
(Rational(1, 4), n + Rational(3, 2), n + Rational(1, 4))
|
||||
|
||||
|
||||
def test_gosper_term():
|
||||
assert gosper_term((4*k + 1)*factorial(
|
||||
k)/factorial(2*k + 1), k) == (-k - S.Half)/(k + Rational(1, 4))
|
||||
|
||||
|
||||
def test_gosper_sum():
|
||||
assert gosper_sum(1, (k, 0, n)) == 1 + n
|
||||
assert gosper_sum(k, (k, 0, n)) == n*(1 + n)/2
|
||||
assert gosper_sum(k**2, (k, 0, n)) == n*(1 + n)*(1 + 2*n)/6
|
||||
assert gosper_sum(k**3, (k, 0, n)) == n**2*(1 + n)**2/4
|
||||
|
||||
assert gosper_sum(2**k, (k, 0, n)) == 2*2**n - 1
|
||||
|
||||
assert gosper_sum(factorial(k), (k, 0, n)) is None
|
||||
assert gosper_sum(binomial(n, k), (k, 0, n)) is None
|
||||
|
||||
assert gosper_sum(factorial(k)/k**2, (k, 0, n)) is None
|
||||
assert gosper_sum((k - 3)*factorial(k), (k, 0, n)) is None
|
||||
|
||||
assert gosper_sum(k*factorial(k), k) == factorial(k)
|
||||
assert gosper_sum(
|
||||
k*factorial(k), (k, 0, n)) == n*factorial(n) + factorial(n) - 1
|
||||
|
||||
assert gosper_sum((-1)**k*binomial(n, k), (k, 0, n)) == 0
|
||||
assert gosper_sum((
|
||||
-1)**k*binomial(n, k), (k, 0, m)) == -(-1)**m*(m - n)*binomial(n, m)/n
|
||||
|
||||
assert gosper_sum((4*k + 1)*factorial(k)/factorial(2*k + 1), (k, 0, n)) == \
|
||||
(2*factorial(2*n + 1) - factorial(n))/factorial(2*n + 1)
|
||||
|
||||
# issue 6033:
|
||||
assert gosper_sum(
|
||||
n*(n + a + b)*a**n*b**n/(factorial(n + a)*factorial(n + b)), \
|
||||
(n, 0, m)).simplify() == -exp(m*log(a) + m*log(b))*gamma(a + 1) \
|
||||
*gamma(b + 1)/(gamma(a)*gamma(b)*gamma(a + m + 1)*gamma(b + m + 1)) \
|
||||
+ 1/(gamma(a)*gamma(b))
|
||||
|
||||
|
||||
def test_gosper_sum_indefinite():
|
||||
assert gosper_sum(k, k) == k*(k - 1)/2
|
||||
assert gosper_sum(k**2, k) == k*(k - 1)*(2*k - 1)/6
|
||||
|
||||
assert gosper_sum(1/(k*(k + 1)), k) == -1/k
|
||||
assert gosper_sum(-(27*k**4 + 158*k**3 + 430*k**2 + 678*k + 445)*gamma(2*k
|
||||
+ 4)/(3*(3*k + 7)*gamma(3*k + 6)), k) == \
|
||||
(3*k + 5)*(k**2 + 2*k + 5)*gamma(2*k + 4)/gamma(3*k + 6)
|
||||
|
||||
|
||||
def test_gosper_sum_parametric():
|
||||
assert gosper_sum(binomial(S.Half, m - j + 1)*binomial(S.Half, m + j), (j, 1, n)) == \
|
||||
n*(1 + m - n)*(-1 + 2*m + 2*n)*binomial(S.Half, 1 + m - n)* \
|
||||
binomial(S.Half, m + n)/(m*(1 + 2*m))
|
||||
|
||||
|
||||
def test_gosper_sum_algebraic():
|
||||
assert gosper_sum(
|
||||
n**2 + sqrt(2), (n, 0, m)) == (m + 1)*(2*m**2 + m + 6*sqrt(2))/6
|
||||
|
||||
|
||||
def test_gosper_sum_iterated():
|
||||
f1 = binomial(2*k, k)/4**k
|
||||
f2 = (1 + 2*n)*binomial(2*n, n)/4**n
|
||||
f3 = (1 + 2*n)*(3 + 2*n)*binomial(2*n, n)/(3*4**n)
|
||||
f4 = (1 + 2*n)*(3 + 2*n)*(5 + 2*n)*binomial(2*n, n)/(15*4**n)
|
||||
f5 = (1 + 2*n)*(3 + 2*n)*(5 + 2*n)*(7 + 2*n)*binomial(2*n, n)/(105*4**n)
|
||||
|
||||
assert gosper_sum(f1, (k, 0, n)) == f2
|
||||
assert gosper_sum(f2, (n, 0, n)) == f3
|
||||
assert gosper_sum(f3, (n, 0, n)) == f4
|
||||
assert gosper_sum(f4, (n, 0, n)) == f5
|
||||
|
||||
# the AeqB tests test expressions given in
|
||||
# www.math.upenn.edu/~wilf/AeqB.pdf
|
||||
|
||||
|
||||
def test_gosper_sum_AeqB_part1():
|
||||
f1a = n**4
|
||||
f1b = n**3*2**n
|
||||
f1c = 1/(n**2 + sqrt(5)*n - 1)
|
||||
f1d = n**4*4**n/binomial(2*n, n)
|
||||
f1e = factorial(3*n)/(factorial(n)*factorial(n + 1)*factorial(n + 2)*27**n)
|
||||
f1f = binomial(2*n, n)**2/((n + 1)*4**(2*n))
|
||||
f1g = (4*n - 1)*binomial(2*n, n)**2/((2*n - 1)**2*4**(2*n))
|
||||
f1h = n*factorial(n - S.Half)**2/factorial(n + 1)**2
|
||||
|
||||
g1a = m*(m + 1)*(2*m + 1)*(3*m**2 + 3*m - 1)/30
|
||||
g1b = 26 + 2**(m + 1)*(m**3 - 3*m**2 + 9*m - 13)
|
||||
g1c = (m + 1)*(m*(m**2 - 7*m + 3)*sqrt(5) - (
|
||||
3*m**3 - 7*m**2 + 19*m - 6))/(2*m**3*sqrt(5) + m**4 + 5*m**2 - 1)/6
|
||||
g1d = Rational(-2, 231) + 2*4**m*(m + 1)*(63*m**4 + 112*m**3 + 18*m**2 -
|
||||
22*m + 3)/(693*binomial(2*m, m))
|
||||
g1e = Rational(-9, 2) + (81*m**2 + 261*m + 200)*factorial(
|
||||
3*m + 2)/(40*27**m*factorial(m)*factorial(m + 1)*factorial(m + 2))
|
||||
g1f = (2*m + 1)**2*binomial(2*m, m)**2/(4**(2*m)*(m + 1))
|
||||
g1g = -binomial(2*m, m)**2/4**(2*m)
|
||||
g1h = 4*pi -(2*m + 1)**2*(3*m + 4)*factorial(m - S.Half)**2/factorial(m + 1)**2
|
||||
|
||||
g = gosper_sum(f1a, (n, 0, m))
|
||||
assert g is not None and simplify(g - g1a) == 0
|
||||
g = gosper_sum(f1b, (n, 0, m))
|
||||
assert g is not None and simplify(g - g1b) == 0
|
||||
g = gosper_sum(f1c, (n, 0, m))
|
||||
assert g is not None and simplify(g - g1c) == 0
|
||||
g = gosper_sum(f1d, (n, 0, m))
|
||||
assert g is not None and simplify(g - g1d) == 0
|
||||
g = gosper_sum(f1e, (n, 0, m))
|
||||
assert g is not None and simplify(g - g1e) == 0
|
||||
g = gosper_sum(f1f, (n, 0, m))
|
||||
assert g is not None and simplify(g - g1f) == 0
|
||||
g = gosper_sum(f1g, (n, 0, m))
|
||||
assert g is not None and simplify(g - g1g) == 0
|
||||
g = gosper_sum(f1h, (n, 0, m))
|
||||
# need to call rewrite(gamma) here because we have terms involving
|
||||
# factorial(1/2)
|
||||
assert g is not None and simplify(g - g1h).rewrite(gamma) == 0
|
||||
|
||||
|
||||
def test_gosper_sum_AeqB_part2():
|
||||
f2a = n**2*a**n
|
||||
f2b = (n - r/2)*binomial(r, n)
|
||||
f2c = factorial(n - 1)**2/(factorial(n - x)*factorial(n + x))
|
||||
|
||||
g2a = -a*(a + 1)/(a - 1)**3 + a**(
|
||||
m + 1)*(a**2*m**2 - 2*a*m**2 + m**2 - 2*a*m + 2*m + a + 1)/(a - 1)**3
|
||||
g2b = (m - r)*binomial(r, m)/2
|
||||
ff = factorial(1 - x)*factorial(1 + x)
|
||||
g2c = 1/ff*(
|
||||
1 - 1/x**2) + factorial(m)**2/(x**2*factorial(m - x)*factorial(m + x))
|
||||
|
||||
g = gosper_sum(f2a, (n, 0, m))
|
||||
assert g is not None and simplify(g - g2a) == 0
|
||||
g = gosper_sum(f2b, (n, 0, m))
|
||||
assert g is not None and simplify(g - g2b) == 0
|
||||
g = gosper_sum(f2c, (n, 1, m))
|
||||
assert g is not None and simplify(g - g2c) == 0
|
||||
|
||||
|
||||
def test_gosper_nan():
|
||||
a = Symbol('a', positive=True)
|
||||
b = Symbol('b', positive=True)
|
||||
n = Symbol('n', integer=True)
|
||||
m = Symbol('m', integer=True)
|
||||
f2d = n*(n + a + b)*a**n*b**n/(factorial(n + a)*factorial(n + b))
|
||||
g2d = 1/(factorial(a - 1)*factorial(
|
||||
b - 1)) - a**(m + 1)*b**(m + 1)/(factorial(a + m)*factorial(b + m))
|
||||
g = gosper_sum(f2d, (n, 0, m))
|
||||
assert simplify(g - g2d) == 0
|
||||
|
||||
|
||||
def test_gosper_sum_AeqB_part3():
|
||||
f3a = 1/n**4
|
||||
f3b = (6*n + 3)/(4*n**4 + 8*n**3 + 8*n**2 + 4*n + 3)
|
||||
f3c = 2**n*(n**2 - 2*n - 1)/(n**2*(n + 1)**2)
|
||||
f3d = n**2*4**n/((n + 1)*(n + 2))
|
||||
f3e = 2**n/(n + 1)
|
||||
f3f = 4*(n - 1)*(n**2 - 2*n - 1)/(n**2*(n + 1)**2*(n - 2)**2*(n - 3)**2)
|
||||
f3g = (n**4 - 14*n**2 - 24*n - 9)*2**n/(n**2*(n + 1)**2*(n + 2)**2*
|
||||
(n + 3)**2)
|
||||
|
||||
# g3a -> no closed form
|
||||
g3b = m*(m + 2)/(2*m**2 + 4*m + 3)
|
||||
g3c = 2**m/m**2 - 2
|
||||
g3d = Rational(2, 3) + 4**(m + 1)*(m - 1)/(m + 2)/3
|
||||
# g3e -> no closed form
|
||||
g3f = -(Rational(-1, 16) + 1/((m - 2)**2*(m + 1)**2)) # the AeqB key is wrong
|
||||
g3g = Rational(-2, 9) + 2**(m + 1)/((m + 1)**2*(m + 3)**2)
|
||||
|
||||
g = gosper_sum(f3a, (n, 1, m))
|
||||
assert g is None
|
||||
g = gosper_sum(f3b, (n, 1, m))
|
||||
assert g is not None and simplify(g - g3b) == 0
|
||||
g = gosper_sum(f3c, (n, 1, m - 1))
|
||||
assert g is not None and simplify(g - g3c) == 0
|
||||
g = gosper_sum(f3d, (n, 1, m))
|
||||
assert g is not None and simplify(g - g3d) == 0
|
||||
g = gosper_sum(f3e, (n, 0, m - 1))
|
||||
assert g is None
|
||||
g = gosper_sum(f3f, (n, 4, m))
|
||||
assert g is not None and simplify(g - g3f) == 0
|
||||
g = gosper_sum(f3g, (n, 1, m))
|
||||
assert g is not None and simplify(g - g3g) == 0
|
||||
@@ -0,0 +1,82 @@
|
||||
from sympy.concrete.guess import (
|
||||
find_simple_recurrence_vector,
|
||||
find_simple_recurrence,
|
||||
rationalize,
|
||||
guess_generating_function_rational,
|
||||
guess_generating_function,
|
||||
guess
|
||||
)
|
||||
from sympy.concrete.products import Product
|
||||
from sympy.core.function import Function
|
||||
from sympy.core.numbers import Rational
|
||||
from sympy.core.singleton import S
|
||||
from sympy.core.symbol import (Symbol, symbols)
|
||||
from sympy.core.sympify import sympify
|
||||
from sympy.functions.combinatorial.factorials import (RisingFactorial, factorial)
|
||||
from sympy.functions.combinatorial.numbers import fibonacci
|
||||
from sympy.functions.elementary.exponential import exp
|
||||
|
||||
|
||||
def test_find_simple_recurrence_vector():
|
||||
assert find_simple_recurrence_vector(
|
||||
[fibonacci(k) for k in range(12)]) == [1, -1, -1]
|
||||
|
||||
|
||||
def test_find_simple_recurrence():
|
||||
a = Function('a')
|
||||
n = Symbol('n')
|
||||
assert find_simple_recurrence([fibonacci(k) for k in range(12)]) == (
|
||||
-a(n) - a(n + 1) + a(n + 2))
|
||||
|
||||
f = Function('a')
|
||||
i = Symbol('n')
|
||||
a = [1, 1, 1]
|
||||
for k in range(15): a.append(5*a[-1]-3*a[-2]+8*a[-3])
|
||||
assert find_simple_recurrence(a, A=f, N=i) == (
|
||||
-8*f(i) + 3*f(i + 1) - 5*f(i + 2) + f(i + 3))
|
||||
assert find_simple_recurrence([0, 2, 15, 74, 12, 3, 0,
|
||||
1, 2, 85, 4, 5, 63]) == 0
|
||||
|
||||
|
||||
def test_rationalize():
|
||||
from mpmath import cos, pi, mpf
|
||||
assert rationalize(cos(pi/3)) == S.Half
|
||||
assert rationalize(mpf("0.333333333333333")) == Rational(1, 3)
|
||||
assert rationalize(mpf("-0.333333333333333")) == Rational(-1, 3)
|
||||
assert rationalize(pi, maxcoeff = 250) == Rational(355, 113)
|
||||
|
||||
|
||||
def test_guess_generating_function_rational():
|
||||
x = Symbol('x')
|
||||
assert guess_generating_function_rational([fibonacci(k)
|
||||
for k in range(5, 15)]) == ((3*x + 5)/(-x**2 - x + 1))
|
||||
|
||||
|
||||
def test_guess_generating_function():
|
||||
x = Symbol('x')
|
||||
assert guess_generating_function([fibonacci(k)
|
||||
for k in range(5, 15)])['ogf'] == ((3*x + 5)/(-x**2 - x + 1))
|
||||
assert guess_generating_function(
|
||||
[1, 2, 5, 14, 41, 124, 383, 1200, 3799, 12122, 38919])['ogf'] == (
|
||||
(1/(x**4 + 2*x**2 - 4*x + 1))**S.Half)
|
||||
assert guess_generating_function(sympify(
|
||||
"[3/2, 11/2, 0, -121/2, -363/2, 121, 4719/2, 11495/2, -8712, -178717/2]")
|
||||
)['ogf'] == (x + Rational(3, 2))/(11*x**2 - 3*x + 1)
|
||||
assert guess_generating_function([factorial(k) for k in range(12)],
|
||||
types=['egf'])['egf'] == 1/(-x + 1)
|
||||
assert guess_generating_function([k+1 for k in range(12)],
|
||||
types=['egf']) == {'egf': (x + 1)*exp(x), 'lgdegf': (x + 2)/(x + 1)}
|
||||
|
||||
|
||||
def test_guess():
|
||||
i0, i1 = symbols('i0 i1')
|
||||
assert guess([1, 2, 6, 24, 120], evaluate=False) == [Product(i1 + 1, (i1, 1, i0 - 1))]
|
||||
assert guess([1, 2, 6, 24, 120]) == [RisingFactorial(2, i0 - 1)]
|
||||
assert guess([1, 2, 7, 42, 429, 7436, 218348, 10850216], niter=4) == [
|
||||
2**(i0 - 1)*(Rational(27, 16))**(i0**2/2 - 3*i0/2 +
|
||||
1)*Product(RisingFactorial(Rational(5, 3), i1 - 1)*RisingFactorial(Rational(7, 3), i1
|
||||
- 1)/(RisingFactorial(Rational(3, 2), i1 - 1)*RisingFactorial(Rational(5, 2), i1 -
|
||||
1)), (i1, 1, i0 - 1))]
|
||||
assert guess([1, 0, 2]) == []
|
||||
x, y = symbols('x y')
|
||||
assert guess([1, 2, 6, 24, 120], variables=[x, y]) == [RisingFactorial(2, x - 1)]
|
||||
@@ -0,0 +1,410 @@
|
||||
from sympy.concrete.products import (Product, product)
|
||||
from sympy.concrete.summations import Sum
|
||||
from sympy.core.function import (Derivative, Function, diff)
|
||||
from sympy.core.numbers import (Rational, oo, pi)
|
||||
from sympy.core.singleton import S
|
||||
from sympy.core.symbol import (Dummy, Symbol, symbols)
|
||||
from sympy.functions.combinatorial.factorials import (rf, factorial)
|
||||
from sympy.functions.elementary.exponential import (exp, log)
|
||||
from sympy.functions.elementary.miscellaneous import sqrt
|
||||
from sympy.functions.elementary.trigonometric import (cos, sin)
|
||||
from sympy.functions.special.tensor_functions import KroneckerDelta
|
||||
from sympy.simplify.combsimp import combsimp
|
||||
from sympy.simplify.simplify import simplify
|
||||
from sympy.testing.pytest import raises
|
||||
|
||||
a, k, n, m, x = symbols('a,k,n,m,x', integer=True)
|
||||
f = Function('f')
|
||||
|
||||
|
||||
def test_karr_convention():
|
||||
# Test the Karr product convention that we want to hold.
|
||||
# See his paper "Summation in Finite Terms" for a detailed
|
||||
# reasoning why we really want exactly this definition.
|
||||
# The convention is described for sums on page 309 and
|
||||
# essentially in section 1.4, definition 3. For products
|
||||
# we can find in analogy:
|
||||
#
|
||||
# \prod_{m <= i < n} f(i) 'has the obvious meaning' for m < n
|
||||
# \prod_{m <= i < n} f(i) = 0 for m = n
|
||||
# \prod_{m <= i < n} f(i) = 1 / \prod_{n <= i < m} f(i) for m > n
|
||||
#
|
||||
# It is important to note that he defines all products with
|
||||
# the upper limit being *exclusive*.
|
||||
# In contrast, SymPy and the usual mathematical notation has:
|
||||
#
|
||||
# prod_{i = a}^b f(i) = f(a) * f(a+1) * ... * f(b-1) * f(b)
|
||||
#
|
||||
# with the upper limit *inclusive*. So translating between
|
||||
# the two we find that:
|
||||
#
|
||||
# \prod_{m <= i < n} f(i) = \prod_{i = m}^{n-1} f(i)
|
||||
#
|
||||
# where we intentionally used two different ways to typeset the
|
||||
# products and its limits.
|
||||
|
||||
i = Symbol("i", integer=True)
|
||||
k = Symbol("k", integer=True)
|
||||
j = Symbol("j", integer=True, positive=True)
|
||||
|
||||
# A simple example with a concrete factors and symbolic limits.
|
||||
|
||||
# The normal product: m = k and n = k + j and therefore m < n:
|
||||
m = k
|
||||
n = k + j
|
||||
|
||||
a = m
|
||||
b = n - 1
|
||||
S1 = Product(i**2, (i, a, b)).doit()
|
||||
|
||||
# The reversed product: m = k + j and n = k and therefore m > n:
|
||||
m = k + j
|
||||
n = k
|
||||
|
||||
a = m
|
||||
b = n - 1
|
||||
S2 = Product(i**2, (i, a, b)).doit()
|
||||
|
||||
assert S1 * S2 == 1
|
||||
|
||||
# Test the empty product: m = k and n = k and therefore m = n:
|
||||
m = k
|
||||
n = k
|
||||
|
||||
a = m
|
||||
b = n - 1
|
||||
Sz = Product(i**2, (i, a, b)).doit()
|
||||
|
||||
assert Sz == 1
|
||||
|
||||
# Another example this time with an unspecified factor and
|
||||
# numeric limits. (We can not do both tests in the same example.)
|
||||
f = Function("f")
|
||||
|
||||
# The normal product with m < n:
|
||||
m = 2
|
||||
n = 11
|
||||
|
||||
a = m
|
||||
b = n - 1
|
||||
S1 = Product(f(i), (i, a, b)).doit()
|
||||
|
||||
# The reversed product with m > n:
|
||||
m = 11
|
||||
n = 2
|
||||
|
||||
a = m
|
||||
b = n - 1
|
||||
S2 = Product(f(i), (i, a, b)).doit()
|
||||
|
||||
assert simplify(S1 * S2) == 1
|
||||
|
||||
# Test the empty product with m = n:
|
||||
m = 5
|
||||
n = 5
|
||||
|
||||
a = m
|
||||
b = n - 1
|
||||
Sz = Product(f(i), (i, a, b)).doit()
|
||||
|
||||
assert Sz == 1
|
||||
|
||||
|
||||
def test_karr_proposition_2a():
|
||||
# Test Karr, page 309, proposition 2, part a
|
||||
i, u, v = symbols('i u v', integer=True)
|
||||
|
||||
def test_the_product(m, n):
|
||||
# g
|
||||
g = i**3 + 2*i**2 - 3*i
|
||||
# f = Delta g
|
||||
f = simplify(g.subs(i, i+1) / g)
|
||||
# The product
|
||||
a = m
|
||||
b = n - 1
|
||||
P = Product(f, (i, a, b)).doit()
|
||||
# Test if Product_{m <= i < n} f(i) = g(n) / g(m)
|
||||
assert combsimp(P / (g.subs(i, n) / g.subs(i, m))) == 1
|
||||
|
||||
# m < n
|
||||
test_the_product(u, u + v)
|
||||
# m = n
|
||||
test_the_product(u, u)
|
||||
# m > n
|
||||
test_the_product(u + v, u)
|
||||
|
||||
|
||||
def test_karr_proposition_2b():
|
||||
# Test Karr, page 309, proposition 2, part b
|
||||
i, u, v, w = symbols('i u v w', integer=True)
|
||||
|
||||
def test_the_product(l, n, m):
|
||||
# Productmand
|
||||
s = i**3
|
||||
# First product
|
||||
a = l
|
||||
b = n - 1
|
||||
S1 = Product(s, (i, a, b)).doit()
|
||||
# Second product
|
||||
a = l
|
||||
b = m - 1
|
||||
S2 = Product(s, (i, a, b)).doit()
|
||||
# Third product
|
||||
a = m
|
||||
b = n - 1
|
||||
S3 = Product(s, (i, a, b)).doit()
|
||||
# Test if S1 = S2 * S3 as required
|
||||
assert combsimp(S1 / (S2 * S3)) == 1
|
||||
|
||||
# l < m < n
|
||||
test_the_product(u, u + v, u + v + w)
|
||||
# l < m = n
|
||||
test_the_product(u, u + v, u + v)
|
||||
# l < m > n
|
||||
test_the_product(u, u + v + w, v)
|
||||
# l = m < n
|
||||
test_the_product(u, u, u + v)
|
||||
# l = m = n
|
||||
test_the_product(u, u, u)
|
||||
# l = m > n
|
||||
test_the_product(u + v, u + v, u)
|
||||
# l > m < n
|
||||
test_the_product(u + v, u, u + w)
|
||||
# l > m = n
|
||||
test_the_product(u + v, u, u)
|
||||
# l > m > n
|
||||
test_the_product(u + v + w, u + v, u)
|
||||
|
||||
|
||||
def test_simple_products():
|
||||
assert product(2, (k, a, n)) == 2**(n - a + 1)
|
||||
assert product(k, (k, 1, n)) == factorial(n)
|
||||
assert product(k**3, (k, 1, n)) == factorial(n)**3
|
||||
|
||||
assert product(k + 1, (k, 0, n - 1)) == factorial(n)
|
||||
assert product(k + 1, (k, a, n - 1)) == rf(1 + a, n - a)
|
||||
|
||||
assert product(cos(k), (k, 0, 5)) == cos(1)*cos(2)*cos(3)*cos(4)*cos(5)
|
||||
assert product(cos(k), (k, 3, 5)) == cos(3)*cos(4)*cos(5)
|
||||
assert product(cos(k), (k, 1, Rational(5, 2))) != cos(1)*cos(2)
|
||||
|
||||
assert isinstance(product(k**k, (k, 1, n)), Product)
|
||||
|
||||
assert Product(x**k, (k, 1, n)).variables == [k]
|
||||
|
||||
raises(ValueError, lambda: Product(n))
|
||||
raises(ValueError, lambda: Product(n, k))
|
||||
raises(ValueError, lambda: Product(n, k, 1))
|
||||
raises(ValueError, lambda: Product(n, k, 1, 10))
|
||||
raises(ValueError, lambda: Product(n, (k, 1)))
|
||||
|
||||
assert product(1, (n, 1, oo)) == 1 # issue 8301
|
||||
assert product(2, (n, 1, oo)) is oo
|
||||
assert product(-1, (n, 1, oo)).func is Product
|
||||
|
||||
|
||||
def test_multiple_products():
|
||||
assert product(x, (n, 1, k), (k, 1, m)) == x**(m**2/2 + m/2)
|
||||
assert product(f(n), (
|
||||
n, 1, m), (m, 1, k)) == Product(f(n), (n, 1, m), (m, 1, k)).doit()
|
||||
assert Product(f(n), (m, 1, k), (n, 1, k)).doit() == \
|
||||
Product(Product(f(n), (m, 1, k)), (n, 1, k)).doit() == \
|
||||
product(f(n), (m, 1, k), (n, 1, k)) == \
|
||||
product(product(f(n), (m, 1, k)), (n, 1, k)) == \
|
||||
Product(f(n)**k, (n, 1, k))
|
||||
assert Product(
|
||||
x, (x, 1, k), (k, 1, n)).doit() == Product(factorial(k), (k, 1, n))
|
||||
|
||||
assert Product(x**k, (n, 1, k), (k, 1, m)).variables == [n, k]
|
||||
|
||||
|
||||
def test_rational_products():
|
||||
assert product(1 + 1/k, (k, 1, n)) == rf(2, n)/factorial(n)
|
||||
|
||||
|
||||
def test_special_products():
|
||||
# Wallis product
|
||||
assert product((4*k)**2 / (4*k**2 - 1), (k, 1, n)) == \
|
||||
4**n*factorial(n)**2/rf(S.Half, n)/rf(Rational(3, 2), n)
|
||||
|
||||
# Euler's product formula for sin
|
||||
assert product(1 + a/k**2, (k, 1, n)) == \
|
||||
rf(1 - sqrt(-a), n)*rf(1 + sqrt(-a), n)/factorial(n)**2
|
||||
|
||||
|
||||
def test__eval_product():
|
||||
from sympy.abc import i, n
|
||||
# issue 4809
|
||||
a = Function('a')
|
||||
assert product(2*a(i), (i, 1, n)) == 2**n * Product(a(i), (i, 1, n))
|
||||
# issue 4810
|
||||
assert product(2**i, (i, 1, n)) == 2**(n*(n + 1)/2)
|
||||
k, m = symbols('k m', integer=True)
|
||||
assert product(2**i, (i, k, m)) == 2**(-k**2/2 + k/2 + m**2/2 + m/2)
|
||||
n = Symbol('n', negative=True, integer=True)
|
||||
p = Symbol('p', positive=True, integer=True)
|
||||
assert product(2**i, (i, n, p)) == 2**(-n**2/2 + n/2 + p**2/2 + p/2)
|
||||
assert product(2**i, (i, p, n)) == 2**(n**2/2 + n/2 - p**2/2 + p/2)
|
||||
|
||||
|
||||
def test_product_pow():
|
||||
# issue 4817
|
||||
assert product(2**f(k), (k, 1, n)) == 2**Sum(f(k), (k, 1, n))
|
||||
assert product(2**(2*f(k)), (k, 1, n)) == 2**Sum(2*f(k), (k, 1, n))
|
||||
|
||||
|
||||
def test_infinite_product():
|
||||
# issue 5737
|
||||
assert isinstance(Product(2**(1/factorial(n)), (n, 0, oo)), Product)
|
||||
|
||||
|
||||
def test_conjugate_transpose():
|
||||
p = Product(x**k, (k, 1, 3))
|
||||
assert p.adjoint().doit() == p.doit().adjoint()
|
||||
assert p.conjugate().doit() == p.doit().conjugate()
|
||||
assert p.transpose().doit() == p.doit().transpose()
|
||||
|
||||
A, B = symbols("A B", commutative=False)
|
||||
p = Product(A*B**k, (k, 1, 3))
|
||||
assert p.adjoint().doit() == p.doit().adjoint()
|
||||
assert p.conjugate().doit() == p.doit().conjugate()
|
||||
assert p.transpose().doit() == p.doit().transpose()
|
||||
|
||||
p = Product(B**k*A, (k, 1, 3))
|
||||
assert p.adjoint().doit() == p.doit().adjoint()
|
||||
assert p.conjugate().doit() == p.doit().conjugate()
|
||||
assert p.transpose().doit() == p.doit().transpose()
|
||||
|
||||
|
||||
def test_simplify_prod():
|
||||
y, t, b, c, v, d = symbols('y, t, b, c, v, d', integer = True)
|
||||
|
||||
_simplify = lambda e: simplify(e, doit=False)
|
||||
assert _simplify(Product(x*y, (x, n, m), (y, a, k)) * \
|
||||
Product(y, (x, n, m), (y, a, k))) == \
|
||||
Product(x*y**2, (x, n, m), (y, a, k))
|
||||
assert _simplify(3 * y* Product(x, (x, n, m)) * Product(x, (x, m + 1, a))) \
|
||||
== 3 * y * Product(x, (x, n, a))
|
||||
assert _simplify(Product(x, (x, k + 1, a)) * Product(x, (x, n, k))) == \
|
||||
Product(x, (x, n, a))
|
||||
assert _simplify(Product(x, (x, k + 1, a)) * Product(x + 1, (x, n, k))) == \
|
||||
Product(x, (x, k + 1, a)) * Product(x + 1, (x, n, k))
|
||||
assert _simplify(Product(x, (t, a, b)) * Product(y, (t, a, b)) * \
|
||||
Product(x, (t, b+1, c))) == Product(x*y, (t, a, b)) * \
|
||||
Product(x, (t, b+1, c))
|
||||
assert _simplify(Product(x, (t, a, b)) * Product(x, (t, b+1, c)) * \
|
||||
Product(y, (t, a, b))) == Product(x*y, (t, a, b)) * \
|
||||
Product(x, (t, b+1, c))
|
||||
assert _simplify(Product(sin(t)**2 + cos(t)**2 + 1, (t, a, b))) == \
|
||||
Product(2, (t, a, b))
|
||||
assert _simplify(Product(sin(t)**2 + cos(t)**2 - 1, (t, a, b))) == \
|
||||
Product(0, (t, a, b))
|
||||
assert _simplify(Product(v*Product(sin(t)**2 + cos(t)**2, (t, a, b)),
|
||||
(v, c, d))) == Product(v*Product(1, (t, a, b)), (v, c, d))
|
||||
|
||||
|
||||
def test_change_index():
|
||||
b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
|
||||
|
||||
assert Product(x, (x, a, b)).change_index(x, x + 1, y) == \
|
||||
Product(y - 1, (y, a + 1, b + 1))
|
||||
assert Product(x**2, (x, a, b)).change_index(x, x - 1) == \
|
||||
Product((x + 1)**2, (x, a - 1, b - 1))
|
||||
assert Product(x**2, (x, a, b)).change_index(x, -x, y) == \
|
||||
Product((-y)**2, (y, -b, -a))
|
||||
assert Product(x, (x, a, b)).change_index(x, -x - 1) == \
|
||||
Product(-x - 1, (x, - b - 1, -a - 1))
|
||||
assert Product(x*y, (x, a, b), (y, c, d)).change_index(x, x - 1, z) == \
|
||||
Product((z + 1)*y, (z, a - 1, b - 1), (y, c, d))
|
||||
|
||||
|
||||
def test_reorder():
|
||||
b, y, c, d, z = symbols('b, y, c, d, z', integer = True)
|
||||
|
||||
assert Product(x*y, (x, a, b), (y, c, d)).reorder((0, 1)) == \
|
||||
Product(x*y, (y, c, d), (x, a, b))
|
||||
assert Product(x, (x, a, b), (x, c, d)).reorder((0, 1)) == \
|
||||
Product(x, (x, c, d), (x, a, b))
|
||||
assert Product(x*y + z, (x, a, b), (z, m, n), (y, c, d)).reorder(\
|
||||
(2, 0), (0, 1)) == Product(x*y + z, (z, m, n), (y, c, d), (x, a, b))
|
||||
assert Product(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
|
||||
(0, 1), (1, 2), (0, 2)) == \
|
||||
Product(x*y*z, (x, a, b), (z, m, n), (y, c, d))
|
||||
assert Product(x*y*z, (x, a, b), (y, c, d), (z, m, n)).reorder(\
|
||||
(x, y), (y, z), (x, z)) == \
|
||||
Product(x*y*z, (x, a, b), (z, m, n), (y, c, d))
|
||||
assert Product(x*y, (x, a, b), (y, c, d)).reorder((x, 1)) == \
|
||||
Product(x*y, (y, c, d), (x, a, b))
|
||||
assert Product(x*y, (x, a, b), (y, c, d)).reorder((y, x)) == \
|
||||
Product(x*y, (y, c, d), (x, a, b))
|
||||
|
||||
|
||||
def test_Product_is_convergent():
|
||||
assert Product(1/n**2, (n, 1, oo)).is_convergent() is S.false
|
||||
assert Product(exp(1/n**2), (n, 1, oo)).is_convergent() is S.true
|
||||
assert Product(1/n, (n, 1, oo)).is_convergent() is S.false
|
||||
assert Product(1 + 1/n, (n, 1, oo)).is_convergent() is S.false
|
||||
assert Product(1 + 1/n**2, (n, 1, oo)).is_convergent() is S.true
|
||||
|
||||
|
||||
def test_reverse_order():
|
||||
x, y, a, b, c, d= symbols('x, y, a, b, c, d', integer = True)
|
||||
|
||||
assert Product(x, (x, 0, 3)).reverse_order(0) == Product(1/x, (x, 4, -1))
|
||||
assert Product(x*y, (x, 1, 5), (y, 0, 6)).reverse_order(0, 1) == \
|
||||
Product(x*y, (x, 6, 0), (y, 7, -1))
|
||||
assert Product(x, (x, 1, 2)).reverse_order(0) == Product(1/x, (x, 3, 0))
|
||||
assert Product(x, (x, 1, 3)).reverse_order(0) == Product(1/x, (x, 4, 0))
|
||||
assert Product(x, (x, 1, a)).reverse_order(0) == Product(1/x, (x, a + 1, 0))
|
||||
assert Product(x, (x, a, 5)).reverse_order(0) == Product(1/x, (x, 6, a - 1))
|
||||
assert Product(x, (x, a + 1, a + 5)).reverse_order(0) == \
|
||||
Product(1/x, (x, a + 6, a))
|
||||
assert Product(x, (x, a + 1, a + 2)).reverse_order(0) == \
|
||||
Product(1/x, (x, a + 3, a))
|
||||
assert Product(x, (x, a + 1, a + 1)).reverse_order(0) == \
|
||||
Product(1/x, (x, a + 2, a))
|
||||
assert Product(x, (x, a, b)).reverse_order(0) == Product(1/x, (x, b + 1, a - 1))
|
||||
assert Product(x, (x, a, b)).reverse_order(x) == Product(1/x, (x, b + 1, a - 1))
|
||||
assert Product(x*y, (x, a, b), (y, 2, 5)).reverse_order(x, 1) == \
|
||||
Product(x*y, (x, b + 1, a - 1), (y, 6, 1))
|
||||
assert Product(x*y, (x, a, b), (y, 2, 5)).reverse_order(y, x) == \
|
||||
Product(x*y, (x, b + 1, a - 1), (y, 6, 1))
|
||||
|
||||
|
||||
def test_issue_9983():
|
||||
n = Symbol('n', integer=True, positive=True)
|
||||
p = Product(1 + 1/n**Rational(2, 3), (n, 1, oo))
|
||||
assert p.is_convergent() is S.false
|
||||
assert product(1 + 1/n**Rational(2, 3), (n, 1, oo)) == p.doit()
|
||||
|
||||
|
||||
def test_issue_13546():
|
||||
n = Symbol('n')
|
||||
k = Symbol('k')
|
||||
p = Product(n + 1 / 2**k, (k, 0, n-1)).doit()
|
||||
assert p.subs(n, 2).doit() == Rational(15, 2)
|
||||
|
||||
|
||||
def test_issue_14036():
|
||||
a, n = symbols('a n')
|
||||
assert product(1 - a**2 / (n*pi)**2, [n, 1, oo]) != 0
|
||||
|
||||
|
||||
def test_rewrite_Sum():
|
||||
assert Product(1 - S.Half**2/k**2, (k, 1, oo)).rewrite(Sum) == \
|
||||
exp(Sum(log(1 - 1/(4*k**2)), (k, 1, oo)))
|
||||
|
||||
|
||||
def test_KroneckerDelta_Product():
|
||||
y = Symbol('y')
|
||||
assert Product(x*KroneckerDelta(x, y), (x, 0, 1)).doit() == 0
|
||||
|
||||
|
||||
def test_issue_20848():
|
||||
_i = Dummy('i')
|
||||
t, y, z = symbols('t y z')
|
||||
assert diff(Product(x, (y, 1, z)), x).as_dummy() == Sum(Product(x, (y, 1, _i - 1))*Product(x, (y, _i + 1, z)), (_i, 1, z)).as_dummy()
|
||||
assert diff(Product(x, (y, 1, z)), x).doit() == x**(z - 1)*z
|
||||
assert diff(Product(x, (y, x, z)), x) == Derivative(Product(x, (y, x, z)), x)
|
||||
assert diff(Product(t, (x, 1, z)), x) == S(0)
|
||||
assert Product(sin(n*x), (n, -1, 1)).diff(x).doit() == S(0)
|
||||
File diff suppressed because it is too large
Load Diff
Reference in New Issue
Block a user