313 lines
11 KiB
Python
313 lines
11 KiB
Python
from sympy.core.containers import Tuple
|
|
from sympy.core.function import Function
|
|
from sympy.core.numbers import oo, Rational
|
|
from sympy.core.singleton import S
|
|
from sympy.core.symbol import symbols, Symbol
|
|
from sympy.functions.combinatorial.numbers import tribonacci, fibonacci
|
|
from sympy.functions.elementary.exponential import exp
|
|
from sympy.functions.elementary.miscellaneous import sqrt
|
|
from sympy.functions.elementary.trigonometric import cos, sin
|
|
from sympy.series import EmptySequence
|
|
from sympy.series.sequences import (SeqMul, SeqAdd, SeqPer, SeqFormula,
|
|
sequence)
|
|
from sympy.sets.sets import Interval
|
|
from sympy.tensor.indexed import Indexed, Idx
|
|
from sympy.series.sequences import SeqExpr, SeqExprOp, RecursiveSeq
|
|
from sympy.testing.pytest import raises, slow
|
|
|
|
x, y, z = symbols('x y z')
|
|
n, m = symbols('n m')
|
|
|
|
|
|
def test_EmptySequence():
|
|
assert S.EmptySequence is EmptySequence
|
|
|
|
assert S.EmptySequence.interval is S.EmptySet
|
|
assert S.EmptySequence.length is S.Zero
|
|
|
|
assert list(S.EmptySequence) == []
|
|
|
|
|
|
def test_SeqExpr():
|
|
#SeqExpr is a baseclass and does not take care of
|
|
#ensuring all arguments are Basics hence the use of
|
|
#Tuple(...) here.
|
|
s = SeqExpr(Tuple(1, n, y), Tuple(x, 0, 10))
|
|
|
|
assert isinstance(s, SeqExpr)
|
|
assert s.gen == (1, n, y)
|
|
assert s.interval == Interval(0, 10)
|
|
assert s.start == 0
|
|
assert s.stop == 10
|
|
assert s.length == 11
|
|
assert s.variables == (x,)
|
|
|
|
assert SeqExpr(Tuple(1, 2, 3), Tuple(x, 0, oo)).length is oo
|
|
|
|
|
|
def test_SeqPer():
|
|
s = SeqPer((1, n, 3), (x, 0, 5))
|
|
|
|
assert isinstance(s, SeqPer)
|
|
assert s.periodical == Tuple(1, n, 3)
|
|
assert s.period == 3
|
|
assert s.coeff(3) == 1
|
|
assert s.free_symbols == {n}
|
|
|
|
assert list(s) == [1, n, 3, 1, n, 3]
|
|
assert s[:] == [1, n, 3, 1, n, 3]
|
|
assert SeqPer((1, n, 3), (x, -oo, 0))[0:6] == [1, n, 3, 1, n, 3]
|
|
|
|
raises(ValueError, lambda: SeqPer((1, 2, 3), (0, 1, 2)))
|
|
raises(ValueError, lambda: SeqPer((1, 2, 3), (x, -oo, oo)))
|
|
raises(ValueError, lambda: SeqPer(n**2, (0, oo)))
|
|
|
|
assert SeqPer((n, n**2, n**3), (m, 0, oo))[:6] == \
|
|
[n, n**2, n**3, n, n**2, n**3]
|
|
assert SeqPer((n, n**2, n**3), (n, 0, oo))[:6] == [0, 1, 8, 3, 16, 125]
|
|
assert SeqPer((n, m), (n, 0, oo))[:6] == [0, m, 2, m, 4, m]
|
|
|
|
|
|
def test_SeqFormula():
|
|
s = SeqFormula(n**2, (n, 0, 5))
|
|
|
|
assert isinstance(s, SeqFormula)
|
|
assert s.formula == n**2
|
|
assert s.coeff(3) == 9
|
|
|
|
assert list(s) == [i**2 for i in range(6)]
|
|
assert s[:] == [i**2 for i in range(6)]
|
|
assert SeqFormula(n**2, (n, -oo, 0))[0:6] == [i**2 for i in range(6)]
|
|
|
|
assert SeqFormula(n**2, (0, oo)) == SeqFormula(n**2, (n, 0, oo))
|
|
|
|
assert SeqFormula(n**2, (0, m)).subs(m, x) == SeqFormula(n**2, (0, x))
|
|
assert SeqFormula(m*n**2, (n, 0, oo)).subs(m, x) == \
|
|
SeqFormula(x*n**2, (n, 0, oo))
|
|
|
|
raises(ValueError, lambda: SeqFormula(n**2, (0, 1, 2)))
|
|
raises(ValueError, lambda: SeqFormula(n**2, (n, -oo, oo)))
|
|
raises(ValueError, lambda: SeqFormula(m*n**2, (0, oo)))
|
|
|
|
seq = SeqFormula(x*(y**2 + z), (z, 1, 100))
|
|
assert seq.expand() == SeqFormula(x*y**2 + x*z, (z, 1, 100))
|
|
seq = SeqFormula(sin(x*(y**2 + z)),(z, 1, 100))
|
|
assert seq.expand(trig=True) == SeqFormula(sin(x*y**2)*cos(x*z) + sin(x*z)*cos(x*y**2), (z, 1, 100))
|
|
assert seq.expand() == SeqFormula(sin(x*y**2 + x*z), (z, 1, 100))
|
|
assert seq.expand(trig=False) == SeqFormula(sin(x*y**2 + x*z), (z, 1, 100))
|
|
seq = SeqFormula(exp(x*(y**2 + z)), (z, 1, 100))
|
|
assert seq.expand() == SeqFormula(exp(x*y**2)*exp(x*z), (z, 1, 100))
|
|
assert seq.expand(power_exp=False) == SeqFormula(exp(x*y**2 + x*z), (z, 1, 100))
|
|
assert seq.expand(mul=False, power_exp=False) == SeqFormula(exp(x*(y**2 + z)), (z, 1, 100))
|
|
|
|
def test_sequence():
|
|
form = SeqFormula(n**2, (n, 0, 5))
|
|
per = SeqPer((1, 2, 3), (n, 0, 5))
|
|
inter = SeqFormula(n**2)
|
|
|
|
assert sequence(n**2, (n, 0, 5)) == form
|
|
assert sequence((1, 2, 3), (n, 0, 5)) == per
|
|
assert sequence(n**2) == inter
|
|
|
|
|
|
def test_SeqExprOp():
|
|
form = SeqFormula(n**2, (n, 0, 10))
|
|
per = SeqPer((1, 2, 3), (m, 5, 10))
|
|
|
|
s = SeqExprOp(form, per)
|
|
assert s.gen == (n**2, (1, 2, 3))
|
|
assert s.interval == Interval(5, 10)
|
|
assert s.start == 5
|
|
assert s.stop == 10
|
|
assert s.length == 6
|
|
assert s.variables == (n, m)
|
|
|
|
|
|
def test_SeqAdd():
|
|
per = SeqPer((1, 2, 3), (n, 0, oo))
|
|
form = SeqFormula(n**2)
|
|
|
|
per_bou = SeqPer((1, 2), (n, 1, 5))
|
|
form_bou = SeqFormula(n**2, (6, 10))
|
|
form_bou2 = SeqFormula(n**2, (1, 5))
|
|
|
|
assert SeqAdd() == S.EmptySequence
|
|
assert SeqAdd(S.EmptySequence) == S.EmptySequence
|
|
assert SeqAdd(per) == per
|
|
assert SeqAdd(per, S.EmptySequence) == per
|
|
assert SeqAdd(per_bou, form_bou) == S.EmptySequence
|
|
|
|
s = SeqAdd(per_bou, form_bou2, evaluate=False)
|
|
assert s.args == (form_bou2, per_bou)
|
|
assert s[:] == [2, 6, 10, 18, 26]
|
|
assert list(s) == [2, 6, 10, 18, 26]
|
|
|
|
assert isinstance(SeqAdd(per, per_bou, evaluate=False), SeqAdd)
|
|
|
|
s1 = SeqAdd(per, per_bou)
|
|
assert isinstance(s1, SeqPer)
|
|
assert s1 == SeqPer((2, 4, 4, 3, 3, 5), (n, 1, 5))
|
|
s2 = SeqAdd(form, form_bou)
|
|
assert isinstance(s2, SeqFormula)
|
|
assert s2 == SeqFormula(2*n**2, (6, 10))
|
|
|
|
assert SeqAdd(form, form_bou, per) == \
|
|
SeqAdd(per, SeqFormula(2*n**2, (6, 10)))
|
|
assert SeqAdd(form, SeqAdd(form_bou, per)) == \
|
|
SeqAdd(per, SeqFormula(2*n**2, (6, 10)))
|
|
assert SeqAdd(per, SeqAdd(form, form_bou), evaluate=False) == \
|
|
SeqAdd(per, SeqFormula(2*n**2, (6, 10)))
|
|
|
|
assert SeqAdd(SeqPer((1, 2), (n, 0, oo)), SeqPer((1, 2), (m, 0, oo))) == \
|
|
SeqPer((2, 4), (n, 0, oo))
|
|
|
|
|
|
def test_SeqMul():
|
|
per = SeqPer((1, 2, 3), (n, 0, oo))
|
|
form = SeqFormula(n**2)
|
|
|
|
per_bou = SeqPer((1, 2), (n, 1, 5))
|
|
form_bou = SeqFormula(n**2, (n, 6, 10))
|
|
form_bou2 = SeqFormula(n**2, (1, 5))
|
|
|
|
assert SeqMul() == S.EmptySequence
|
|
assert SeqMul(S.EmptySequence) == S.EmptySequence
|
|
assert SeqMul(per) == per
|
|
assert SeqMul(per, S.EmptySequence) == S.EmptySequence
|
|
assert SeqMul(per_bou, form_bou) == S.EmptySequence
|
|
|
|
s = SeqMul(per_bou, form_bou2, evaluate=False)
|
|
assert s.args == (form_bou2, per_bou)
|
|
assert s[:] == [1, 8, 9, 32, 25]
|
|
assert list(s) == [1, 8, 9, 32, 25]
|
|
|
|
assert isinstance(SeqMul(per, per_bou, evaluate=False), SeqMul)
|
|
|
|
s1 = SeqMul(per, per_bou)
|
|
assert isinstance(s1, SeqPer)
|
|
assert s1 == SeqPer((1, 4, 3, 2, 2, 6), (n, 1, 5))
|
|
s2 = SeqMul(form, form_bou)
|
|
assert isinstance(s2, SeqFormula)
|
|
assert s2 == SeqFormula(n**4, (6, 10))
|
|
|
|
assert SeqMul(form, form_bou, per) == \
|
|
SeqMul(per, SeqFormula(n**4, (6, 10)))
|
|
assert SeqMul(form, SeqMul(form_bou, per)) == \
|
|
SeqMul(per, SeqFormula(n**4, (6, 10)))
|
|
assert SeqMul(per, SeqMul(form, form_bou2,
|
|
evaluate=False), evaluate=False) == \
|
|
SeqMul(form, per, form_bou2, evaluate=False)
|
|
|
|
assert SeqMul(SeqPer((1, 2), (n, 0, oo)), SeqPer((1, 2), (n, 0, oo))) == \
|
|
SeqPer((1, 4), (n, 0, oo))
|
|
|
|
|
|
def test_add():
|
|
per = SeqPer((1, 2), (n, 0, oo))
|
|
form = SeqFormula(n**2)
|
|
|
|
assert per + (SeqPer((2, 3))) == SeqPer((3, 5), (n, 0, oo))
|
|
assert form + SeqFormula(n**3) == SeqFormula(n**2 + n**3)
|
|
|
|
assert per + form == SeqAdd(per, form)
|
|
|
|
raises(TypeError, lambda: per + n)
|
|
raises(TypeError, lambda: n + per)
|
|
|
|
|
|
def test_sub():
|
|
per = SeqPer((1, 2), (n, 0, oo))
|
|
form = SeqFormula(n**2)
|
|
|
|
assert per - (SeqPer((2, 3))) == SeqPer((-1, -1), (n, 0, oo))
|
|
assert form - (SeqFormula(n**3)) == SeqFormula(n**2 - n**3)
|
|
|
|
assert per - form == SeqAdd(per, -form)
|
|
|
|
raises(TypeError, lambda: per - n)
|
|
raises(TypeError, lambda: n - per)
|
|
|
|
|
|
def test_mul__coeff_mul():
|
|
assert SeqPer((1, 2), (n, 0, oo)).coeff_mul(2) == SeqPer((2, 4), (n, 0, oo))
|
|
assert SeqFormula(n**2).coeff_mul(2) == SeqFormula(2*n**2)
|
|
assert S.EmptySequence.coeff_mul(100) == S.EmptySequence
|
|
|
|
assert SeqPer((1, 2), (n, 0, oo)) * (SeqPer((2, 3))) == \
|
|
SeqPer((2, 6), (n, 0, oo))
|
|
assert SeqFormula(n**2) * SeqFormula(n**3) == SeqFormula(n**5)
|
|
|
|
assert S.EmptySequence * SeqFormula(n**2) == S.EmptySequence
|
|
assert SeqFormula(n**2) * S.EmptySequence == S.EmptySequence
|
|
|
|
raises(TypeError, lambda: sequence(n**2) * n)
|
|
raises(TypeError, lambda: n * sequence(n**2))
|
|
|
|
|
|
def test_neg():
|
|
assert -SeqPer((1, -2), (n, 0, oo)) == SeqPer((-1, 2), (n, 0, oo))
|
|
assert -SeqFormula(n**2) == SeqFormula(-n**2)
|
|
|
|
|
|
def test_operations():
|
|
per = SeqPer((1, 2), (n, 0, oo))
|
|
per2 = SeqPer((2, 4), (n, 0, oo))
|
|
form = SeqFormula(n**2)
|
|
form2 = SeqFormula(n**3)
|
|
|
|
assert per + form + form2 == SeqAdd(per, form, form2)
|
|
assert per + form - form2 == SeqAdd(per, form, -form2)
|
|
assert per + form - S.EmptySequence == SeqAdd(per, form)
|
|
assert per + per2 + form == SeqAdd(SeqPer((3, 6), (n, 0, oo)), form)
|
|
assert S.EmptySequence - per == -per
|
|
assert form + form == SeqFormula(2*n**2)
|
|
|
|
assert per * form * form2 == SeqMul(per, form, form2)
|
|
assert form * form == SeqFormula(n**4)
|
|
assert form * -form == SeqFormula(-n**4)
|
|
|
|
assert form * (per + form2) == SeqMul(form, SeqAdd(per, form2))
|
|
assert form * (per + per) == SeqMul(form, per2)
|
|
|
|
assert form.coeff_mul(m) == SeqFormula(m*n**2, (n, 0, oo))
|
|
assert per.coeff_mul(m) == SeqPer((m, 2*m), (n, 0, oo))
|
|
|
|
|
|
def test_Idx_limits():
|
|
i = symbols('i', cls=Idx)
|
|
r = Indexed('r', i)
|
|
|
|
assert SeqFormula(r, (i, 0, 5))[:] == [r.subs(i, j) for j in range(6)]
|
|
assert SeqPer((1, 2), (i, 0, 5))[:] == [1, 2, 1, 2, 1, 2]
|
|
|
|
|
|
@slow
|
|
def test_find_linear_recurrence():
|
|
assert sequence((0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55), \
|
|
(n, 0, 10)).find_linear_recurrence(11) == [1, 1]
|
|
assert sequence((1, 2, 4, 7, 28, 128, 582, 2745, 13021, 61699, 292521, \
|
|
1387138), (n, 0, 11)).find_linear_recurrence(12) == [5, -2, 6, -11]
|
|
assert sequence(x*n**3+y*n, (n, 0, oo)).find_linear_recurrence(10) \
|
|
== [4, -6, 4, -1]
|
|
assert sequence(x**n, (n,0,20)).find_linear_recurrence(21) == [x]
|
|
assert sequence((1,2,3)).find_linear_recurrence(10, 5) == [0, 0, 1]
|
|
assert sequence(((1 + sqrt(5))/2)**n + \
|
|
(-(1 + sqrt(5))/2)**(-n)).find_linear_recurrence(10) == [1, 1]
|
|
assert sequence(x*((1 + sqrt(5))/2)**n + y*(-(1 + sqrt(5))/2)**(-n), \
|
|
(n,0,oo)).find_linear_recurrence(10) == [1, 1]
|
|
assert sequence((1,2,3,4,6),(n, 0, 4)).find_linear_recurrence(5) == []
|
|
assert sequence((2,3,4,5,6,79),(n, 0, 5)).find_linear_recurrence(6,gfvar=x) \
|
|
== ([], None)
|
|
assert sequence((2,3,4,5,8,30),(n, 0, 5)).find_linear_recurrence(6,gfvar=x) \
|
|
== ([Rational(19, 2), -20, Rational(27, 2)], (-31*x**2 + 32*x - 4)/(27*x**3 - 40*x**2 + 19*x -2))
|
|
assert sequence(fibonacci(n)).find_linear_recurrence(30,gfvar=x) \
|
|
== ([1, 1], -x/(x**2 + x - 1))
|
|
assert sequence(tribonacci(n)).find_linear_recurrence(30,gfvar=x) \
|
|
== ([1, 1, 1], -x/(x**3 + x**2 + x - 1))
|
|
|
|
def test_RecursiveSeq():
|
|
y = Function('y')
|
|
n = Symbol('n')
|
|
fib = RecursiveSeq(y(n - 1) + y(n - 2), y(n), n, [0, 1])
|
|
assert fib.coeff(3) == 2
|