def test_prde_special_denom(): a = Poly(t + 1, t) ba = Poly(t**2, t) bd = Poly(1, t) G = [(Poly(t, t), Poly(1, t)), (Poly(t**2, t), Poly(1, t)), (Poly(t**3, t), Poly(1, t))] DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]}) assert prde_special_denom(a, ba, bd, G, DE) == \ (Poly(t + 1, t), Poly(t**2, t), [(Poly(t, t), Poly(1, t)), (Poly(t**2, t), Poly(1, t)), (Poly(t**3, t), Poly(1, t))], Poly(1, t)) G = [(Poly(t, t), Poly(1, t)), (Poly(1, t), Poly(t, t))] assert prde_special_denom(Poly(1, t), Poly(t**2, t), Poly(1, t), G, DE) == \ (Poly(1, t), Poly(t**2 - 1, t), [(Poly(t**2, t), Poly(1, t)), (Poly(1, t), Poly(1, t))], Poly(t, t)) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(-2*x*t0, t0)]}) DE.decrement_level() G = [(Poly(t, t), Poly(t**2, t)), (Poly(2*t, t), Poly(t, t))] assert prde_special_denom(Poly(5*x*t + 1, t), Poly(t**2 + 2*x**3*t, t), Poly(t**3 + 2, t), G, DE) == \ (Poly(5*x*t + 1, t), Poly(0, t), [(Poly(t, t), Poly(t**2, t)), (Poly(2*t, t), Poly(t, t))], Poly(1, x)) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly((t**2 + 1)*2*x, t)]}) G = [(Poly(t + x, t), Poly(t*x, t)), (Poly(2*t, t), Poly(x**2, x))] assert prde_special_denom(Poly(5*x*t + 1, t), Poly(t**2 + 2*x**3*t, t), Poly(t**3, t), G, DE) == \ (Poly(5*x*t + 1, t), Poly(0, t), [(Poly(t + x, t), Poly(x*t, t)), (Poly(2*t, t, x), Poly(x**2, t, x))], Poly(1, t)) assert prde_special_denom(Poly(t + 1, t), Poly(t**2, t), Poly(t**3, t), G, DE) == \ (Poly(t + 1, t), Poly(0, t), [(Poly(t + x, t), Poly(x*t, t)), (Poly(2*t, t, x), Poly(x**2, t, x))], Poly(1, t))
def test_rischDE(): # TODO: Add more tests for rischDE, including ones from the text DE = DifferentialExtension(extension={'D':[Poly(1, x), Poly(t, t)]}) DE.decrement_level() assert rischDE(Poly(-2*x, x), Poly(1, x), Poly(1 - 2*x - 2*x**2, x), Poly(1, x), DE) == \ (Poly(x + 1, x), Poly(1, x))
def test_DifferentialExtension_all_attrs(): # Test 'unimportant' attributes DE = DifferentialExtension(exp(x)*log(x), x, handle_first='exp') assert DE.f == exp(x)*log(x) assert DE.newf == t0*t1 assert DE.x == x assert DE.cases == ['base', 'exp', 'primitive'] assert DE.case == 'primitive' assert DE.level == -1 assert DE.t == t1 == DE.T[DE.level] assert DE.d == Poly(1/x, t1) == DE.D[DE.level] raises(ValueError, lambda: DE.increment_level()) DE.decrement_level() assert DE.level == -2 assert DE.t == t0 == DE.T[DE.level] assert DE.d == Poly(t0, t0) == DE.D[DE.level] assert DE.case == 'exp' DE.decrement_level() assert DE.level == -3 assert DE.t == x == DE.T[DE.level] == DE.x assert DE.d == Poly(1, x) == DE.D[DE.level] assert DE.case == 'base' raises(ValueError, lambda: DE.decrement_level()) DE.increment_level() DE.increment_level() assert DE.level == -1 assert DE.t == t1 == DE.T[DE.level] assert DE.d == Poly(1/x, t1) == DE.D[DE.level] assert DE.case == 'primitive' # Test methods assert DE.indices('log') == [2] assert DE.indices('exp') == [1]
def test_DifferentialExtension_all_attrs(): # Test 'unimportant' attributes DE = DifferentialExtension(exp(x) * log(x), x, dummy=False, handle_first="exp") assert DE.f == exp(x) * log(x) assert DE.newf == t0 * t1 assert DE.x == x assert DE.cases == ["base", "exp", "primitive"] assert DE.case == "primitive" assert DE.level == -1 assert DE.t == t1 == DE.T[DE.level] assert DE.d == Poly(1 / x, t1) == DE.D[DE.level] raises(ValueError, lambda: DE.increment_level()) DE.decrement_level() assert DE.level == -2 assert DE.t == t0 == DE.T[DE.level] assert DE.d == Poly(t0, t0) == DE.D[DE.level] assert DE.case == "exp" DE.decrement_level() assert DE.level == -3 assert DE.t == x == DE.T[DE.level] == DE.x assert DE.d == Poly(1, x) == DE.D[DE.level] assert DE.case == "base" raises(ValueError, lambda: DE.decrement_level()) DE.increment_level() DE.increment_level() assert DE.level == -1 assert DE.t == t1 == DE.T[DE.level] assert DE.d == Poly(1 / x, t1) == DE.D[DE.level] assert DE.case == "primitive"
def test_special_denom(): # TODO: add more tests here DE = DifferentialExtension(extension={'D':[Poly(1, x), Poly(t, t)]}) assert special_denom(Poly(1, t), Poly(t**2, t), Poly(1, t), Poly(t**2 - 1, t), Poly(t, t), DE) == \ (Poly(1, t), Poly(t**2 - 1, t), Poly(t**2 - 1, t), Poly(t, t)) # assert special_denom(Poly(1, t), Poly(2*x, t), Poly((1 + 2*x)*t, t), DE) == 1 # Issue 841 # Note, this isn't a very good test, because the denominator is just 1, # but at least it tests the exp cancellation case DE = DifferentialExtension(extension={'D':[Poly(1, x), Poly(-2*x*t0, t0), Poly(I*k*t1, t1)]}) DE.decrement_level() assert special_denom(Poly(1, t0), Poly(I*k, t0), Poly(1, t0), Poly(t0, t0), Poly(1, t0), DE) == \ (Poly(1, t0), Poly(I*k, t0), Poly(t0, t0), Poly(1, t0))
def test_integrate_primitive(): DE = DifferentialExtension(extension={ 'D': [Poly(1, x), Poly(1 / x, t)], 'Tfuncs': [log] }) assert integrate_primitive(Poly(t, t), Poly(1, t), DE) == (x * log(x), -1, True) assert integrate_primitive(Poly(x, t), Poly(t, t), DE) == (0, NonElementaryIntegral(x / log(x), x), False) DE = DifferentialExtension( extension={ 'D': [Poly(1, x), Poly(1 / x, t1), Poly(1 / (x + 1), t2)], 'Tfuncs': [log, Lambda(i, log(i + 1))] }) assert integrate_primitive(Poly(t1, t2), Poly(t2, t2), DE) == \ (0, NonElementaryIntegral(log(x)/log(1 + x), x), False) DE = DifferentialExtension( extension={ 'D': [Poly(1, x), Poly(1 / x, t1), Poly(1 / (x * t1), t2)], 'Tfuncs': [log, Lambda(i, log(log(i)))] }) assert integrate_primitive(Poly(t2, t2), Poly(t1, t2), DE) == \ (0, NonElementaryIntegral(log(log(x))/log(x), x), False) DE = DifferentialExtension(extension={ 'D': [Poly(1, x), Poly(1 / x, t0)], 'Tfuncs': [log] }) assert integrate_primitive(Poly(x**2*t0**3 + (3*x**2 + x)*t0**2 + (3*x**2 + 2*x)*t0 + x**2 + x, t0), Poly(x**2*t0**4 + 4*x**2*t0**3 + 6*x**2*t0**2 + 4*x**2*t0 + x**2, t0), DE) == \ (-1/(log(x) + 1), NonElementaryIntegral(1/(log(x) + 1), x), False)
def test_residue_reduce(): a = Poly(2 * t**2 - t - x**2, t) d = Poly(t**3 - x**2 * t, t) DE = DifferentialExtension(extension={ 'D': [Poly(1, x), Poly(1 / x, t)], 'Tfuncs': [log] }) assert residue_reduce(a, d, DE, z, invert=False) == \ ([(Poly(z**2 - S(1)/4, z), Poly((1 + 3*x*z - 6*z**2 - 2*x**2 + 4*x**2*z**2)*t - x*z + x**2 + 2*x**2*z**2 - 2*z*x**3, t))], False) assert residue_reduce(a, d, DE, z, invert=True) == \ ([(Poly(z**2 - S(1)/4, z), Poly(t + 2*x*z, t))], False) assert residue_reduce(Poly(-2/x, t), Poly(t**2 - 1, t,), DE, z, invert=False) == \ ([(Poly(z**2 - 1, z), Poly(-2*z*t/x - 2/x, t))], True) ans = residue_reduce(Poly(-2 / x, t), Poly(t**2 - 1, t), DE, z, invert=True) assert ans == ([(Poly(z**2 - 1, z), Poly(t + z, t))], True) assert residue_reduce_to_basic(ans[0], DE, z) == -log(-1 + log(x)) + log(1 + log(x)) DE = DifferentialExtension(extension={ 'D': [Poly(1, x), Poly(-t**2 - t / x - (1 - nu**2 / x**2), t)] }) # TODO: Skip or make faster assert residue_reduce(Poly((-2*nu**2 - x**4)/(2*x**2)*t - (1 + x**2)/x, t), Poly(t**2 + 1 + x**2/2, t), DE, z) == \ ([(Poly(z + S(1)/2, z, domain='QQ'), Poly(t**2 + 1 + x**2/2, t, domain='EX'))], True) DE = DifferentialExtension( extension={'D': [Poly(1, x), Poly(1 + t**2, t)]}) assert residue_reduce(Poly(-2*x*t + 1 - x**2, t), Poly(t**2 + 2*x*t + 1 + x**2, t), DE, z) == \ ([(Poly(z**2 + S(1)/4, z), Poly(t + x + 2*z, t))], True) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]}) assert residue_reduce(Poly(t, t), Poly(t + sqrt(2), t), DE, z) == \ ([(Poly(z - 1, z), Poly(t + sqrt(2), t))], True)
def test_DifferentialExtension_extension_flag(): raises(ValueError, lambda: DifferentialExtension(extension={'T': [x, t]})) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]}) assert DE._important_attrs == (None, None, [Poly(1, x), Poly(t, t)], [x, t], None, None, None, None) assert DE.d == Poly(t, t) assert DE.t == t assert DE.level == -1 assert DE.cases == ['base', 'exp'] assert DE.x == x assert DE.case == 'exp' DE = DifferentialExtension(extension={ 'D': [Poly(1, x), Poly(t, t)], 'exts': [None, 'exp'], 'extargs': [None, x] }) assert DE._important_attrs == (None, None, [Poly(1, x), Poly(t, t)], [x, t], None, None, [None, 'exp'], [None, x]) raises(ValueError, lambda: DifferentialExtension())
def test_DifferentialExtension_misc(): # Odd ends assert DifferentialExtension(sin(y)*exp(x), x, dummy=False)._important_attrs == \ (Poly(sin(y)*t0, t0, domain='ZZ[sin(y)]'), Poly(1, t0, domain='ZZ'), [Poly(1, x, domain='ZZ'), Poly(t0, t0, domain='ZZ')], [x, t0], [Lambda(i, exp(i))], [], [1], [x], [], []) raises(NotImplementedError, lambda: DifferentialExtension(sin(x), x)) assert DifferentialExtension(10**x, x, dummy=False)._important_attrs == \ (Poly(t0, t0), Poly(1, t0), [Poly(1, x), Poly(log(10)*t0, t0)], [x, t0], [Lambda(i, exp(i*log(10)))], [(exp(x*log(10)), 10**x)], [1], [x*log(10)], [], []) assert DifferentialExtension( log(x) + log(x**2), x, dummy=False)._important_attrs in [ (Poly(3 * t0, t0), Poly(2, t0), [Poly(1, x), Poly(2 / x, t0)], [x, t0], [Lambda(i, log(i**2))], [], [], [], [1], [x**2]), (Poly(3 * t0, t0), Poly(1, t0), [Poly(1, x), Poly(1 / x, t0)], [x, t0], [Lambda(i, log(i))], [], [], [], [1], [x]) ] assert DifferentialExtension(S.Zero, x, dummy=False)._important_attrs == \ (Poly(0, x), Poly(1, x), [Poly(1, x)], [x], [], [], [], [], [], [])
def test_DifferentialExtension_handle_first(): assert DifferentialExtension(exp(x)*log(x), x, handle_first='log', dummy=False)._important_attrs == \ (Poly(t0*t1, t1), Poly(1, t1), [Poly(1, x), Poly(1/x, t0), Poly(t1, t1)], [x, t0, t1], [Lambda(i, log(i)), Lambda(i, exp(i))], [], [2], [x], [1], [x]) assert DifferentialExtension(exp(x)*log(x), x, handle_first='exp', dummy=False)._important_attrs == \ (Poly(t0*t1, t1), Poly(1, t1), [Poly(1, x), Poly(t0, t0), Poly(1/x, t1)], [x, t0, t1], [Lambda(i, exp(i)), Lambda(i, log(i))], [], [1], [x], [2], [x]) # This one must have the log first, regardless of what we set it to # (because the log is inside of the exponential: x**x == exp(x*log(x))) assert DifferentialExtension(-x**x*log(x)**2 + x**x - x**x/x, x, handle_first='exp', dummy=False)._important_attrs == \ DifferentialExtension(-x**x*log(x)**2 + x**x - x**x/x, x, handle_first='log', dummy=False)._important_attrs == \ (Poly((-1 + x - x*t0**2)*t1, t1), Poly(x, t1), [Poly(1, x), Poly(1/x, t0), Poly((1 + t0)*t1, t1)], [x, t0, t1], [Lambda(i, log(i)), Lambda(i, exp(t0*i))], [(exp(x*log(x)), x**x)], [2], [t0*x], [1], [x])
def test_DifferentialExtension_extension_flag(): raises(ValueError, lambda: DifferentialExtension(extension={"T": [x, t]})) DE = DifferentialExtension(extension={"D": [Poly(1, x), Poly(t, t)]}) assert DE._important_attrs == ( None, None, [Poly(1, x), Poly(t, t)], [x, t], None, None, None, None, ) assert DE.d == Poly(t, t) assert DE.t == t assert DE.level == -1 assert DE.cases == ["base", "exp"] assert DE.x == x assert DE.case == "exp" DE = DifferentialExtension( extension={ "D": [Poly(1, x), Poly(t, t)], "exts": [None, "exp"], "extargs": [None, x], } ) assert DE._important_attrs == ( None, None, [Poly(1, x), Poly(t, t)], [x, t], None, None, [None, "exp"], [None, x], ) raises(ValueError, lambda: DifferentialExtension())
def test_prde_cancel_liouvillian(): ### 1. case == 'primitive' # used when integrating f = log(x) - log(x - 1) # Not taken from 'the' book DE = DifferentialExtension(extension={"D": [Poly(1, x), Poly(1 / x, t)]}) p0 = Poly(0, t, field=True) h, A = prde_cancel_liouvillian( Poly(-1 / (x - 1), t), [Poly(-x + 1, t), Poly(1, t)], 1, DE ) V = A.nullspace() h == [ p0, p0, Poly((x - 1) * t, t), p0, p0, p0, p0, p0, p0, p0, Poly(x - 1, t), Poly(-(x ** 2) + x, t), p0, p0, p0, p0, ] assert A.rank() == 16 assert (Matrix([h]) * V[0][:16, :]) == Matrix([[Poly(0, t, domain="QQ(x)")]]) ### 2. case == 'exp' # used when integrating log(x/exp(x) + 1) # Not taken from book DE = DifferentialExtension(extension={"D": [Poly(1, x), Poly(-t, t)]}) assert prde_cancel_liouvillian( Poly(0, t, domain="QQ[x]"), [Poly(1, t, domain="QQ(x)")], 0, DE ) == ([Poly(1, t, domain="QQ"), Poly(x, t)], Matrix([[-1, 0, 1]]))
def test_derivation(): p = Poly(4*x**4*t**5 + (-4*x**3 - 4*x**4)*t**4 + (-3*x**2 + 2*x**3)*t**3 + (2*x + 7*x**2 + 2*x**3)*t**2 + (1 - 4*x - 4*x**2)*t - 1 + 2*x, t) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(-t**2 - 3/(2*x)*t + 1/(2*x), t)]}) assert derivation(p, DE) == Poly(-20*x**4*t**6 + (2*x**3 + 16*x**4)*t**5 + (21*x**2 + 12*x**3)*t**4 + (7*x/2 - 25*x**2 - 12*x**3)*t**3 + (-5 - 15*x/2 + 7*x**2)*t**2 - (3 - 8*x - 10*x**2 - 4*x**3)/(2*x)*t + (1 - 4*x**2)/(2*x), t) assert derivation(Poly(1, t), DE) == Poly(0, t) assert derivation(Poly(t, t), DE) == DE.d assert derivation(Poly(t**2 + 1/x*t + (1 - 2*x)/(4*x**2), t), DE) == \ Poly(-2*t**3 - 4/x*t**2 - (5 - 2*x)/(2*x**2)*t - (1 - 2*x)/(2*x**3), t, domain='ZZ(x)') DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1/x, t1), Poly(t, t)]}) assert derivation(Poly(x*t*t1, t), DE) == Poly(t*t1 + x*t*t1 + t, t) assert derivation(Poly(x*t*t1, t), DE, coefficientD=True) == \ Poly((1 + t1)*t, t) DE = DifferentialExtension(extension={'D': [Poly(1, x)]}) assert derivation(Poly(x, x), DE) == Poly(1, x) # Test basic option assert derivation((x + 1)/(x - 1), DE, basic=True) == -2/(1 - 2*x + x**2) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]}) assert derivation((t + 1)/(t - 1), DE, basic=True) == -2*t/(1 - 2*t + t**2) assert derivation(t + 1, DE, basic=True) == t
def test_DifferentialExtension_printing(): DE = DifferentialExtension(exp(2*x**2) + log(exp(x**2) + 1), x) assert repr(DE) == ("DifferentialExtension(dict([('f', exp(2*x**2) + log(exp(x**2) + 1)), " "('x', x), ('T', [x, t0, t1]), ('D', [Poly(1, x, domain='ZZ'), Poly(2*x*t0, t0, domain='ZZ[x]'), " "Poly(2*t0*x/(t0 + 1), t1, domain='ZZ(x,t0)')]), ('fa', Poly(t1 + t0**2, t1, domain='ZZ[t0]')), " "('fd', Poly(1, t1, domain='ZZ')), ('Tfuncs', [Lambda(i, exp(i**2)), Lambda(i, log(t0 + 1))]), " "('backsubs', []), ('exts', [None, 'exp', 'log']), ('extargs', [None, x**2, t0 + 1]), " "('cases', ['base', 'exp', 'primitive']), ('case', 'primitive'), ('t', t1), " "('d', Poly(2*t0*x/(t0 + 1), t1, domain='ZZ(x,t0)')), ('newf', t0**2 + t1), ('level', -1), " "('dummy', False)]))") assert str(DE) == ("DifferentialExtension({fa=Poly(t1 + t0**2, t1, domain='ZZ[t0]'), " "fd=Poly(1, t1, domain='ZZ'), D=[Poly(1, x, domain='ZZ'), Poly(2*x*t0, t0, domain='ZZ[x]'), " "Poly(2*t0*x/(t0 + 1), t1, domain='ZZ(x,t0)')]})")
def test_prde_special_denom(): a = Poly(t + 1, t) ba = Poly(t**2, t) bd = Poly(1, t) G = [(Poly(t, t), Poly(1, t)), (Poly(t**2, t), Poly(1, t)), (Poly(t**3, t), Poly(1, t))] DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]}) assert prde_special_denom(a, ba, bd, G, DE) == \ (Poly(t + 1, t), Poly(t**2, t), [(Poly(t, t), Poly(1, t)), (Poly(t**2, t), Poly(1, t)), (Poly(t**3, t), Poly(1, t))], Poly(1, t)) G = [(Poly(t, t), Poly(1, t)), (Poly(1, t), Poly(t, t))] assert prde_special_denom(Poly(1, t), Poly(t**2, t), Poly(1, t), G, DE) == \ (Poly(1, t), Poly(t**2 - 1, t), [(Poly(t**2, t), Poly(1, t)), (Poly(1, t), Poly(1, t))], Poly(t, t))
def test_limited_integrate(): DE = DifferentialExtension(extension={"D": [Poly(1, x)]}) G = [(Poly(x, x), Poly(x + 1, x))] assert limited_integrate( Poly(-(1 + x + 5 * x ** 2 - 3 * x ** 3), x), Poly(1 - x - x ** 2 + x ** 3, x), G, DE, ) == ((Poly(x ** 2 - x + 2, x), Poly(x - 1, x)), [2]) G = [(Poly(1, x), Poly(x, x))] assert limited_integrate(Poly(5 * x ** 2, x), Poly(3, x), G, DE) == ( (Poly(5 * x ** 3 / 9, x), Poly(1, x)), [0], )
def test_DifferentialExtension_log(): assert DifferentialExtension( log(x) * log(x + 1) * log(2 * x ** 2 + 2 * x), x )._important_attrs == ( Poly(t0 * t1 ** 2 + (t0 * log(2) + t0 ** 2) * t1, t1), Poly(1, t1), [Poly(1, x), Poly(1 / x, t0), Poly(1 / (x + 1), t1, expand=False)], [x, t0, t1], [Lambda(i, log(i)), Lambda(i, log(i + 1))], [], [None, "log", "log"], [None, x, x + 1], ) assert DifferentialExtension(x ** x * log(x), x)._important_attrs == ( Poly(t0 * t1, t1), Poly(1, t1), [Poly(1, x), Poly(1 / x, t0), Poly((1 + t0) * t1, t1)], [x, t0, t1], [Lambda(i, log(i)), Lambda(i, exp(t0 * i))], [(exp(x * log(x)), x ** x)], [None, "log", "exp"], [None, x, t0 * x], )
def test_constant_system(): A = Matrix( [ [-(x + 3) / (x - 1), (x + 1) / (x - 1), 1], [-x - 3, x + 1, x - 1], [2 * (x + 3) / (x - 1), 0, 0], ] ) u = Matrix([(x + 1) / (x - 1), x + 1, 0]) DE = DifferentialExtension(extension={"D": [Poly(1, x)]}) assert constant_system(A, u, DE) == ( Matrix([[1, 0, 0], [0, 1, 0], [0, 0, 0], [0, 0, 1]]), Matrix([0, 1, 0, 0]), )
def test_laurent_series(): DE = DifferentialExtension(extension={"D": [Poly(1, x), Poly(1, t)]}) a = Poly(36, t) d = Poly((t - 2) * (t ** 2 - 1) ** 2, t) F = Poly(t ** 2 - 1, t) n = 2 assert laurent_series(a, d, F, n, DE) == ( Poly(-3 * t ** 3 + 3 * t ** 2 - 6 * t - 8, t), Poly(t ** 5 + t ** 4 - 2 * t ** 3 - 2 * t ** 2 + t + 1, t), [ Poly(-3 * t ** 3 - 6 * t ** 2, t), Poly(2 * t ** 6 + 6 * t ** 5 - 8 * t ** 3, t), ], )
def test_DifferentialExtension_exp(): i = Symbol('i') assert DifferentialExtension(exp(x) + exp(x**2), x, dummy=False)._important_attrs == \ (Poly(t1 + t0, t1), Poly(1, t1), [Poly(1, x,), Poly(t0, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i)), Lambda(i, exp(i**2))], [], [1, 2], [x, x**2], [], []) assert DifferentialExtension(exp(x) + exp(2*x), x, dummy=False)._important_attrs == \ (Poly(t0**2 + t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0, t0)], [x, t0], [Lambda(i, exp(i))], [], [1], [x], [], []) assert DifferentialExtension(exp(x) + exp(x/2), x, dummy=False)._important_attrs == \ (Poly(t0**2 + t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0/2, t0)], [x, t0], [Lambda(i, exp(i/2))], [], [1], [x/2], [], []) assert DifferentialExtension(exp(x) + exp(x**2) + exp(x + x**2), x, dummy=False)._important_attrs == \ (Poly((1 + t0)*t1 + t0, t1), Poly(1, t1), [Poly(1, x), Poly(t0, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i)), Lambda(i, exp(i**2))], [], [1, 2], [x, x**2], [], []) assert DifferentialExtension(exp(x) + exp(x**2) + exp(x + x**2 + 1), x, dummy=False)._important_attrs == \ (Poly((1 + S.Exp1*t0)*t1 + t0, t1), Poly(1, t1), [Poly(1, x), Poly(t0, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i)), Lambda(i, exp(i**2))], [], [1, 2], [x, x**2], [], []) assert DifferentialExtension(exp(x) + exp(x**2) + exp(x/2 + x**2), x, dummy=False)._important_attrs == \ (Poly((t0 + 1)*t1 + t0**2, t1), Poly(1, t1), [Poly(1, x), Poly(t0/2, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i/2)), Lambda(i, exp(i**2))], [(exp(x/2), sqrt(exp(x)))], [1, 2], [x/2, x**2], [], []) assert DifferentialExtension(exp(x) + exp(x**2) + exp(x/2 + x**2 + 3), x, dummy=False)._important_attrs == \ (Poly((t0*exp(3) + 1)*t1 + t0**2, t1), Poly(1, t1), [Poly(1, x), Poly(t0/2, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i/2)), Lambda(i, exp(i**2))], [(exp(x/2), sqrt(exp(x)))], [1, 2], [x/2, x**2], [], []) assert DifferentialExtension(sqrt(exp(x)), x, dummy=False)._important_attrs == \ (Poly(t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0/2, t0)], [x, t0], [Lambda(i, exp(i/2))], [(exp(x/2), sqrt(exp(x)))], [1], [x/2], [], []) assert DifferentialExtension(exp(x/2), x, dummy=False)._important_attrs == \ (Poly(t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0/2, t0)], [x, t0], [Lambda(i, exp(i/2))], [], [1], [x/2], [], [])
def test_prde_no_cancel(): # b large DE = DifferentialExtension(extension={'D': [Poly(1, x)]}) assert prde_no_cancel_b_large(Poly(1, x), [Poly(x**2, x), Poly(1, x)], 2, DE) == \ ([Poly(x**2 - 2*x + 2, x), Poly(1, x)], Matrix([[1, 0, -1, 0], [0, 1, 0, -1]])) assert prde_no_cancel_b_large(Poly(1, x), [Poly(x**3, x), Poly(1, x)], 3, DE) == \ ([Poly(x**3 - 3*x**2 + 6*x - 6, x), Poly(1, x)], Matrix([[1, 0, -1, 0], [0, 1, 0, -1]])) # b small # XXX: Is there a better example of a monomial with D.degree() > 2? DE = DifferentialExtension( extension={'D': [Poly(1, x), Poly(t**3 + 1, t)]}) # My original q was t**4 + t + 1, but this solution implies q == t**4 # (c1 = 4), with some of the ci for the original q equal to 0. G = [ Poly(t**6, t), Poly(x * t**5, t), Poly(t**3, t), Poly(x * t**2, t), Poly(1 + x, t) ] assert prde_no_cancel_b_small(Poly(x*t, t), G, 4, DE) == \ ([Poly(t**4/4 - x/12*t**3 + x**2/24*t**2 + (-S(11)/12 - x**3/24)*t + x/24, t), Poly(x/3*t**3 - x**2/6*t**2 + (-S(1)/3 + x**3/6)*t - x/6, t), Poly(t, t), Poly(0, t), Poly(0, t)], Matrix([[1, 0, -1, 0, 0, 0, 0, 0, 0, 0], [0, 1, -S(1)/4, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, -1, 0, 0, 0, 0], [0, 1, 0, 0, 0, 0, -1, 0, 0, 0], [0, 0, 1, 0, 0, 0, 0, -1, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0, -1, 0], [0, 0, 0, 0, 1, 0, 0, 0, 0, -1]]))
def test_integrate_nonlinear_no_specials(): a, d, = Poly( x**2 * t**5 + x * t**4 - nu**2 * t**3 - x * (x**2 + 1) * t**2 - (x**2 - nu**2) * t - x**5 / 4, t), Poly( x**2 * t**4 + x**2 * (x**2 + 2) * t**2 + x**2 + x**4 + x**6 / 4, t) # f(x) == phi_nu(x), the logarithmic derivative of J_v, the Bessel function, # which has no specials (see Chapter 5, note 4 of Bronstein's book). f = Function('phi_nu') DE = DifferentialExtension( extension={ 'D': [Poly(1, x), Poly(-t**2 - t / x - (1 - nu**2 / x**2), t)], 'Tfuncs': [f] }) assert integrate_nonlinear_no_specials(a, d, DE) == \ (-log(1 + f(x)**2 + x**2/2)/2 - (4 + x**2)/(4 + 2*x**2 + 4*f(x)**2), True) assert integrate_nonlinear_no_specials(Poly(t, t), Poly(1, t), DE) == \ (0, False)
def test_DifferentialExtension_exp(): assert DifferentialExtension(exp(x) + exp(x**2), x)._important_attrs == \ (Poly(t1 + t0, t1), Poly(1, t1), [Poly(1, x,), Poly(t0, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i)), Lambda(i, exp(i**2))], [], [None, 'exp', 'exp'], [None, x, x**2]) assert DifferentialExtension(exp(x) + exp(2*x), x)._important_attrs == \ (Poly(t0**2 + t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0, t0)], [x, t0], [Lambda(i, exp(i))], [], [None, 'exp'], [None, x]) assert DifferentialExtension(exp(x) + exp(x/2), x)._important_attrs == \ (Poly(t0**2 + t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0/2, t0)], [x, t0], [Lambda(i, exp(i/2))], [], [None, 'exp'], [None, x/2]) assert DifferentialExtension(exp(x) + exp(x**2) + exp(x + x**2), x)._important_attrs == \ (Poly((1 + t0)*t1 + t0, t1), Poly(1, t1), [Poly(1, x), Poly(t0, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i)), Lambda(i, exp(i**2))], [], [None, 'exp', 'exp'], [None, x, x**2]) assert DifferentialExtension(exp(x) + exp(x**2) + exp(x + x**2 + 1), x)._important_attrs == \ (Poly((1 + S.Exp1*t0)*t1 + t0, t1), Poly(1, t1), [Poly(1, x), Poly(t0, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i)), Lambda(i, exp(i**2))], [], [None, 'exp', 'exp'], [None, x, x**2]) assert DifferentialExtension(exp(x) + exp(x**2) + exp(x/2 + x**2), x)._important_attrs == \ (Poly((t0 + 1)*t1 + t0**2, t1), Poly(1, t1), [Poly(1, x), Poly(t0/2, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i/2)), Lambda(i, exp(i**2))], [(exp(x/2), sqrt(exp(x)))], [None, 'exp', 'exp'], [None, x/2, x**2]) assert DifferentialExtension(exp(x) + exp(x**2) + exp(x/2 + x**2 + 3), x)._important_attrs == \ (Poly((t0*exp(3) + 1)*t1 + t0**2, t1), Poly(1, t1), [Poly(1, x), Poly(t0/2, t0), Poly(2*x*t1, t1)], [x, t0, t1], [Lambda(i, exp(i/2)), Lambda(i, exp(i**2))], [(exp(x/2), sqrt(exp(x)))], [None, 'exp', 'exp'], [None, x/2, x**2]) assert DifferentialExtension(sqrt(exp(x)), x)._important_attrs == \ (Poly(t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0/2, t0)], [x, t0], [Lambda(i, exp(i/2))], [(exp(x/2), sqrt(exp(x)))], [None, 'exp'], [None, x/2]) assert DifferentialExtension(exp(x/2), x)._important_attrs == \ (Poly(t0, t0), Poly(1, t0), [Poly(1, x), Poly(t0/2, t0)], [x, t0], [Lambda(i, exp(i/2))], [], [None, 'exp'], [None, x/2])
def test_DecrementLevel(): DE = DifferentialExtension(x * log(exp(x) + 1), x) assert DE.level == -1 assert DE.t == t1 assert DE.d == Poly(t0 / (t0 + 1), t1) assert DE.case == "primitive" with DecrementLevel(DE): assert DE.level == -2 assert DE.t == t0 assert DE.d == Poly(t0, t0) assert DE.case == "exp" with DecrementLevel(DE): assert DE.level == -3 assert DE.t == x assert DE.d == Poly(1, x) assert DE.case == "base" assert DE.level == -2 assert DE.t == t0 assert DE.d == Poly(t0, t0) assert DE.case == "exp" assert DE.level == -1 assert DE.t == t1 assert DE.d == Poly(t0 / (t0 + 1), t1) assert DE.case == "primitive" # Test that __exit__ is called after an exception correctly try: with DecrementLevel(DE): raise _TestingException except _TestingException: pass else: raise AssertionError("Did not raise.") assert DE.level == -1 assert DE.t == t1 assert DE.d == Poly(t0 / (t0 + 1), t1) assert DE.case == "primitive"
def test_bound_degree_fail(): # Primitive DE = DifferentialExtension( extension={"D": [Poly(1, x), Poly(t0 / x ** 2, t0), Poly(1 / x, t)]} ) assert ( bound_degree( Poly(t ** 2, t), Poly(-(1 / x ** 2 * t ** 2 + 1 / x), t), Poly( (2 * x - 1) * t ** 4 + (t0 + x) / x * t ** 3 - (t0 + 4 * x ** 2) / 2 * x * t ** 2 + x * t, t, ), DE, ) == 3 )
def test_param_poly_rischDE(): DE = DifferentialExtension(extension={"D": [Poly(1, x)]}) a = Poly(x ** 2 - x, x, field=True) b = Poly(1, x, field=True) q = [Poly(x, x, field=True), Poly(x ** 2, x, field=True)] h, A = param_poly_rischDE(a, b, q, 3, DE) assert A.nullspace() == [Matrix([0, 1, 1, 1])] # c1, c2, d1, d2 # Solution of a*Dp + b*p = c1*q1 + c2*q2 = q2 = x**2 # is d1*h1 + d2*h2 = h1 + h2 = x. assert h[0] + h[1] == Poly(x, x) # a*Dp + b*p = q1 = x has no solution. a = Poly(x ** 2 - x, x, field=True) b = Poly(x ** 2 - 5 * x + 3, x, field=True) q = [Poly(1, x, field=True), Poly(x, x, field=True), Poly(x ** 2, x, field=True)] h, A = param_poly_rischDE(a, b, q, 3, DE) assert A.nullspace() == [Matrix([3, -5, 1, -5, 1, 1])] p = -5 * h[0] + h[1] + h[2] # Poly(1, x) assert a * derivation(p, DE) + b * p == Poly(x ** 2 - 5 * x + 3, x)
def test_integrate_hyperexponential(): # TODO: Add tests for integrate_hyperexponential() from the book a = Poly((1 + 2*t1 + t1**2 + 2*t1**3)*t**2 + (1 + t1**2)*t + 1 + t1**2, t) d = Poly(1, t) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1 + t1**2, t1), Poly(t*(1 + t1**2), t)], 'Tfuncs': [tan, lambda x: exp(tan(x))]}) assert integrate_hyperexponential(a, d, DE) == \ (exp(2*tan(x))*tan(x) + exp(tan(x)), 1 + t1**2, True) # exp(2*tan(x))*tan(x) + tan(x) + exp(tan(x)) a = Poly((t1**3 + (x + 1)*t1**2 + t1 + x + 2)*t, t) assert integrate_hyperexponential(a, d, DE) == \ ((x + tan(x))*exp(tan(x)), 0, True) a = Poly(t, t) d = Poly(1, t) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(2*x*t, t)], 'Tfuncs': [lambda x: exp(x**2)]}) assert integrate_hyperexponential(a, d, DE) == \ (0, NonElementaryIntegral(exp(x**2), x), False) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)], 'Tfuncs': [exp]}) assert integrate_hyperexponential(a, d, DE) == (exp(x), 0, True) a = Poly(25*t**6 - 10*t**5 + 7*t**4 - 8*t**3 + 13*t**2 + 2*t - 1, t) d = Poly(25*t**6 + 35*t**4 + 11*t**2 + 1, t) assert integrate_hyperexponential(a, d, DE) == \ (-(55 - 50*exp(x))/(25 + 125*exp(2*x)) + log(1 + exp(2*x)), -1, True) # -(55 - 50*exp(x))/(25 + 125*exp(2*x)) - x + log(1 + exp(2*x)) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t0, t0), Poly(t0*t, t)], 'Tfuncs': [exp, lambda x: exp(exp(x))]}) assert integrate_hyperexponential(Poly(2*t0*t**2, t), Poly(1, t), DE) == (exp(2*exp(x)), 0, True) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t0, t0), Poly(-t0*t, t)], 'Tfuncs': [exp, lambda x: exp(-exp(x))]}) assert integrate_hyperexponential(Poly(-27*exp(9) - 162*t0*exp(9) + 27*x*t0*exp(9), t), Poly((36*exp(18) + x**2*exp(18) - 12*x*exp(18))*t, t), DE) == \ (27*exp(exp(x))/(-6*exp(9) + x*exp(9)), 0, True) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)], 'Tfuncs': [exp]}) assert integrate_hyperexponential(Poly(x**2/2*t, t), Poly(1, t), DE) == \ ((2 - 2*x + x**2)*exp(x)/2, 0, True) assert integrate_hyperexponential(Poly(1 + t, t), Poly(t, t), DE) == \ (-exp(-x), 1, True) # x - exp(-x) assert integrate_hyperexponential(Poly(x, t), Poly(t + 1, t), DE) == \ (0, NonElementaryIntegral(x/(1 + exp(x)), x), False)
def test_special_denom(): # TODO: add more tests here DE = DifferentialExtension(extension={"D": [Poly(1, x), Poly(t, t)]}) assert special_denom( Poly(1, t), Poly(t ** 2, t), Poly(1, t), Poly(t ** 2 - 1, t), Poly(t, t), DE ) == (Poly(1, t), Poly(t ** 2 - 1, t), Poly(t ** 2 - 1, t), Poly(t, t)) # assert special_denom(Poly(1, t), Poly(2*x, t), Poly((1 + 2*x)*t, t), DE) == 1 # issue 3940 # Note, this isn't a very good test, because the denominator is just 1, # but at least it tests the exp cancellation case DE = DifferentialExtension( extension={"D": [Poly(1, x), Poly(-2 * x * t0, t0), Poly(I * k * t1, t1)]} ) DE.decrement_level() assert special_denom( Poly(1, t0), Poly(I * k, t0), Poly(1, t0), Poly(t0, t0), Poly(1, t0), DE ) == (Poly(1, t0), Poly(I * k, t0), Poly(t0, t0), Poly(1, t0)) assert special_denom( Poly(1, t), Poly(t ** 2, t), Poly(1, t), Poly(t ** 2 - 1, t), Poly(t, t), DE, case="tan", ) == ( Poly(1, t, t0, domain="ZZ"), Poly(t ** 2, t0, t, domain="ZZ[x]"), Poly(t, t, t0, domain="ZZ"), Poly(1, t0, domain="ZZ"), ) raises( ValueError, lambda: special_denom( Poly(1, t), Poly(t ** 2, t), Poly(1, t), Poly(t ** 2 - 1, t), Poly(t, t), DE, case="unrecognized_case", ), )
def test_special_denom(): # TODO: add more tests here DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]}) assert special_denom(Poly(1, t), Poly(t**2, t), Poly(1, t), Poly(t**2 - 1, t), Poly(t, t), DE) == \ (Poly(1, t), Poly(t**2 - 1, t), Poly(t**2 - 1, t), Poly(t, t)) # assert special_denom(Poly(1, t), Poly(2*x, t), Poly((1 + 2*x)*t, t), DE) == 1 # issue 3940 # Note, this isn't a very good test, because the denominator is just 1, # but at least it tests the exp cancellation case DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(-2*x*t0, t0), Poly(I*k*t1, t1)]}) DE.decrement_level() assert special_denom(Poly(1, t0), Poly(I*k, t0), Poly(1, t0), Poly(t0, t0), Poly(1, t0), DE) == \ (Poly(1, t0), Poly(I*k, t0), Poly(t0, t0), Poly(1, t0))
def test_integrate_hyperexponential_polynomial(): # Without proper cancellation within integrate_hyperexponential_polynomial(), # this will take a long time to complete, and will return a complicated # expression p = Poly( (-28 * x**11 * t0 - 6 * x**8 * t0 + 6 * x**9 * t0 - 15 * x**8 * t0**2 + 15 * x**7 * t0**2 + 84 * x**10 * t0**2 - 140 * x**9 * t0**3 - 20 * x**6 * t0**3 + 20 * x**7 * t0**3 - 15 * x**6 * t0**4 + 15 * x**5 * t0**4 + 140 * x**8 * t0**4 - 84 * x**7 * t0**5 - 6 * x**4 * t0**5 + 6 * x**5 * t0**5 + x**3 * t0**6 - x**4 * t0**6 + 28 * x**6 * t0**6 - 4 * x**5 * t0**7 + x**9 - x**10 + 4 * x**12) / (-8 * x**11 * t0 + 28 * x**10 * t0**2 - 56 * x**9 * t0**3 + 70 * x**8 * t0**4 - 56 * x**7 * t0**5 + 28 * x**6 * t0**6 - 8 * x**5 * t0**7 + x**4 * t0**8 + x**12) * t1**2 + (-28 * x**11 * t0 - 12 * x**8 * t0 + 12 * x**9 * t0 - 30 * x**8 * t0**2 + 30 * x**7 * t0**2 + 84 * x**10 * t0**2 - 140 * x**9 * t0**3 - 40 * x**6 * t0**3 + 40 * x**7 * t0**3 - 30 * x**6 * t0**4 + 30 * x**5 * t0**4 + 140 * x**8 * t0**4 - 84 * x**7 * t0**5 - 12 * x**4 * t0**5 + 12 * x**5 * t0**5 - 2 * x**4 * t0**6 + 2 * x**3 * t0**6 + 28 * x**6 * t0**6 - 4 * x**5 * t0**7 + 2 * x**9 - 2 * x**10 + 4 * x**12) / (-8 * x**11 * t0 + 28 * x**10 * t0**2 - 56 * x**9 * t0**3 + 70 * x**8 * t0**4 - 56 * x**7 * t0**5 + 28 * x**6 * t0**6 - 8 * x**5 * t0**7 + x**4 * t0**8 + x**12) * t1 + (-2 * x**2 * t0 + 2 * x**3 * t0 + x * t0**2 - x**2 * t0**2 + x**3 - x**4) / (-4 * x**5 * t0 + 6 * x**4 * t0**2 - 4 * x**3 * t0**3 + x**2 * t0**4 + x**6), t1, z, expand=False) DE = DifferentialExtension( extension={'D': [Poly(1, x), Poly(1 / x, t0), Poly(2 * x * t1, t1)]}) assert integrate_hyperexponential_polynomial(p, DE, z) == (Poly( (x - t0) * t1**2 + (-2 * t0 + 2 * x) * t1, t1), Poly(-2 * x * t0 + x**2 + t0**2, t1), True)
def test_spde(): DE = DifferentialExtension( extension={'D': [Poly(1, x), Poly(t**2 + 1, t)]}) raises( NonElementaryIntegralException, lambda: spde(Poly(t, t), Poly((t - 1) * (t**2 + 1), t), Poly(1, t), 0, DE)) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(t, t)]}) assert spde(Poly(t**2 + x*t*2 + x**2, t), Poly(t**2/x**2 + (2/x - 1)*t, t), Poly(t**2/x**2 + (2/x - 1)*t, t), 0, DE) == \ (Poly(0, t), Poly(0, t), 0, Poly(0, t), Poly(1, t)) DE = DifferentialExtension( extension={'D': [Poly(1, x), Poly(t0 / x**2, t0), Poly(1 / x, t)]}) assert spde(Poly(t**2, t), Poly(-t**2/x**2 - 1/x, t), Poly((2*x - 1)*t**4 + (t0 + x)/x*t**3 - (t0 + 4*x**2)/(2*x)*t**2 + x*t, t), 3, DE) == \ (Poly(0, t), Poly(0, t), 0, Poly(0, t), Poly(t0*t**2/2 + x**2*t**2 - x**2*t, t)) DE = DifferentialExtension(extension={'D': [Poly(1, x)]}) assert spde(Poly(x**2 + x + 1, x), Poly(-2*x - 1, x), Poly(x**5/2 + 3*x**4/4 + x**3 - x**2 + 1, x), 4, DE) == \ (Poly(0, x), Poly(x/2 - S(1)/4, x), 2, Poly(x**2 + x + 1, x), Poly(5*x/4, x)) assert spde(Poly(x**2 + x + 1, x), Poly(-2*x - 1, x), Poly(x**5/2 + 3*x**4/4 + x**3 - x**2 + 1, x), n, DE) == \ (Poly(0, x), Poly(x/2 - S(1)/4, x), -2 + n, Poly(x**2 + x + 1, x), Poly(5*x/4, x)) DE = DifferentialExtension(extension={'D': [Poly(1, x), Poly(1, t)]}) raises( NonElementaryIntegralException, lambda: spde(Poly((t - 1) * (t**2 + 1)**2, t), Poly( (t - 1) * (t**2 + 1), t), Poly(1, t), 0, DE)) DE = DifferentialExtension(extension={'D': [Poly(1, x)]}) assert spde(Poly(x**2 - x, x), Poly(1, x), Poly(9 * x**4 - 10 * x**3 + 2 * x**2, x), 4, DE) == (Poly(0, x), Poly(0, x), 0, Poly(0, x), Poly(3 * x**3 - 2 * x**2, x)) assert spde(Poly(x**2 - x, x), Poly(x**2 - 5*x + 3, x), Poly(x**7 - x**6 - 2*x**4 + 3*x**3 - x**2, x), 5, DE) == \ (Poly(1, x), Poly(x + 1, x), 1, Poly(x**4 - x**3, x), Poly(x**3 - x**2, x))
def test_integrate_hyperexponential(): # TODO: Add tests for integrate_hyperexponential() from the book a = Poly( (1 + 2 * t1 + t1 ** 2 + 2 * t1 ** 3) * t ** 2 + (1 + t1 ** 2) * t + 1 + t1 ** 2, t, ) d = Poly(1, t) DE = DifferentialExtension( extension={ "D": [Poly(1, x), Poly(1 + t1 ** 2, t1), Poly(t * (1 + t1 ** 2), t)], "Tfuncs": [tan, Lambda(i, exp(tan(i)))], } ) assert integrate_hyperexponential(a, d, DE) == ( exp(2 * tan(x)) * tan(x) + exp(tan(x)), 1 + t1 ** 2, True, ) a = Poly((t1 ** 3 + (x + 1) * t1 ** 2 + t1 + x + 2) * t, t) assert integrate_hyperexponential(a, d, DE) == ((x + tan(x)) * exp(tan(x)), 0, True) a = Poly(t, t) d = Poly(1, t) DE = DifferentialExtension( extension={ "D": [Poly(1, x), Poly(2 * x * t, t)], "Tfuncs": [Lambda(i, exp(x ** 2))], } ) assert integrate_hyperexponential(a, d, DE) == ( 0, NonElementaryIntegral(exp(x ** 2), x), False, ) DE = DifferentialExtension( extension={"D": [Poly(1, x), Poly(t, t)], "Tfuncs": [exp]} ) assert integrate_hyperexponential(a, d, DE) == (exp(x), 0, True) a = Poly( 25 * t ** 6 - 10 * t ** 5 + 7 * t ** 4 - 8 * t ** 3 + 13 * t ** 2 + 2 * t - 1, t ) d = Poly(25 * t ** 6 + 35 * t ** 4 + 11 * t ** 2 + 1, t) assert integrate_hyperexponential(a, d, DE) == ( -(11 - 10 * exp(x)) / (5 + 25 * exp(2 * x)) + log(1 + exp(2 * x)), -1, True, ) DE = DifferentialExtension( extension={ "D": [Poly(1, x), Poly(t0, t0), Poly(t0 * t, t)], "Tfuncs": [exp, Lambda(i, exp(exp(i)))], } ) assert integrate_hyperexponential(Poly(2 * t0 * t ** 2, t), Poly(1, t), DE) == ( exp(2 * exp(x)), 0, True, ) DE = DifferentialExtension( extension={ "D": [Poly(1, x), Poly(t0, t0), Poly(-t0 * t, t)], "Tfuncs": [exp, Lambda(i, exp(-exp(i)))], } ) assert integrate_hyperexponential( Poly(-27 * exp(9) - 162 * t0 * exp(9) + 27 * x * t0 * exp(9), t), Poly((36 * exp(18) + x ** 2 * exp(18) - 12 * x * exp(18)) * t, t), DE, ) == (27 * exp(exp(x)) / (-6 * exp(9) + x * exp(9)), 0, True) DE = DifferentialExtension( extension={"D": [Poly(1, x), Poly(t, t)], "Tfuncs": [exp]} ) assert integrate_hyperexponential(Poly(x ** 2 / 2 * t, t), Poly(1, t), DE) == ( (2 - 2 * x + x ** 2) * exp(x) / 2, 0, True, ) assert integrate_hyperexponential(Poly(1 + t, t), Poly(t, t), DE) == ( -exp(-x), 1, True, ) # x - exp(-x) assert integrate_hyperexponential(Poly(x, t), Poly(t + 1, t), DE) == ( 0, NonElementaryIntegral(x / (1 + exp(x)), x), False, ) DE = DifferentialExtension( extension={ "D": [Poly(1, x), Poly(1 / x, t0), Poly(2 * x * t1, t1)], "Tfuncs": [log, Lambda(i, exp(i ** 2))], } ) elem, nonelem, b = integrate_hyperexponential( Poly( (8 * x ** 7 - 12 * x ** 5 + 6 * x ** 3 - x) * t1 ** 4 + ( 8 * t0 * x ** 7 - 8 * t0 * x ** 6 - 4 * t0 * x ** 5 + 2 * t0 * x ** 3 + 2 * t0 * x ** 2 - t0 * x + 24 * x ** 8 - 36 * x ** 6 - 4 * x ** 5 + 22 * x ** 4 + 4 * x ** 3 - 7 * x ** 2 - x + 1 ) * t1 ** 3 + ( 8 * t0 * x ** 8 - 4 * t0 * x ** 6 - 16 * t0 * x ** 5 - 2 * t0 * x ** 4 + 12 * t0 * x ** 3 + t0 * x ** 2 - 2 * t0 * x + 24 * x ** 9 - 36 * x ** 7 - 8 * x ** 6 + 22 * x ** 5 + 12 * x ** 4 - 7 * x ** 3 - 6 * x ** 2 + x + 1 ) * t1 ** 2 + ( 8 * t0 * x ** 8 - 8 * t0 * x ** 6 - 16 * t0 * x ** 5 + 6 * t0 * x ** 4 + 10 * t0 * x ** 3 - 2 * t0 * x ** 2 - t0 * x + 8 * x ** 10 - 12 * x ** 8 - 4 * x ** 7 + 2 * x ** 6 + 12 * x ** 5 + 3 * x ** 4 - 9 * x ** 3 - x ** 2 + 2 * x ) * t1 + 8 * t0 * x ** 7 - 12 * t0 * x ** 6 - 4 * t0 * x ** 5 + 8 * t0 * x ** 4 - t0 * x ** 2 - 4 * x ** 7 + 4 * x ** 6 + 4 * x ** 5 - 4 * x ** 4 - x ** 3 + x ** 2, t1, ), Poly( (8 * x ** 7 - 12 * x ** 5 + 6 * x ** 3 - x) * t1 ** 4 + ( 24 * x ** 8 + 8 * x ** 7 - 36 * x ** 6 - 12 * x ** 5 + 18 * x ** 4 + 6 * x ** 3 - 3 * x ** 2 - x ) * t1 ** 3 + ( 24 * x ** 9 + 24 * x ** 8 - 36 * x ** 7 - 36 * x ** 6 + 18 * x ** 5 + 18 * x ** 4 - 3 * x ** 3 - 3 * x ** 2 ) * t1 ** 2 + ( 8 * x ** 10 + 24 * x ** 9 - 12 * x ** 8 - 36 * x ** 7 + 6 * x ** 6 + 18 * x ** 5 - x ** 4 - 3 * x ** 3 ) * t1 + 8 * x ** 10 - 12 * x ** 8 + 6 * x ** 6 - x ** 4, t1, ), DE, ) assert factor(elem) == -((x - 1) * log(x) / ((x + exp(x ** 2)) * (2 * x ** 2 - 1))) assert (nonelem, b) == ( NonElementaryIntegral(exp(x ** 2) / (exp(x ** 2) + 1), x), False, )
def test_residue_reduce(): a = Poly(2 * t ** 2 - t - x ** 2, t) d = Poly(t ** 3 - x ** 2 * t, t) DE = DifferentialExtension( extension={"D": [Poly(1, x), Poly(1 / x, t)], "Tfuncs": [log]} ) assert residue_reduce(a, d, DE, z, invert=False) == ( [ ( Poly(z ** 2 - Rational(1, 4), z), Poly( (1 + 3 * x * z - 6 * z ** 2 - 2 * x ** 2 + 4 * x ** 2 * z ** 2) * t - x * z + x ** 2 + 2 * x ** 2 * z ** 2 - 2 * z * x ** 3, t, ), ) ], False, ) assert residue_reduce(a, d, DE, z, invert=True) == ( [(Poly(z ** 2 - Rational(1, 4), z), Poly(t + 2 * x * z, t))], False, ) assert residue_reduce( Poly(-2 / x, t), Poly(t ** 2 - 1, t,), DE, z, invert=False ) == ([(Poly(z ** 2 - 1, z), Poly(-2 * z * t / x - 2 / x, t))], True) ans = residue_reduce(Poly(-2 / x, t), Poly(t ** 2 - 1, t), DE, z, invert=True) assert ans == ([(Poly(z ** 2 - 1, z), Poly(t + z, t))], True) assert residue_reduce_to_basic(ans[0], DE, z) == -log(-1 + log(x)) + log(1 + log(x)) DE = DifferentialExtension( extension={ "D": [Poly(1, x), Poly(-(t ** 2) - t / x - (1 - nu ** 2 / x ** 2), t)] } ) # TODO: Skip or make faster assert residue_reduce( Poly((-2 * nu ** 2 - x ** 4) / (2 * x ** 2) * t - (1 + x ** 2) / x, t), Poly(t ** 2 + 1 + x ** 2 / 2, t), DE, z, ) == ( [ ( Poly(z + S.Half, z, domain="QQ"), Poly(t ** 2 + 1 + x ** 2 / 2, t, domain="EX"), ) ], True, ) DE = DifferentialExtension(extension={"D": [Poly(1, x), Poly(1 + t ** 2, t)]}) assert residue_reduce( Poly(-2 * x * t + 1 - x ** 2, t), Poly(t ** 2 + 2 * x * t + 1 + x ** 2, t), DE, z, ) == ([(Poly(z ** 2 + Rational(1, 4), z), Poly(t + x + 2 * z, t))], True) DE = DifferentialExtension(extension={"D": [Poly(1, x), Poly(t, t)]}) assert residue_reduce(Poly(t, t), Poly(t + sqrt(2), t), DE, z) == ( [(Poly(z - 1, z), Poly(t + sqrt(2), t))], True, )
def test_hermite_reduce(): DE = DifferentialExtension(extension={"D": [Poly(1, x), Poly(t ** 2 + 1, t)]}) assert hermite_reduce(Poly(x - t, t), Poly(t ** 2, t), DE) == ( (Poly(-x, t), Poly(t, t)), (Poly(0, t), Poly(1, t)), (Poly(-x, t), Poly(1, t)), ) DE = DifferentialExtension( extension={ "D": [Poly(1, x), Poly(-(t ** 2) - t / x - (1 - nu ** 2 / x ** 2), t)] } ) assert hermite_reduce( Poly( x ** 2 * t ** 5 + x * t ** 4 - nu ** 2 * t ** 3 - x * (x ** 2 + 1) * t ** 2 - (x ** 2 - nu ** 2) * t - x ** 5 / 4, t, ), Poly( x ** 2 * t ** 4 + x ** 2 * (x ** 2 + 2) * t ** 2 + x ** 2 + x ** 4 + x ** 6 / 4, t, ), DE, ) == ( (Poly(-(x ** 2) - 4, t), Poly(4 * t ** 2 + 2 * x ** 2 + 4, t)), ( Poly((-2 * nu ** 2 - x ** 4) * t - (2 * x ** 3 + 2 * x), t), Poly(2 * x ** 2 * t ** 2 + x ** 4 + 2 * x ** 2, t), ), (Poly(x * t + 1, t), Poly(x, t)), ) DE = DifferentialExtension(extension={"D": [Poly(1, x), Poly(1 / x, t)]}) a = Poly( (-2 + 3 * x) * t ** 3 + (-1 + x) * t ** 2 + (-4 * x + 2 * x ** 2) * t + x ** 2, t, ) d = Poly( x * t ** 6 - 4 * x ** 2 * t ** 5 + 6 * x ** 3 * t ** 4 - 4 * x ** 4 * t ** 3 + x ** 5 * t ** 2, t, ) assert hermite_reduce(a, d, DE) == ( ( Poly(3 * t ** 2 + t + 3 * x, t), Poly(3 * t ** 4 - 9 * x * t ** 3 + 9 * x ** 2 * t ** 2 - 3 * x ** 3 * t, t), ), (Poly(0, t), Poly(1, t)), (Poly(0, t), Poly(1, t)), ) assert hermite_reduce( Poly(-(t ** 2) + 2 * t + 2, t), Poly(-x * t ** 2 + 2 * x * t - x, t), DE ) == ( (Poly(3, t), Poly(t - 1, t)), (Poly(0, t), Poly(1, t)), (Poly(1, t), Poly(x, t)), ) assert hermite_reduce( Poly( -(x ** 2) * t ** 6 + (-1 - 2 * x ** 3 + x ** 4) * t ** 3 + (-3 - 3 * x ** 4) * t ** 2 - 2 * x * t - x - 3 * x ** 2, t, ), Poly(x ** 4 * t ** 6 - 2 * x ** 2 * t ** 3 + 1, t), DE, ) == ( (Poly(x ** 3 * t + x ** 4 + 1, t), Poly(x ** 3 * t ** 3 - x, t)), (Poly(0, t), Poly(1, t)), (Poly(-1, t), Poly(x ** 2, t)), ) assert hermite_reduce( Poly( (-2 + 3 * x) * t ** 3 + (-1 + x) * t ** 2 + (-4 * x + 2 * x ** 2) * t + x ** 2, t, ), Poly( x * t ** 6 - 4 * x ** 2 * t ** 5 + 6 * x ** 3 * t ** 4 - 4 * x ** 4 * t ** 3 + x ** 5 * t ** 2, t, ), DE, ) == ( ( Poly(3 * t ** 2 + t + 3 * x, t), Poly(3 * t ** 4 - 9 * x * t ** 3 + 9 * x ** 2 * t ** 2 - 3 * x ** 3 * t, t), ), (Poly(0, t), Poly(1, t)), (Poly(0, t), Poly(1, t)), )
def test_DifferentialExtension_equality(): DE1 = DE2 = DifferentialExtension(log(x), x) assert DE1 == DE2