def test__eis(): assert _eis(z).diff(z) == -_eis(z) + 1 / z pytest.raises(ArgumentIndexError, lambda: _eis(x).fdiff(2)) assert _eis(1/z).series(z) == \ z + z**2 + 2*z**3 + 6*z**4 + 24*z**5 + O(z**6) assert Ei(z).rewrite('tractable') == exp(z) * _eis(z) assert li(z).rewrite('tractable') == z * _eis(log(z)) assert _eis(z).rewrite('intractable') == exp(-z) * Ei(z) assert expand(li(z).rewrite('tractable').diff(z).rewrite('intractable')) \ == li(z).diff(z) assert expand(Ei(z).rewrite('tractable').diff(z).rewrite('intractable')) \ == Ei(z).diff(z) assert _eis(z).series( z, n=2) == EulerGamma + log(z) + z * (-log(z) - EulerGamma + 1) + z**2 * ( log(z) / 2 - Rational(3, 4) + EulerGamma / 2) + O(z**2) l = Limit(Ei(y / x) / exp(y / x), x, 0) assert l.doit() == l # cover _eis._eval_aseries
def test_order_noncommutative(): A = Symbol('A', commutative=False) assert O(A + A * x, x) == O(1, x) assert (A + A * x) * O(x) == O(x) assert (A * x) * O(x) == O(x**2, x) assert expand((1 + O(x)) * A * A * x) == A * A * x + O(x**2, x) assert expand((A * A + O(x)) * x) == A * A * x + O(x**2, x) assert expand((A + O(x)) * A * x) == A * A * x + O(x**2, x)
def test_expand_frac(): assert expand((x + y)*y/x/(x + 1), frac=True) == \ (x*y + y**2)/(x**2 + x) assert expand((x + y)*y/x/(x + 1), numer=True) == \ (x*y + y**2)/(x*(x + 1)) assert expand((x + y)*y/x/(x + 1), denom=True) == \ y*(x + y)/(x**2 + x) eq = (x + 1)**2 / y assert expand_numer(eq, multinomial=False) == eq
def test_expand_frac(): assert expand((x + y)*y/x/(x + 1), frac=True) == \ (x*y + y**2)/(x**2 + x) assert expand((x + y)*y/x/(x + 1), numer=True) == \ (x*y + y**2)/(x*(x + 1)) assert expand((x + y)*y/x/(x + 1), denom=True) == \ y*(x + y)/(x**2 + x) eq = (x + 1)**2/y assert expand_numer(eq, multinomial=False) == eq
def test_piecewise_fold_expand(): p1 = Piecewise((1, Interval(0, 1, False, True).contains(x)), (0, True)) p2 = piecewise_fold(expand((1 - x)*p1)) assert p2 == Piecewise((1 - x, Interval(0, 1, False, True).contains(x)), (Piecewise((-x, Interval(0, 1, False, True).contains(x)), (0, True)), True)) p2 = expand(piecewise_fold((1 - x)*p1)) assert p2 == Piecewise( (1 - x, Interval(0, 1, False, True).contains(x)), (0, True))
def decide_termination(program: Program): """ The main function, gathering all the information, deciding on and calling a proof-rule """ reset_mora() branch_store.set_program(program) bound_store.set_program(program) lgc = get_loop_guard_change(program) me_pos = create_martingale_expression(program) me_neg = expand(me_pos * (-1)) log(f"Martingale expression: {me_pos.as_expr()}", LOG_ESSENTIAL) rules = [ InitialStateRule(lgc, me_pos, program), RankingSMRule(lgc, me_pos, program), SupermartingaleRule(lgc, me_pos, program), RepulsingSMRule(lgc, me_neg, program) ] result = Result() for rule in rules: if rule.is_applicable(): result = rule.run(result) if result.all_known(): break return result
def test_sympyissues_5919_6830(): # issue sympy/sympy#5919 n = -1 + 1 / x z = n / x / (-n)**2 - 1 / n / x assert expand( z) == 1 / (x**2 - 2 * x + 1) - 1 / (x - 2 + 1 / x) - 1 / (-x + 1) # issue sympy/sympy#6830 p = (1 + x)**2 assert expand_multinomial( (1 + x * p)**2) == (x**2 * (x**4 + 4 * x**3 + 6 * x**2 + 4 * x + 1) + 2 * x * (x**2 + 2 * x + 1) + 1) assert expand_multinomial( (1 + (y + x) * p)**2) == (2 * ((x + y) * (x**2 + 2 * x + 1)) + (x**2 + 2 * x * y + y**2) * (x**4 + 4 * x**3 + 6 * x**2 + 4 * x + 1) + 1) A = Symbol('A', commutative=False) p = (1 + A)**2 assert expand_multinomial( (1 + x * p)**2) == (x**2 * (1 + 4 * A + 6 * A**2 + 4 * A**3 + A**4) + 2 * x * (1 + 2 * A + A**2) + 1) assert expand_multinomial( (1 + (y + x) * p)**2) == ((x + y) * (1 + 2 * A + A**2) * 2 + (x**2 + 2 * x * y + y**2) * (1 + 4 * A + 6 * A**2 + 4 * A**3 + A**4) + 1) assert expand_multinomial((1 + (y + x) * p)**3) == ( (x + y) * (1 + 2 * A + A**2) * 3 + (x**2 + 2 * x * y + y**2) * (1 + 4 * A + 6 * A**2 + 4 * A**3 + A**4) * 3 + (x**3 + 3 * x**2 * y + 3 * x * y**2 + y**3) * (1 + 6 * A + 15 * A**2 + 20 * A**3 + 15 * A**4 + 6 * A**5 + A**6) + 1) # unevaluate powers eq = (Pow((x + 1) * ((A + 1)**2), 2, evaluate=False)) # - in this case the base is not an Add so no further # expansion is done assert expand_multinomial(eq) == \ (x**2 + 2*x + 1)*(1 + 4*A + 6*A**2 + 4*A**3 + A**4) # - but here, the expanded base *is* an Add so it gets expanded eq = (Pow(((A + 1)**2), 2, evaluate=False)) assert expand_multinomial(eq) == 1 + 4 * A + 6 * A**2 + 4 * A**3 + A**4 # coverage def ok(a, b, n): e = (a + I * b)**n return verify_numerically(e, expand_multinomial(e)) for a in [2, Rational(1, 2)]: for b in [3, Rational(1, 3)]: for n in range(2, 6): assert ok(a, b, n) assert expand_multinomial((x + 1 + O(z))**2) == \ 1 + 2*x + x**2 + O(z) assert expand_multinomial((x + 1 + O(z))**3) == \ 1 + 3*x + 3*x**2 + x**3 + O(z) e = (sin(x) + y)**3 assert (expand_multinomial(e.subs({y: O(x**4)})) == expand_multinomial(e).subs({y: O(x**4)}) == sin(x)**3 + O(x**6)) assert expand_multinomial(3**(x + y + 3)) == 27 * 3**(x + y)
def can_do_meijer(a1, a2, b1, b2, numeric=True): """ This helper function tries to hyperexpand() the meijer g-function corresponding to the parameters a1, a2, b1, b2. It returns False if this expansion still contains g-functions. If numeric is True, it also tests the so-obtained formula numerically (at random values) and returns False if the test fails. Else it returns True. """ r = hyperexpand(meijerg(a1, a2, b1, b2, z)) if r.has(meijerg): return False # NOTE hyperexpand() returns a truly branched function, whereas numerical # evaluation only works on the main branch. Since we are evaluating on # the main branch, this should not be a problem, but expressions like # exp_polar(I*pi/2*x)**a are evaluated incorrectly. We thus have to get # rid of them. The expand heuristically does this... r = unpolarify(expand(r, force=True, power_base=True, power_exp=False, mul=False, log=False, multinomial=False, basic=False)) if not numeric: return True repl = {} for n, a in enumerate(meijerg(a1, a2, b1, b2, z).free_symbols - {z}): repl[a] = randcplx(n) return tn(meijerg(a1, a2, b1, b2, z).subs(repl), r.subs(repl), z)
def compute_solution_for_recurrence(recurr_coeff: Expr, inhom_part_solution: Expr, initial_value: Expr): """ Computes the (unique) solution to the recurrence relation: f(0) = initial_value; f(n+1) = recurr_coeff * f(n) + inhom_part_solution """ log( f"Start compute solution for recurrence, { recurr_coeff }, { inhom_part_solution }, { initial_value }", LOG_VERBOSE) n = symbols('n', integer=True, positive=True) if recurr_coeff.is_zero: return expand(inhom_part_solution.xreplace({n: n - 1})) hom_solution = (recurr_coeff**n) * initial_value k = symbols('_k', integer=True, positive=True) summand = simplify( (recurr_coeff**k) * inhom_part_solution.xreplace({n: (n - 1) - k})) particular_solution = summation(summand, (k, 0, (n - 1))) particular_solution = without_piecewise(particular_solution) solution = simplify(hom_solution + particular_solution) log( f"End compute solution for recurrence, { recurr_coeff }, { inhom_part_solution }, { initial_value }", LOG_VERBOSE) return solution
def compute_recurrence(program: Program, monomial: Poly): """ Iteratively splits a monomial on variables which are dependent with respect to the given monomial """ log(f"Start compute recurrence, { monomial.as_expr() }", LOG_VERBOSE) result = monomial.as_expr() split_variables = set() for variable, update in reversed(program.updates.items()): if variable not in result.free_symbols: continue if update.is_random_var: result = replace_rv_in_polynomial( program, result.as_poly(program.variables), variable).as_expr() continue split_variables.add(variable) branches = split_expression_on_variable(program, result, variable) log(f"Start combining {len(branches)} branches", LOG_VERBOSE) result = sum([prob * branch for branch, prob in branches]) log(f"Mid combining branches", LOG_VERBOSE) result = expand(result) log(f"End combining branches", LOG_VERBOSE) log(f"End compute recurrence, { monomial.as_expr() }", LOG_VERBOSE) return result.as_poly(program.variables)
def can_do_meijer(a1, a2, b1, b2, numeric=True): """ This helper function tries to hyperexpand() the meijer g-function corresponding to the parameters a1, a2, b1, b2. It returns False if this expansion still contains g-functions. If numeric is True, it also tests the so-obtained formula numerically (at random values) and returns False if the test fails. Else it returns True. """ from diofant import unpolarify, expand r = hyperexpand(meijerg(a1, a2, b1, b2, z)) if r.has(meijerg): return False # NOTE hyperexpand() returns a truly branched function, whereas numerical # evaluation only works on the main branch. Since we are evaluating on # the main branch, this should not be a problem, but expressions like # exp_polar(I*pi/2*x)**a are evaluated incorrectly. We thus have to get # rid of them. The expand heuristically does this... r = unpolarify(expand(r, force=True, power_base=True, power_exp=False, mul=False, log=False, multinomial=False, basic=False)) if not numeric: return True repl = {} for n, a in enumerate(meijerg(a1, a2, b1, b2, z).free_symbols - {z}): repl[a] = randcplx(n) return tn(meijerg(a1, a2, b1, b2, z).subs(repl), r.subs(repl), z)
def test_Piecewise(): e1 = x * (x + y) - y * (x + y) e2 = sin(x)**2 + cos(x)**2 e3 = expand((x + y) * y / x) s1 = simplify(e1) s2 = simplify(e2) s3 = simplify(e3) assert simplify(Piecewise((e1, x < e2), (e3, True))) == \ Piecewise((s1, x < s2), (s3, True))
def test__erfs(): assert _erfs(z).diff(z) == -2/sqrt(S.Pi) + 2*z*_erfs(z) assert _erfs(1/z).series(z) == \ z/sqrt(pi) - z**3/(2*sqrt(pi)) + 3*z**5/(4*sqrt(pi)) + O(z**6) assert expand(erf(z).rewrite('tractable').diff(z).rewrite('intractable')) \ == erf(z).diff(z) assert _erfs(z).rewrite("intractable") == (-erf(z) + 1)*exp(z**2)
def get_loop_guard_change(program: Program): """ Returns E[LG_{n+1} - LG_{n}] """ n = symbols("n", integer=True, positive=True) lg = sympify(LOOP_GUARD_VAR).as_poly(program.variables) expected_lg = get_expected(program, lg) expected_lg_plus = expected_lg.xreplace({n: n + 1}) return expand(expected_lg_plus - expected_lg)
def test__erfs(): assert _erfs(z).diff(z) == -2 / sqrt(pi) + 2 * z * _erfs(z) pytest.raises(ArgumentIndexError, lambda: _erfs(x).fdiff(2)) assert _erfs(1/z).series(z) == \ z/sqrt(pi) - z**3/(2*sqrt(pi)) + 3*z**5/(4*sqrt(pi)) + O(z**6) assert expand(erf(z).rewrite('tractable').diff(z).rewrite('intractable')) \ == erf(z).diff(z) assert _erfs(z).rewrite('intractable') == (-erf(z) + 1) * exp(z**2)
def test__eis(): assert _eis(z).diff(z) == -_eis(z) + 1/z assert _eis(1/z).series(z) == \ z + z**2 + 2*z**3 + 6*z**4 + 24*z**5 + O(z**6) assert Ei(z).rewrite('tractable') == exp(z)*_eis(z) assert li(z).rewrite('tractable') == z*_eis(log(z)) assert _eis(z).rewrite('intractable') == exp(-z)*Ei(z) assert expand(li(z).rewrite('tractable').diff(z).rewrite('intractable')) \ == li(z).diff(z) assert expand(Ei(z).rewrite('tractable').diff(z).rewrite('intractable')) \ == Ei(z).diff(z) assert _eis(z).series(z, n=2) == EulerGamma + log(z) + z*(-log(z) - EulerGamma + 1) + z**2*(log(z)/2 - Rational(3, 4) + EulerGamma/2) + O(z**2)
def test__erfs(): assert _erfs(z).diff(z) == -2/sqrt(pi) + 2*z*_erfs(z) pytest.raises(ArgumentIndexError, lambda: _erfs(x).fdiff(2)) assert _erfs(1/z).series(z) == \ z/sqrt(pi) - z**3/(2*sqrt(pi)) + 3*z**5/(4*sqrt(pi)) + O(z**6) assert expand(erf(z).rewrite('tractable').diff(z).rewrite('intractable')) \ == erf(z).diff(z) assert _erfs(z).rewrite("intractable") == (-erf(z) + 1)*exp(z**2)
def create_martingale_expression(program: Program): """ Creates the martingale expression E(M_{i+1} - M_i | F_i). Also deterministic variables get substituted with their representation in n. """ lg = symbols(LOOP_GUARD_VAR).as_poly(program.variables) expected_guard = get_recurrence(program, lg) lg = program.updates[symbols(LOOP_GUARD_VAR)].branches[0][0] expression = expand(expected_guard - lg).as_expr() expression = substitute_deterministic_variables(expression, program) return simplify(expression)
def test_sympyissues_5919_6830(): # issue sympy/sympy#5919 n = -1 + 1/x z = n/x/(-n)**2 - 1/n/x assert expand(z) == 1/(x**2 - 2*x + 1) - 1/(x - 2 + 1/x) - 1/(-x + 1) # issue sympy/sympy#6830 p = (1 + x)**2 assert expand_multinomial((1 + x*p)**2) == ( x**2*(x**4 + 4*x**3 + 6*x**2 + 4*x + 1) + 2*x*(x**2 + 2*x + 1) + 1) assert expand_multinomial((1 + (y + x)*p)**2) == ( 2*((x + y)*(x**2 + 2*x + 1)) + (x**2 + 2*x*y + y**2) * (x**4 + 4*x**3 + 6*x**2 + 4*x + 1) + 1) A = Symbol('A', commutative=False) p = (1 + A)**2 assert expand_multinomial((1 + x*p)**2) == ( x**2*(1 + 4*A + 6*A**2 + 4*A**3 + A**4) + 2*x*(1 + 2*A + A**2) + 1) assert expand_multinomial((1 + (y + x)*p)**2) == ( (x + y)*(1 + 2*A + A**2)*2 + (x**2 + 2*x*y + y**2) * (1 + 4*A + 6*A**2 + 4*A**3 + A**4) + 1) assert expand_multinomial((1 + (y + x)*p)**3) == ( (x + y)*(1 + 2*A + A**2)*3 + (x**2 + 2*x*y + y**2)*(1 + 4*A + 6*A**2 + 4*A**3 + A**4)*3 + (x**3 + 3*x**2*y + 3*x*y**2 + y**3)*(1 + 6*A + 15*A**2 + 20*A**3 + 15*A**4 + 6*A**5 + A**6) + 1) # unevaluate powers eq = (Pow((x + 1)*((A + 1)**2), 2, evaluate=False)) # - in this case the base is not an Add so no further # expansion is done assert expand_multinomial(eq) == \ (x**2 + 2*x + 1)*(1 + 4*A + 6*A**2 + 4*A**3 + A**4) # - but here, the expanded base *is* an Add so it gets expanded eq = (Pow(((A + 1)**2), 2, evaluate=False)) assert expand_multinomial(eq) == 1 + 4*A + 6*A**2 + 4*A**3 + A**4 # coverage def ok(a, b, n): e = (a + I*b)**n return verify_numerically(e, expand_multinomial(e)) for a in [2, Rational(1, 2)]: for b in [3, Rational(1, 3)]: for n in range(2, 6): assert ok(a, b, n) assert expand_multinomial((x + 1 + O(z))**2) == \ 1 + 2*x + x**2 + O(z) assert expand_multinomial((x + 1 + O(z))**3) == \ 1 + 3*x + 3*x**2 + x**3 + O(z) e = (sin(x) + y)**3 assert (expand_multinomial(e.subs({y: O(x**4)})) == expand_multinomial(e).subs({y: O(x**4)}) == sin(x)**3 + O(x**6)) assert expand_multinomial(3**(x + y + 3)) == 27*3**(x + y)
def test_Piecewise(): e1 = x * (x + y) - y * (x + y) e2 = sin(x)**2 + cos(x)**2 e3 = expand((x + y) * y / x) s1 = simplify(e1) s2 = simplify(e2) s3 = simplify(e3) assert simplify(Piecewise((e1, x < e2), (e3, True))) == \ Piecewise((s1, x < s2), (s3, True)) # trigsimp tries not to touch non-trig containing args assert trigsimp(Piecewise((e1, e3 < e2), (e3, True))) == \ Piecewise((e1, e3 < s2), (e3, True))
def test_Piecewise(): e1 = x*(x + y) - y*(x + y) e2 = sin(x)**2 + cos(x)**2 e3 = expand((x + y)*y/x) s1 = simplify(e1) s2 = simplify(e2) s3 = simplify(e3) assert simplify(Piecewise((e1, x < e2), (e3, True))) == \ Piecewise((s1, x < s2), (s3, True)) # trigsimp tries not to touch non-trig containing args assert trigsimp(Piecewise((e1, e3 < e2), (e3, True))) == \ Piecewise((e1, e3 < s2), (e3, True))
def test__eis(): assert _eis(z).diff(z) == -_eis(z) + 1/z pytest.raises(ArgumentIndexError, lambda: _eis(x).fdiff(2)) assert _eis(1/z).series(z) == \ z + z**2 + 2*z**3 + 6*z**4 + 24*z**5 + O(z**6) assert Ei(z).rewrite('tractable') == exp(z)*_eis(z) assert li(z).rewrite('tractable') == z*_eis(log(z)) assert _eis(z).rewrite('intractable') == exp(-z)*Ei(z) assert expand(li(z).rewrite('tractable').diff(z).rewrite('intractable')) \ == li(z).diff(z) assert expand(Ei(z).rewrite('tractable').diff(z).rewrite('intractable')) \ == Ei(z).diff(z) assert _eis(z).series(z, n=2) == EulerGamma + log(z) + z*(-log(z) - EulerGamma + 1) + z**2*(log(z)/2 - Rational(3, 4) + EulerGamma/2) + O(z**2) l = Limit(Ei(y/x)/exp(y/x), x, 0) assert l.doit() == l # cover _eis._eval_aseries
def get_inhom_part_solution(program: Program, inhom_part: Poly): """ For a given inhomogenous part of the assignment of a monomial replace the monomials in the inhom part by their closed form solutions. """ log(f"Start get inhom_part_solution, { inhom_part.as_expr() }", LOG_VERBOSE) monomials = get_monoms(inhom_part) result = inhom_part.coeff_monomial(1) for monomial in monomials: solution = get_solution(program, monomial) monomial = monomial.as_expr() result += inhom_part.coeff_monomial(monomial) * solution log(f"End get inhom_part_solution, {inhom_part.as_expr()}", LOG_VERBOSE) return expand(result)
def test_expand_non_commutative(): A = Symbol('A', commutative=False) B = Symbol('B', commutative=False) C = Symbol('C', commutative=False) a = Symbol('a') b = Symbol('b') i = Symbol('i', integer=True) n = Symbol('n', negative=True) m = Symbol('m', negative=True) p = Symbol('p', polar=True) np = Symbol('p', polar=False) assert (C * (A + B)).expand() == C * A + C * B assert (C * (A + B)).expand() != A * C + B * C assert ((A + B)**2).expand() == A**2 + A * B + B * A + B**2 assert ((A + B)**3).expand() == (A**2 * B + B**2 * A + A * B**2 + B * A**2 + A**3 + B**3 + A * B * A + B * A * B) # issue 6219 assert ((a * A * B * A**-1)**2).expand() == a**2 * A * B**2 / A # Note that (a*A*B*A**-1)**2 is automatically converted to a**2*(A*B*A**-1)**2 assert ((a * A * B * A**-1)**2).expand(deep=False) == a**2 * (A * B * A**-1)**2 assert ((a * A * B * A**-1)**2).expand() == a**2 * (A * B**2 * A**-1) assert ((a * A * B * A**-1)**2).expand(force=True) == a**2 * A * B**2 * A**(-1) assert ((a * A * B)**2).expand() == a**2 * A * B * A * B assert ((a * A)**2).expand() == a**2 * A**2 assert ((a * A * B)**i).expand() == a**i * (A * B)**i assert ((a * A * (B * (A * B / A)**2))**i).expand() == a**i * (A * B * A * B**2 / A)**i # issue 6558 assert (A * B * (A * B)**-1).expand() == A * B * (A * B)**-1 assert ((a * A)**i).expand() == a**i * A**i assert ((a * A * B * A**-1)**3).expand() == a**3 * A * B**3 / A assert ((a*A*B*A*B/A)**3).expand() == \ a**3*A*B*(A*B**2)*(A*B**2)*A*B*A**(-1) assert ((a*A*B*A*B/A)**-3).expand() == \ a**-3*(A*B*(A*B**2)*(A*B**2)*A*B*A**(-1))**-1 assert ((a * b * A * B * A**-1)**i).expand() == a**i * b**i * (A * B / A)**i assert ((a * (a * b)**i)**i).expand() == a**i * a**(i**2) * b**(i**2) e = Pow(Mul(a, 1 / a, A, B, evaluate=False), Integer(2), evaluate=False) assert e.expand() == A * B * A * B assert sqrt(a * (A * b)**i).expand() == sqrt(a * b**i * A**i) assert (sqrt(-a)**a).expand() == sqrt(-a)**a assert expand((-2 * n)**(i / 3)) == 2**(i / 3) * (-n)**(i / 3) assert expand( (-2 * n * m)**(i / a)) == (-2)**(i / a) * (-n)**(i / a) * (-m)**(i / a) assert expand((-2 * a * p)**b) == 2**b * p**b * (-a)**b assert expand((-2 * a * np)**b) == 2**b * (-a * np)**b assert expand(sqrt(A * B)) == sqrt(A * B) assert expand(sqrt(-2 * a * b)) == sqrt(2) * sqrt(-a * b)
def test_expand_non_commutative(): A = Symbol('A', commutative=False) B = Symbol('B', commutative=False) C = Symbol('C', commutative=False) a = Symbol('a') b = Symbol('b') i = Symbol('i', integer=True) n = Symbol('n', negative=True) m = Symbol('m', negative=True) p = Symbol('p', polar=True) np = Symbol('p', polar=False) assert (C*(A + B)).expand() == C*A + C*B assert (C*(A + B)).expand() != A*C + B*C assert ((A + B)**2).expand() == A**2 + A*B + B*A + B**2 assert ((A + B)**3).expand() == (A**2*B + B**2*A + A*B**2 + B*A**2 + A**3 + B**3 + A*B*A + B*A*B) # issue sympy/sympy#6219 assert ((a*A*B*A**-1)**2).expand() == a**2*A*B**2/A # Note that (a*A*B*A**-1)**2 is automatically converted to a**2*(A*B*A**-1)**2 assert ((a*A*B*A**-1)**2).expand(deep=False) == a**2*(A*B*A**-1)**2 assert ((a*A*B*A**-1)**2).expand() == a**2*(A*B**2*A**-1) assert ((a*A*B*A**-1)**2).expand(force=True) == a**2*A*B**2*A**(-1) assert ((a*A*B)**2).expand() == a**2*A*B*A*B assert ((a*A)**2).expand() == a**2*A**2 assert ((a*A*B)**i).expand() == a**i*(A*B)**i assert ((a*A*(B*(A*B/A)**2))**i).expand() == a**i*(A*B*A*B**2/A)**i # issue sympy/sympy#6558 assert (A*B*(A*B)**-1).expand() == A*B*(A*B)**-1 assert ((a*A)**i).expand() == a**i*A**i assert ((a*A*B*A**-1)**3).expand() == a**3*A*B**3/A assert ((a*A*B*A*B/A)**3).expand() == \ a**3*A*B*(A*B**2)*(A*B**2)*A*B*A**(-1) assert ((a*A*B*A*B/A)**-3).expand() == \ a**-3*(A*B*(A*B**2)*(A*B**2)*A*B*A**(-1))**-1 assert ((a*b*A*B*A**-1)**i).expand() == a**i*b**i*(A*B/A)**i assert ((a*(a*b)**i)**i).expand() == a**i*a**(i**2)*b**(i**2) e = Pow(Mul(a, 1/a, A, B, evaluate=False), Integer(2), evaluate=False) assert e.expand() == A*B*A*B assert sqrt(a*(A*b)**i).expand() == sqrt(a*b**i*A**i) assert (sqrt(-a)**a).expand() == sqrt(-a)**a assert expand((-2*n)**(i/3)) == 2**(i/3)*(-n)**(i/3) assert expand((-2*n*m)**(i/a)) == (-2)**(i/a)*(-n)**(i/a)*(-m)**(i/a) assert expand((-2*a*p)**b) == 2**b*p**b*(-a)**b assert expand((-2*a*np)**b) == 2**b*(-a*np)**b assert expand(sqrt(A*B)) == sqrt(A*B) assert expand(sqrt(-2*a*b)) == sqrt(2)*sqrt(-a*b)
def test_sign(): assert sign(1.2) == 1 assert sign(-1.2) == -1 assert sign(3*I) == I assert sign(-3*I) == -I assert sign(0) == 0 assert sign(nan) == nan assert sign(2 + 2*I).doit() == sqrt(2)*(2 + 2*I)/4 assert sign(2 + 3*I).simplify() == sign(2 + 3*I) assert sign(2 + 2*I).simplify() == sign(1 + I) assert sign(im(sqrt(1 - sqrt(3)))) == 1 assert sign(sqrt(1 - sqrt(3))) == I x = Symbol('x') assert sign(x).is_finite is True assert sign(x).is_complex is True assert sign(x).is_imaginary is None assert sign(x).is_integer is None assert sign(x).is_extended_real is None assert sign(x).is_zero is None assert sign(x).doit() == sign(x) assert sign(1.2*x) == sign(x) assert sign(2*x) == sign(x) assert sign(I*x) == I*sign(x) assert sign(-2*I*x) == -I*sign(x) assert sign(conjugate(x)) == conjugate(sign(x)) p = Symbol('p', positive=True) n = Symbol('n', negative=True) m = Symbol('m', negative=True) assert sign(2*p*x) == sign(x) assert sign(n*x) == -sign(x) assert sign(n*m*x) == sign(x) x = Symbol('x', imaginary=True) xn = Symbol('xn', imaginary=True, nonzero=True) assert sign(x).is_imaginary is True assert sign(x).is_integer is None assert sign(x).is_extended_real is None assert sign(x).is_zero is None assert sign(x).diff(x) == 2*DiracDelta(-I*x) assert sign(xn).doit() == xn / Abs(xn) assert conjugate(sign(x)) == -sign(x) x = Symbol('x', extended_real=True) assert sign(x).is_imaginary is None assert sign(x).is_integer is True assert sign(x).is_extended_real is True assert sign(x).is_zero is None assert sign(x).diff(x) == 2*DiracDelta(x) assert sign(x).doit() == sign(x) assert conjugate(sign(x)) == sign(x) assert sign(sin(x)).nseries(x) == 1 y = Symbol('y') assert sign(x*y).nseries(x).removeO() == sign(y) x = Symbol('x', nonzero=True) assert sign(x).is_imaginary is None assert sign(x).is_integer is None assert sign(x).is_extended_real is None assert sign(x).is_zero is False assert sign(x).doit() == x / Abs(x) assert sign(Abs(x)) == 1 assert Abs(sign(x)) == 1 x = Symbol('x', positive=True) assert sign(x).is_imaginary is False assert sign(x).is_integer is True assert sign(x).is_extended_real is True assert sign(x).is_zero is False assert sign(x).doit() == x / Abs(x) assert sign(Abs(x)) == 1 assert Abs(sign(x)) == 1 x = 0 assert sign(x).is_imaginary is True assert sign(x).is_integer is True assert sign(x).is_extended_real is True assert sign(x).is_zero is True assert sign(x).doit() == 0 assert sign(Abs(x)) == 0 assert Abs(sign(x)) == 0 nz = Symbol('nz', nonzero=True, integer=True) assert sign(nz).is_imaginary is False assert sign(nz).is_integer is True assert sign(nz).is_extended_real is True assert sign(nz).is_zero is False assert sign(nz)**2 == 1 assert (sign(nz)**3).args == (sign(nz), 3) assert sign(Symbol('x', nonnegative=True)).is_nonnegative assert sign(Symbol('x', nonnegative=True)).is_nonpositive is None assert sign(Symbol('x', nonpositive=True)).is_nonnegative is None assert sign(Symbol('x', nonpositive=True)).is_nonpositive assert sign(Symbol('x', extended_real=True)).is_nonnegative is None assert sign(Symbol('x', extended_real=True)).is_nonpositive is None assert sign(Symbol('x', extended_real=True, zero=False)).is_nonpositive is None x, y = Symbol('x', extended_real=True), Symbol('y') assert sign(x).rewrite(Piecewise) == \ Piecewise((1, x > 0), (-1, x < 0), (0, True)) assert sign(y).rewrite(Piecewise) == sign(y) assert sign(x).rewrite(Heaviside) == 2*Heaviside(x)-1 assert sign(y).rewrite(Heaviside) == sign(y) # evaluate what can be evaluated assert sign(exp_polar(I*pi)*pi) is Integer(-1) eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) # if there is a fast way to know when and when you cannot prove an # expression like this is zero then the equality to zero is ok assert sign(eq) == 0 q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6) p = cbrt(expand(q**3)) d = p - q assert sign(d) == 0 assert abs(sign(z)) == Abs(sign(z), evaluate=False)
def simp(x): return simplify(expand_trig(expand_complex(expand(x))))
def test_meijerint(): s, t, mu = symbols('s t mu', extended_real=True) assert integrate(meijerg([], [], [0], [], s*t) * meijerg([], [], [mu/2], [-mu/2], t**2/4), (t, 0, oo)).is_Piecewise s = symbols('s', positive=True) assert integrate(x**s*meijerg([[], []], [[0], []], x), (x, 0, oo)) == \ gamma(s + 1) assert integrate(x**s*meijerg([[], []], [[0], []], x), (x, 0, oo), meijerg=True) == gamma(s + 1) assert isinstance(integrate(x**s*meijerg([[], []], [[0], []], x), (x, 0, oo), meijerg=False), Integral) assert meijerint_indefinite(exp(x), x) == exp(x) # TODO what simplifications should be done automatically? # This tests "extra case" for antecedents_1. a, b = symbols('a b', positive=True) assert simplify(meijerint_definite(x**a, x, 0, b)[0]) == \ b**(a + 1)/(a + 1) # This tests various conditions and expansions: meijerint_definite((x + 1)**3*exp(-x), x, 0, oo) == (16, True) # Again, how about simplifications? sigma, mu = symbols('sigma mu', positive=True) i, c = meijerint_definite(exp(-((x - mu)/(2*sigma))**2), x, 0, oo) assert simplify(i) == sqrt(pi)*sigma*(erf(mu/(2*sigma)) + 1) assert c i, _ = meijerint_definite(exp(-mu*x)*exp(sigma*x), x, 0, oo) # TODO it would be nice to test the condition assert simplify(i) == 1/(mu - sigma) # Test substitutions to change limits assert meijerint_definite(exp(x), x, -oo, 2) == (exp(2), True) # Note: causes a NaN in _check_antecedents assert expand(meijerint_definite(exp(x), x, 0, I)[0]) == exp(I) - 1 assert expand(meijerint_definite(exp(-x), x, 0, x)[0]) == \ 1 - exp(-exp(I*arg(x))*abs(x)) # Test -oo to oo assert meijerint_definite(exp(-x**2), x, -oo, oo) == (sqrt(pi), True) assert meijerint_definite(exp(-abs(x)), x, -oo, oo) == (2, True) assert meijerint_definite(exp(-(2*x - 3)**2), x, -oo, oo) == \ (sqrt(pi)/2, True) assert meijerint_definite(exp(-abs(2*x - 3)), x, -oo, oo) == (1, True) assert meijerint_definite(exp(-((x - mu)/sigma)**2/2)/sqrt(2*pi*sigma**2), x, -oo, oo) == (1, True) # Test one of the extra conditions for 2 g-functinos assert meijerint_definite(exp(-x)*sin(x), x, 0, oo) == (Rational(1, 2), True) # Test a bug def res(n): return (1/(1 + x**2)).diff(x, n).subs({x: 1})*(-1)**n for n in range(6): assert integrate(exp(-x)*sin(x)*x**n, (x, 0, oo), meijerg=True) == \ res(n) # This used to test trigexpand... now it is done by linear substitution assert simplify(integrate(exp(-x)*sin(x + a), (x, 0, oo), meijerg=True) ) == sqrt(2)*sin(a + pi/4)/2 # Test the condition 14 from prudnikov. # (This is besselj*besselj in disguise, to stop the product from being # recognised in the tables.) a, b, s = symbols('a b s') assert meijerint_definite(meijerg([], [], [a/2], [-a/2], x/4) * meijerg([], [], [b/2], [-b/2], x/4)*x**(s - 1), x, 0, oo) == \ (4*2**(2*s - 2)*gamma(-2*s + 1)*gamma(a/2 + b/2 + s) / (gamma(-a/2 + b/2 - s + 1)*gamma(a/2 - b/2 - s + 1) * gamma(a/2 + b/2 - s + 1)), And(0 < -2*re(4*s) + 8, 0 < re(a/2 + b/2 + s), re(2*s) < 1)) # test a bug assert integrate(sin(x**a)*sin(x**b), (x, 0, oo), meijerg=True) == \ Integral(sin(x**a)*sin(x**b), (x, 0, oo)) # test better hyperexpand assert integrate(exp(-x**2)*log(x), (x, 0, oo), meijerg=True) == \ (sqrt(pi)*polygamma(0, Rational(1, 2))/4).expand() # Test hyperexpand bug. n = symbols('n', integer=True) assert simplify(integrate(exp(-x)*x**n, x, meijerg=True)) == \ lowergamma(n + 1, x) # Test a bug with argument 1/x alpha = symbols('alpha', positive=True) assert meijerint_definite((2 - x)**alpha*sin(alpha/x), x, 0, 2) == \ (sqrt(pi)*alpha*gamma(alpha + 1)*meijerg(((), (alpha/2 + Rational(1, 2), alpha/2 + 1)), ((0, 0, Rational(1, 2)), (-Rational(1, 2),)), alpha**2/16)/4, True) # test a bug related to 3016 a, s = symbols('a s', positive=True) assert simplify(integrate(x**s*exp(-a*x**2), (x, -oo, oo))) == \ a**(-s/2 - Rational(1, 2))*((-1)**s + 1)*gamma(s/2 + Rational(1, 2))/2
def test_Abs(): pytest.raises(TypeError, lambda: Abs(Interval(2, 3))) # issue sympy/sympy#8717 x, y = symbols('x,y') assert sign(sign(x)) == sign(x) assert isinstance(sign(x*y), sign) assert Abs(0) == 0 assert Abs(1) == 1 assert Abs(-1) == 1 assert Abs(I) == 1 assert Abs(-I) == 1 assert Abs(nan) == nan assert Abs(I * pi) == pi assert Abs(-I * pi) == pi assert Abs(I * x) == Abs(x) assert Abs(-I * x) == Abs(x) assert Abs(-2*x) == 2*Abs(x) assert Abs(-2.0*x) == 2.0*Abs(x) assert Abs(2*pi*x*y) == 2*pi*Abs(x*y) assert Abs(conjugate(x)) == Abs(x) assert conjugate(Abs(x)) == Abs(x) a = cos(1)**2 + sin(1)**2 - 1 assert Abs(a*x).series(x).simplify() == 0 a = Symbol('a', positive=True) assert Abs(2*pi*x*a) == 2*pi*a*Abs(x) assert Abs(2*pi*I*x*a) == 2*pi*a*Abs(x) x = Symbol('x', extended_real=True) n = Symbol('n', integer=True) assert Abs((-1)**n) == 1 assert x**(2*n) == Abs(x)**(2*n) assert Abs(x).diff(x) == sign(x) assert Abs(-x).fdiff() == sign(x) assert abs(x) == Abs(x) # Python built-in assert Abs(x)**3 == x**2*Abs(x) assert Abs(x)**4 == x**4 assert ( Abs(x)**(3*n)).args == (Abs(x), 3*n) # leave symbolic odd unchanged assert (1/Abs(x)).args == (Abs(x), -1) assert 1/Abs(x)**3 == 1/(x**2*Abs(x)) assert Abs(x)**-3 == Abs(x)/(x**4) assert Abs(x**3) == x**2*Abs(x) assert Abs(x**pi) == Abs(x**pi, evaluate=False) x = Symbol('x', imaginary=True) assert Abs(x).diff(x) == -sign(x) pytest.raises(ArgumentIndexError, lambda: Abs(z).fdiff(2)) eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) # if there is a fast way to know when you can and when you cannot prove an # expression like this is zero then the equality to zero is ok assert abs(eq) == 0 q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6) p = cbrt(expand(q**3)) d = p - q assert abs(d) == 0 assert Abs(4*exp(pi*I/4)) == 4 assert Abs(3**(2 + I)) == 9 assert Abs((-3)**(1 - I)) == 3*exp(pi) assert Abs(oo) is oo assert Abs(-oo) is oo assert Abs(oo + I) is oo assert Abs(oo + I*oo) is oo a = Symbol('a', algebraic=True) t = Symbol('t', transcendental=True) x = Symbol('x') assert re(a).is_algebraic assert re(x).is_algebraic is None assert re(t).is_algebraic is False assert abs(sign(z)) == Abs(sign(z), evaluate=False)
def test_expand(): assert expand((A*B)**2) == A*B*A*B assert expand(A*B - B*A) == A*B - B*A assert expand((A*B/A)**2) == A*B*B/A assert expand(B*A*(A + B)*B) == B*A**2*B + B*A*B**2 assert expand(B*A*(A + C)*B) == B*A**2*B + B*A*C*B
def test_expand_function(): assert expand(x + y) == x + y assert expand(x + y, complex=True) == I*im(x) + I*im(y) + re(x) + re(y) assert expand((x + y)**11, modulus=11) == x**11 + y**11
def test_expand_log(): t = Symbol('t', positive=True) # after first expansion, -2*log(2) + log(4); then 0 after second assert expand(log(t**2) - log(t**2 / 4) - 2 * log(2)) == 0
def mysimp(expr): return expand(powsimp(logcombine(expr, force=True), force=True, deep=True), force=True).replace(exp_polar, exp)
def test_expand_function(): assert expand(x + y) == x + y assert expand(x + y, complex=True) == I * im(x) + I * im(y) + re(x) + re(y) assert expand((x + y)**11, modulus=11) == x**11 + y**11
def test_minimal_polynomial(): assert minimal_polynomial(-7)(x) == x + 7 assert minimal_polynomial(-1)(x) == x + 1 assert minimal_polynomial(+0)(x) == x assert minimal_polynomial(+1)(x) == x - 1 assert minimal_polynomial(+7)(x) == x - 7 assert minimal_polynomial(Rational(1, 3), method='groebner')(x) == 3 * x - 1 pytest.raises(NotAlgebraic, lambda: minimal_polynomial(pi, method='groebner')) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(sin(sqrt(2)), method='groebner')) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(2**pi, method='groebner')) pytest.raises(ValueError, lambda: minimal_polynomial(1, method='spam')) assert minimal_polynomial(sqrt(2))(x) == x**2 - 2 assert minimal_polynomial(sqrt(5))(x) == x**2 - 5 assert minimal_polynomial(sqrt(6))(x) == x**2 - 6 assert minimal_polynomial(2 * sqrt(2))(x) == x**2 - 8 assert minimal_polynomial(3 * sqrt(5))(x) == x**2 - 45 assert minimal_polynomial(4 * sqrt(6))(x) == x**2 - 96 assert minimal_polynomial(2 * sqrt(2) + 3)(x) == x**2 - 6 * x + 1 assert minimal_polynomial(3 * sqrt(5) + 6)(x) == x**2 - 12 * x - 9 assert minimal_polynomial(4 * sqrt(6) + 7)(x) == x**2 - 14 * x - 47 assert minimal_polynomial(2 * sqrt(2) - 3)(x) == x**2 + 6 * x + 1 assert minimal_polynomial(3 * sqrt(5) - 6)(x) == x**2 + 12 * x - 9 assert minimal_polynomial(4 * sqrt(6) - 7)(x) == x**2 + 14 * x - 47 assert minimal_polynomial(sqrt(1 + sqrt(6)))(x) == x**4 - 2 * x**2 - 5 assert minimal_polynomial(sqrt(I + sqrt(6)))(x) == x**8 - 10 * x**4 + 49 assert minimal_polynomial(2 * I + sqrt(2 + I))(x) == x**4 + 4 * x**2 + 8 * x + 37 assert minimal_polynomial(sqrt(2) + sqrt(3))(x) == x**4 - 10 * x**2 + 1 assert minimal_polynomial(sqrt(2) + sqrt(3) + sqrt(6))(x) == x**4 - 22 * x**2 - 48 * x - 23 e = 1 / sqrt(sqrt(1 + sqrt(3)) - 4) assert minimal_polynomial(e) == minimal_polynomial(e, method='groebner') assert minimal_polynomial(e)(x) == (222 * x**8 + 240 * x**6 + 94 * x**4 + 16 * x**2 + 1) a = 1 - 9 * sqrt(2) + 7 * sqrt(3) assert minimal_polynomial( 1 / a)(x) == 392 * x**4 - 1232 * x**3 + 612 * x**2 + 4 * x - 1 assert minimal_polynomial( 1 / sqrt(a))(x) == 392 * x**8 - 1232 * x**6 + 612 * x**4 + 4 * x**2 - 1 pytest.raises(NotAlgebraic, lambda: minimal_polynomial(oo)) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(2**y)) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(sin(1))) assert minimal_polynomial(sqrt(2))(x) == x**2 - 2 assert minimal_polynomial(sqrt(2)) == PurePoly(x**2 - 2) assert minimal_polynomial(sqrt(2), method='groebner') == PurePoly(x**2 - 2) a = sqrt(2) b = sqrt(3) assert minimal_polynomial(b)(x) == x**2 - 3 assert minimal_polynomial(a) == PurePoly(x**2 - 2) assert minimal_polynomial(b) == PurePoly(x**2 - 3) assert minimal_polynomial(sqrt(a)) == PurePoly(x**4 - 2) assert minimal_polynomial(a + 1) == PurePoly(x**2 - 2 * x - 1) assert minimal_polynomial(sqrt(a / 2 + 17))(x) == 2 * x**4 - 68 * x**2 + 577 assert minimal_polynomial(sqrt(b / 2 + 17))(x) == 4 * x**4 - 136 * x**2 + 1153 # issue diofant/diofant#431 K = QQ.algebraic_field(sqrt(2)) theta = K.to_expr(K([17, Rational(1, 2)])) assert minimal_polynomial(theta)(x) == 2 * x**2 - 68 * x + 577 K = QQ.algebraic_field(RootOf(x**7 + x - 1, 3)) theta = K.to_expr(K([1, 0, 0, 2, 1])) ans = minimal_polynomial(theta)(x) assert ans == (x**7 - 7 * x**6 + 19 * x**5 - 27 * x**4 + 63 * x**3 - 115 * x**2 + 82 * x - 147) assert minimal_polynomial(theta, method='groebner')(x) == ans K = QQ.algebraic_field(RootOf(x**5 + 5 * x - 1, 2)) theta = K.to_expr(K([1, -1, 1])) ans = (x**30 - 15 * x**28 - 10 * x**27 + 135 * x**26 + 330 * x**25 - 705 * x**24 - 150 * x**23 + 3165 * x**22 - 6850 * x**21 + 7182 * x**20 + 3900 * x**19 + 4435 * x**18 + 11970 * x**17 - 259725 * x**16 - 18002 * x**15 + 808215 * x**14 - 200310 * x**13 - 647115 * x**12 + 299280 * x**11 - 1999332 * x**10 + 910120 * x**9 + 2273040 * x**8 - 5560320 * x**7 + 5302000 * x**6 - 2405376 * x**5 + 1016640 * x**4 - 804480 * x**3 + 257280 * x**2 - 53760 * x + 1280) assert minimal_polynomial(sqrt(theta) + root(theta, 3), method='groebner')(x) == ans K1 = QQ.algebraic_field(RootOf(x**3 + 4 * x - 15, 1)) K2 = QQ.algebraic_field(RootOf(x**3 - x + 1, 0)) theta = sqrt(1 + 1 / (K1.to_expr(K1([1, 0, 1])) + 1 / (sqrt(3) + K2.to_expr(K2([-1, 2, 1]))))) ans = (2262264837876687263 * x**36 - 38939909597855051866 * x**34 + 315720420314462950715 * x**32 - 1601958657418182606114 * x**30 + 5699493671077371036494 * x**28 - 15096777696140985506150 * x**26 + 30847690820556462893974 * x**24 - 49706549068200640994022 * x**22 + 64013601241426223813103 * x**20 - 66358713088213594372990 * x**18 + 55482571280904904971976 * x**16 - 37309340229165533529076 * x**14 + 20016999328983554519040 * x**12 - 8446273798231518826782 * x**10 + 2738866994867366499481 * x**8 - 657825125060873756424 * x**6 + 110036313740049140508 * x**4 - 11416087328869938298 * x**2 + 551322649782053543) assert minimal_polynomial(theta)(x) == ans a = sqrt(2) / 3 + 7 f = 81*x**8 - 2268*x**6 - 4536*x**5 + 22644*x**4 + 63216*x**3 - \ 31608*x**2 - 189648*x + 141358 assert minimal_polynomial(sqrt(a) + sqrt(sqrt(a)))(x) == f assert minimal_polynomial(a**Rational( 3, 2))(x) == 729 * x**4 - 506898 * x**2 + 84604519 K = QQ.algebraic_field(RootOf(x**3 + x - 1, 0)) a = K.to_expr(K([0, 1])) assert minimal_polynomial(1 / a**2)(x) == x**3 - x**2 - 2 * x - 1 # issue sympy/sympy#5994 eq = (-1 / (800 * sqrt( Rational(-1, 240) + 1 / (18000 * cbrt(Rational(-1, 17280000) + sqrt(15) * I / 28800000)) + 2 * cbrt(Rational(-1, 17280000) + sqrt(15) * I / 28800000)))) assert minimal_polynomial(eq)(x) == 8000 * x**2 - 1 ex = 1 + sqrt(2) + sqrt(3) mp = minimal_polynomial(ex)(x) assert mp == x**4 - 4 * x**3 - 4 * x**2 + 16 * x - 8 ex = 1 / (1 + sqrt(2) + sqrt(3)) mp = minimal_polynomial(ex)(x) assert mp == 8 * x**4 - 16 * x**3 + 4 * x**2 + 4 * x - 1 p = cbrt(expand((1 + sqrt(2) - 2 * sqrt(3) + sqrt(7))**3)) mp = minimal_polynomial(p)(x) assert mp == x**8 - 8 * x**7 - 56 * x**6 + 448 * x**5 + 480 * x**4 - 5056 * x**3 + 1984 * x**2 + 7424 * x - 3008 p = expand((1 + sqrt(2) - 2 * sqrt(3) + sqrt(7))**3) mp = minimal_polynomial(p)(x) assert mp == x**8 - 512 * x**7 - 118208 * x**6 + 31131136 * x**5 + 647362560 * x**4 - 56026611712 * x**3 + 116994310144 * x**2 + 404854931456 * x - 27216576512 assert minimal_polynomial(-sqrt(5) / 2 - Rational(1, 2) + (-sqrt(5) / 2 - Rational(1, 2))**2)(x) == x - 1 a = 1 + sqrt(2) assert minimal_polynomial((a * sqrt(2) + a)**3)(x) == x**2 - 198 * x + 1 p = 1 / (1 + sqrt(2) + sqrt(3)) assert minimal_polynomial( p, method='groebner')(x) == 8 * x**4 - 16 * x**3 + 4 * x**2 + 4 * x - 1 p = 2 / (1 + sqrt(2) + sqrt(3)) assert minimal_polynomial( p, method='groebner')(x) == x**4 - 4 * x**3 + 2 * x**2 + 4 * x - 2 assert minimal_polynomial(1 + sqrt(2) * I, method='groebner')(x) == x**2 - 2 * x + 3 assert minimal_polynomial(1 / (1 + sqrt(2)) + 1, method='groebner')(x) == x**2 - 2 assert minimal_polynomial(sqrt(2) * I + I * (1 + sqrt(2)), method='groebner')(x) == x**4 + 18 * x**2 + 49 assert minimal_polynomial(exp_polar(0))(x) == x - 1
def mysimp(expr): from diofant import expand, logcombine, powsimp return expand(powsimp(logcombine(expr, force=True), force=True, deep=True), force=True).replace(exp_polar, exp)
def test_Abs(): pytest.raises(TypeError, lambda: Abs(Interval(2, 3))) # issue sympy/sympy#8717 x, y = symbols('x,y') assert sign(sign(x)) == sign(x) assert isinstance(sign(x*y), sign) assert Abs(0) == 0 assert Abs(1) == 1 assert Abs(-1) == 1 assert Abs(I) == 1 assert Abs(-I) == 1 assert Abs(nan) == nan assert Abs(I * pi) == pi assert Abs(-I * pi) == pi assert Abs(I * x) == Abs(x) assert Abs(-I * x) == Abs(x) assert Abs(-2*x) == 2*Abs(x) assert Abs(-2.0*x) == 2.0*Abs(x) assert Abs(2*pi*x*y) == 2*pi*Abs(x*y) assert Abs(conjugate(x)) == Abs(x) assert conjugate(Abs(x)) == Abs(x) a = cos(1)**2 + sin(1)**2 - 1 assert Abs(a*x).series(x).simplify() == 0 a = Symbol('a', positive=True) assert Abs(2*pi*x*a) == 2*pi*a*Abs(x) assert Abs(2*pi*I*x*a) == 2*pi*a*Abs(x) x = Symbol('x', extended_real=True) n = Symbol('n', integer=True) assert Abs((-1)**n) == 1 assert x**(2*n) == Abs(x)**(2*n) assert Abs(x).diff(x) == sign(x) assert abs(x) == Abs(x) # Python built-in assert Abs(x)**3 == x**2*Abs(x) assert Abs(x)**4 == x**4 assert ( Abs(x)**(3*n)).args == (Abs(x), 3*n) # leave symbolic odd unchanged assert (1/Abs(x)).args == (Abs(x), -1) assert 1/Abs(x)**3 == 1/(x**2*Abs(x)) assert Abs(x)**-3 == Abs(x)/(x**4) assert Abs(x**3) == x**2*Abs(x) assert Abs(x**pi) == Abs(x**pi, evaluate=False) x = Symbol('x', imaginary=True) assert Abs(x).diff(x) == -sign(x) pytest.raises(ArgumentIndexError, lambda: Abs(z).fdiff(2)) eq = -sqrt(10 + 6*sqrt(3)) + sqrt(1 + sqrt(3)) + sqrt(3 + 3*sqrt(3)) # if there is a fast way to know when you can and when you cannot prove an # expression like this is zero then the equality to zero is ok assert abs(eq) == 0 q = 1 + sqrt(2) - 2*sqrt(3) + 1331*sqrt(6) p = cbrt(expand(q**3)) d = p - q assert abs(d) == 0 assert Abs(4*exp(pi*I/4)) == 4 assert Abs(3**(2 + I)) == 9 assert Abs((-3)**(1 - I)) == 3*exp(pi) assert Abs(oo) is oo assert Abs(-oo) is oo assert Abs(oo + I) is oo assert Abs(oo + I*oo) is oo a = Symbol('a', algebraic=True) t = Symbol('t', transcendental=True) x = Symbol('x') assert re(a).is_algebraic assert re(x).is_algebraic is None assert re(t).is_algebraic is False assert abs(sign(z)) == Abs(sign(z), evaluate=False)
def test_expand_log(): t = Symbol('t', positive=True) # after first expansion, -2*log(2) + log(4); then 0 after second assert expand(log(t**2) - log(t**2/4) - 2*log(2)) == 0
def test_inverse_mellin_transform(): from diofant import (sin, simplify, Max, Min, expand, powsimp, exp_polar, cos, cot) IMT = inverse_mellin_transform assert IMT(gamma(s), s, x, (0, oo)) == exp(-x) assert IMT(gamma(-s), s, x, (-oo, 0)) == exp(-1 / x) assert simplify(IMT(s/(2*s**2 - 2), s, x, (2, oo))) == \ (x**2 + 1)*Heaviside(1 - x)/(4*x) # test passing "None" assert IMT(1/(s**2 - 1), s, x, (-1, None)) == \ -x*Heaviside(-x + 1)/2 - Heaviside(x - 1)/(2*x) assert IMT(1/(s**2 - 1), s, x, (None, 1)) == \ (-x/2 + 1/(2*x))*Heaviside(-x + 1) # test expansion of sums assert IMT(gamma(s) + gamma(s - 1), s, x, (1, oo)) == (x + 1) * exp(-x) / x # test factorisation of polys r = symbols('r', extended_real=True) assert IMT(1/(s**2 + 1), s, exp(-x), (None, oo) ).subs(x, r).rewrite(sin).simplify() \ == sin(r)*Heaviside(1 - exp(-r)) # test multiplicative substitution _a, _b = symbols('a b', positive=True) assert IMT(_b**(-s / _a) * factorial(s / _a) / s, s, x, (0, oo)) == exp(-_b * x**_a) assert IMT(factorial(_a / _b + s / _b) / (_a + s), s, x, (-_a, oo)) == x**_a * exp(-x**_b) def simp_pows(expr): return simplify(powsimp(expand_mul(expr, deep=False), force=True)).replace(exp_polar, exp) # Now test the inverses of all direct transforms tested above # Section 8.4.2 nu = symbols('nu', extended_real=True, finite=True) assert IMT(-1 / (nu + s), s, x, (-oo, None)) == x**nu * Heaviside(x - 1) assert IMT(1 / (nu + s), s, x, (None, oo)) == x**nu * Heaviside(1 - x) assert simp_pows(IMT(gamma(beta)*gamma(s)/gamma(s + beta), s, x, (0, oo))) \ == (1 - x)**(beta - 1)*Heaviside(1 - x) assert simp_pows(IMT(gamma(beta)*gamma(1 - beta - s)/gamma(1 - s), s, x, (-oo, None))) \ == (x - 1)**(beta - 1)*Heaviside(x - 1) assert simp_pows(IMT(gamma(s)*gamma(rho - s)/gamma(rho), s, x, (0, None))) \ == (1/(x + 1))**rho assert simp_pows(IMT(d**c*d**(s - 1)*sin(pi*c) * gamma(s)*gamma(s + c)*gamma(1 - s)*gamma(1 - s - c)/pi, s, x, (Max(-re(c), 0), Min(1 - re(c), 1)))) \ == (x**c - d**c)/(x - d) assert simplify(IMT(1/sqrt(pi)*(-c/2)*gamma(s)*gamma((1 - c)/2 - s) * gamma(-c/2 - s)/gamma(1 - c - s), s, x, (0, -re(c)/2))) == \ (1 + sqrt(x + 1))**c assert simplify(IMT(2**(a + 2*s)*b**(a + 2*s - 1)*gamma(s)*gamma(1 - a - 2*s) / gamma(1 - a - s), s, x, (0, (-re(a) + 1)/2))) == \ b**(a - 1)*(sqrt(1 + x/b**2) + 1)**(a - 1)*(b**2*sqrt(1 + x/b**2) + b**2 + x)/(b**2 + x) assert simplify(IMT(-2**(c + 2*s)*c*b**(c + 2*s)*gamma(s)*gamma(-c - 2*s) / gamma(-c - s + 1), s, x, (0, -re(c)/2))) == \ b**c*(sqrt(1 + x/b**2) + 1)**c # Section 8.4.5 assert IMT(24 / s**5, s, x, (0, oo)) == log(x)**4 * Heaviside(1 - x) assert expand(IMT(6/s**4, s, x, (-oo, 0)), force=True) == \ log(x)**3*Heaviside(x - 1) assert IMT(pi / (s * sin(pi * s)), s, x, (-1, 0)) == log(x + 1) assert IMT(pi / (s * sin(pi * s / 2)), s, x, (-2, 0)) == log(x**2 + 1) assert IMT(pi / (s * sin(2 * pi * s)), s, x, (-Rational(1, 2), 0)) == log(sqrt(x) + 1) assert IMT(pi / (s * sin(pi * s)), s, x, (0, 1)) == log(1 + 1 / x) # TODO def mysimp(expr): from diofant import expand, logcombine, powsimp return expand(powsimp(logcombine(expr, force=True), force=True, deep=True), force=True).replace(exp_polar, exp) assert mysimp(mysimp(IMT(pi / (s * tan(pi * s)), s, x, (-1, 0)))) in [ log(1 - x) * Heaviside(1 - x) + log(x - 1) * Heaviside(x - 1), log(x) * Heaviside(x - 1) + log(1 - 1 / x) * Heaviside(x - 1) + log(-x + 1) * Heaviside(-x + 1) ] # test passing cot assert mysimp(IMT(pi * cot(pi * s) / s, s, x, (0, 1))) in [ log(1 / x - 1) * Heaviside(1 - x) + log(1 - 1 / x) * Heaviside(x - 1), -log(x) * Heaviside(-x + 1) + log(1 - 1 / x) * Heaviside(x - 1) + log(-x + 1) * Heaviside(-x + 1), ] # 8.4.14 assert IMT(-gamma(s + Rational(1, 2))/(sqrt(pi)*s), s, x, (-Rational(1, 2), 0)) == \ erf(sqrt(x)) # 8.4.19 assert simplify(IMT(gamma(a/2 + s)/gamma(a/2 - s + 1), s, x, (-re(a)/2, Rational(3, 4)))) \ == besselj(a, 2*sqrt(x)) assert simplify(IMT(2**a*gamma(Rational(1, 2) - 2*s)*gamma(s + (a + 1)/2) / (gamma(1 - s - a/2)*gamma(1 - 2*s + a)), s, x, (-(re(a) + 1)/2, Rational(1, 4)))) == \ sin(sqrt(x))*besselj(a, sqrt(x)) assert simplify(IMT(2**a*gamma(a/2 + s)*gamma(Rational(1, 2) - 2*s) / (gamma(Rational(1, 2) - s - a/2)*gamma(1 - 2*s + a)), s, x, (-re(a)/2, Rational(1, 4)))) == \ cos(sqrt(x))*besselj(a, sqrt(x)) # TODO this comes out as an amazing mess, but simplifies nicely assert simplify(IMT(gamma(a + s)*gamma(Rational(1, 2) - s) / (sqrt(pi)*gamma(1 - s)*gamma(1 + a - s)), s, x, (-re(a), Rational(1, 2)))) == \ besselj(a, sqrt(x))**2 assert simplify(IMT(gamma(s)*gamma(Rational(1, 2) - s) / (sqrt(pi)*gamma(1 - s - a)*gamma(1 + a - s)), s, x, (0, Rational(1, 2)))) == \ besselj(-a, sqrt(x))*besselj(a, sqrt(x)) assert simplify(IMT(4**s*gamma(-2*s + 1)*gamma(a/2 + b/2 + s) / (gamma(-a/2 + b/2 - s + 1)*gamma(a/2 - b/2 - s + 1) * gamma(a/2 + b/2 - s + 1)), s, x, (-(re(a) + re(b))/2, Rational(1, 2)))) == \ besselj(a, sqrt(x))*besselj(b, sqrt(x)) # Section 8.4.20 # TODO this can be further simplified! assert simplify(IMT(-2**(2*s)*cos(pi*a/2 - pi*b/2 + pi*s)*gamma(-2*s + 1) * gamma(a/2 - b/2 + s)*gamma(a/2 + b/2 + s) / (pi*gamma(a/2 - b/2 - s + 1)*gamma(a/2 + b/2 - s + 1)), s, x, (Max(-re(a)/2 - re(b)/2, -re(a)/2 + re(b)/2), Rational(1, 2)))) == \ besselj(a, sqrt(x))*-(besselj(-b, sqrt(x)) - besselj(b, sqrt(x))*cos(pi*b))/sin(pi*b) # TODO more # for coverage assert IMT(pi / cos(pi * s), s, x, (0, Rational(1, 2))) == sqrt(x) / (x + 1)
def mysimp(expr): return expand( powsimp(logcombine(expr, force=True), force=True, deep=True), force=True).replace(exp_polar, exp)
def test_minimal_polynomial(): assert minimal_polynomial(-7, x) == x + 7 assert minimal_polynomial(-1, x) == x + 1 assert minimal_polynomial(0, x) == x assert minimal_polynomial(1, x) == x - 1 assert minimal_polynomial(7, x) == x - 7 assert minimal_polynomial(sqrt(2), x) == x**2 - 2 assert minimal_polynomial(sqrt(5), x) == x**2 - 5 assert minimal_polynomial(sqrt(6), x) == x**2 - 6 assert minimal_polynomial(2 * sqrt(2), x) == x**2 - 8 assert minimal_polynomial(3 * sqrt(5), x) == x**2 - 45 assert minimal_polynomial(4 * sqrt(6), x) == x**2 - 96 assert minimal_polynomial(2 * sqrt(2) + 3, x) == x**2 - 6 * x + 1 assert minimal_polynomial(3 * sqrt(5) + 6, x) == x**2 - 12 * x - 9 assert minimal_polynomial(4 * sqrt(6) + 7, x) == x**2 - 14 * x - 47 assert minimal_polynomial(2 * sqrt(2) - 3, x) == x**2 + 6 * x + 1 assert minimal_polynomial(3 * sqrt(5) - 6, x) == x**2 + 12 * x - 9 assert minimal_polynomial(4 * sqrt(6) - 7, x) == x**2 + 14 * x - 47 assert minimal_polynomial(sqrt(1 + sqrt(6)), x) == x**4 - 2 * x**2 - 5 assert minimal_polynomial(sqrt(I + sqrt(6)), x) == x**8 - 10 * x**4 + 49 assert minimal_polynomial(2 * I + sqrt(2 + I), x) == x**4 + 4 * x**2 + 8 * x + 37 assert minimal_polynomial(sqrt(2) + sqrt(3), x) == x**4 - 10 * x**2 + 1 assert minimal_polynomial(sqrt(2) + sqrt(3) + sqrt(6), x) == x**4 - 22 * x**2 - 48 * x - 23 a = 1 - 9 * sqrt(2) + 7 * sqrt(3) assert minimal_polynomial( 1 / a, x) == 392 * x**4 - 1232 * x**3 + 612 * x**2 + 4 * x - 1 assert minimal_polynomial( 1 / sqrt(a), x) == 392 * x**8 - 1232 * x**6 + 612 * x**4 + 4 * x**2 - 1 pytest.raises(NotAlgebraic, lambda: minimal_polynomial(oo, x)) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(2**y, x)) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(sin(1), x)) assert minimal_polynomial(sqrt(2)).dummy_eq(x**2 - 2) assert minimal_polynomial(sqrt(2), x) == x**2 - 2 assert minimal_polynomial(sqrt(2), polys=True) == Poly(x**2 - 2) assert minimal_polynomial(sqrt(2), x, polys=True) == Poly(x**2 - 2) assert minimal_polynomial(sqrt(2), x, polys=True, compose=False) == Poly(x**2 - 2) a = AlgebraicNumber(sqrt(2)) b = AlgebraicNumber(sqrt(3)) assert minimal_polynomial(a, x) == x**2 - 2 assert minimal_polynomial(b, x) == x**2 - 3 assert minimal_polynomial(a, x, polys=True) == Poly(x**2 - 2) assert minimal_polynomial(b, x, polys=True) == Poly(x**2 - 3) assert minimal_polynomial(sqrt(a / 2 + 17), x) == 2 * x**4 - 68 * x**2 + 577 assert minimal_polynomial(sqrt(b / 2 + 17), x) == 4 * x**4 - 136 * x**2 + 1153 a, b = sqrt(2) / 3 + 7, AlgebraicNumber(sqrt(2) / 3 + 7) f = 81*x**8 - 2268*x**6 - 4536*x**5 + 22644*x**4 + 63216*x**3 - \ 31608*x**2 - 189648*x + 141358 assert minimal_polynomial(sqrt(a) + sqrt(sqrt(a)), x) == f assert minimal_polynomial(sqrt(b) + sqrt(sqrt(b)), x) == f assert minimal_polynomial(a**Q(3, 2), x) == 729 * x**4 - 506898 * x**2 + 84604519 # issue 5994 eq = (-1 / (800 * sqrt( Rational(-1, 240) + 1 / (18000 * (Rational(-1, 17280000) + sqrt(15) * I / 28800000)**Rational(1, 3)) + 2 * (Rational(-1, 17280000) + sqrt(15) * I / 28800000)**Rational(1, 3)))) assert minimal_polynomial(eq, x) == 8000 * x**2 - 1 ex = 1 + sqrt(2) + sqrt(3) mp = minimal_polynomial(ex, x) assert mp == x**4 - 4 * x**3 - 4 * x**2 + 16 * x - 8 ex = 1 / (1 + sqrt(2) + sqrt(3)) mp = minimal_polynomial(ex, x) assert mp == 8 * x**4 - 16 * x**3 + 4 * x**2 + 4 * x - 1 p = (expand((1 + sqrt(2) - 2 * sqrt(3) + sqrt(7))**3))**Rational(1, 3) mp = minimal_polynomial(p, x) assert mp == x**8 - 8 * x**7 - 56 * x**6 + 448 * x**5 + 480 * x**4 - 5056 * x**3 + 1984 * x**2 + 7424 * x - 3008 p = expand((1 + sqrt(2) - 2 * sqrt(3) + sqrt(7))**3) mp = minimal_polynomial(p, x) assert mp == x**8 - 512 * x**7 - 118208 * x**6 + 31131136 * x**5 + 647362560 * x**4 - 56026611712 * x**3 + 116994310144 * x**2 + 404854931456 * x - 27216576512 assert minimal_polynomial( -sqrt(5) / 2 - S.Half + (-sqrt(5) / 2 - S.Half)**2, x) == x - 1 a = 1 + sqrt(2) assert minimal_polynomial((a * sqrt(2) + a)**3, x) == x**2 - 198 * x + 1 p = 1 / (1 + sqrt(2) + sqrt(3)) assert minimal_polynomial( p, x, compose=False) == 8 * x**4 - 16 * x**3 + 4 * x**2 + 4 * x - 1 p = 2 / (1 + sqrt(2) + sqrt(3)) assert minimal_polynomial( p, x, compose=False) == x**4 - 4 * x**3 + 2 * x**2 + 4 * x - 2 assert minimal_polynomial(1 + sqrt(2) * I, x, compose=False) == x**2 - 2 * x + 3 assert minimal_polynomial(1 / (1 + sqrt(2)) + 1, x, compose=False) == x**2 - 2 assert minimal_polynomial(sqrt(2) * I + I * (1 + sqrt(2)), x, compose=False) == x**4 + 18 * x**2 + 49
def test_meijerint(): s, t, mu = symbols('s t mu', extended_real=True) assert integrate( meijerg([], [], [0], [], s * t) * meijerg([], [], [mu / 2], [-mu / 2], t**2 / 4), (t, 0, oo)).is_Piecewise s = symbols('s', positive=True) assert integrate(x**s*meijerg([[], []], [[0], []], x), (x, 0, oo)) == \ gamma(s + 1) assert integrate(x**s * meijerg([[], []], [[0], []], x), (x, 0, oo), meijerg=True) == gamma(s + 1) assert isinstance( integrate(x**s * meijerg([[], []], [[0], []], x), (x, 0, oo), meijerg=False), Integral) assert meijerint_indefinite(exp(x), x) == exp(x) # TODO what simplifications should be done automatically? # This tests "extra case" for antecedents_1. a, b = symbols('a b', positive=True) assert simplify(meijerint_definite(x**a, x, 0, b)[0]) == \ b**(a + 1)/(a + 1) # This tests various conditions and expansions: meijerint_definite((x + 1)**3 * exp(-x), x, 0, oo) == (16, True) # Again, how about simplifications? sigma, mu = symbols('sigma mu', positive=True) i, c = meijerint_definite(exp(-((x - mu) / (2 * sigma))**2), x, 0, oo) assert simplify(i) == sqrt(pi) * sigma * (erf(mu / (2 * sigma)) + 1) assert c i, _ = meijerint_definite(exp(-mu * x) * exp(sigma * x), x, 0, oo) # TODO it would be nice to test the condition assert simplify(i) == 1 / (mu - sigma) # Test substitutions to change limits assert meijerint_definite(exp(x), x, -oo, 2) == (exp(2), True) # Note: causes a NaN in _check_antecedents assert expand(meijerint_definite(exp(x), x, 0, I)[0]) == exp(I) - 1 assert expand(meijerint_definite(exp(-x), x, 0, x)[0]) == \ 1 - exp(-exp(I*arg(x))*abs(x)) # Test -oo to oo assert meijerint_definite(exp(-x**2), x, -oo, oo) == (sqrt(pi), True) assert meijerint_definite(exp(-abs(x)), x, -oo, oo) == (2, True) assert meijerint_definite(exp(-(2*x - 3)**2), x, -oo, oo) == \ (sqrt(pi)/2, True) assert meijerint_definite(exp(-abs(2 * x - 3)), x, -oo, oo) == (1, True) assert meijerint_definite( exp(-((x - mu) / sigma)**2 / 2) / sqrt(2 * pi * sigma**2), x, -oo, oo) == (1, True) # Test one of the extra conditions for 2 g-functinos assert meijerint_definite(exp(-x) * sin(x), x, 0, oo) == (Rational(1, 2), True) # Test a bug def res(n): return (1 / (1 + x**2)).diff(x, n).subs({x: 1}) * (-1)**n for n in range(6): assert integrate(exp(-x)*sin(x)*x**n, (x, 0, oo), meijerg=True) == \ res(n) # This used to test trigexpand... now it is done by linear substitution assert simplify(integrate(exp(-x) * sin(x + a), (x, 0, oo), meijerg=True)) == sqrt(2) * sin(a + pi / 4) / 2 # Test the condition 14 from prudnikov. # (This is besselj*besselj in disguise, to stop the product from being # recognised in the tables.) a, b, s = symbols('a b s') assert meijerint_definite(meijerg([], [], [a/2], [-a/2], x/4) * meijerg([], [], [b/2], [-b/2], x/4)*x**(s - 1), x, 0, oo) == \ (4*2**(2*s - 2)*gamma(-2*s + 1)*gamma(a/2 + b/2 + s) / (gamma(-a/2 + b/2 - s + 1)*gamma(a/2 - b/2 - s + 1) * gamma(a/2 + b/2 - s + 1)), And(0 < -2*re(4*s) + 8, 0 < re(a/2 + b/2 + s), re(2*s) < 1)) # test a bug assert integrate(sin(x**a)*sin(x**b), (x, 0, oo), meijerg=True) == \ Integral(sin(x**a)*sin(x**b), (x, 0, oo)) # test better hyperexpand assert integrate(exp(-x**2)*log(x), (x, 0, oo), meijerg=True) == \ (sqrt(pi)*polygamma(0, Rational(1, 2))/4).expand() # Test hyperexpand bug. n = symbols('n', integer=True) assert simplify(integrate(exp(-x)*x**n, x, meijerg=True)) == \ lowergamma(n + 1, x) # Test a bug with argument 1/x alpha = symbols('alpha', positive=True) assert meijerint_definite((2 - x)**alpha*sin(alpha/x), x, 0, 2) == \ (sqrt(pi)*alpha*gamma(alpha + 1)*meijerg(((), (alpha/2 + Rational(1, 2), alpha/2 + 1)), ((0, 0, Rational(1, 2)), (-Rational(1, 2),)), alpha**2/16)/4, True) # test a bug related to 3016 a, s = symbols('a s', positive=True) assert simplify(integrate(x**s*exp(-a*x**2), (x, -oo, oo))) == \ a**(-s/2 - Rational(1, 2))*((-1)**s + 1)*gamma(s/2 + Rational(1, 2))/2
def test_minimal_polynomial(): assert minimal_polynomial(-7)(x) == x + 7 assert minimal_polynomial(-1)(x) == x + 1 assert minimal_polynomial( 0)(x) == x assert minimal_polynomial( 1)(x) == x - 1 assert minimal_polynomial( 7)(x) == x - 7 assert minimal_polynomial(Rational(1, 3), method='groebner')(x) == 3*x - 1 pytest.raises(NotAlgebraic, lambda: minimal_polynomial(pi, method='groebner')) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(sin(sqrt(2)), method='groebner')) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(2**pi, method='groebner')) pytest.raises(ValueError, lambda: minimal_polynomial(1, method='spam')) assert minimal_polynomial(sqrt(2))(x) == x**2 - 2 assert minimal_polynomial(sqrt(5))(x) == x**2 - 5 assert minimal_polynomial(sqrt(6))(x) == x**2 - 6 assert minimal_polynomial(2*sqrt(2))(x) == x**2 - 8 assert minimal_polynomial(3*sqrt(5))(x) == x**2 - 45 assert minimal_polynomial(4*sqrt(6))(x) == x**2 - 96 assert minimal_polynomial(2*sqrt(2) + 3)(x) == x**2 - 6*x + 1 assert minimal_polynomial(3*sqrt(5) + 6)(x) == x**2 - 12*x - 9 assert minimal_polynomial(4*sqrt(6) + 7)(x) == x**2 - 14*x - 47 assert minimal_polynomial(2*sqrt(2) - 3)(x) == x**2 + 6*x + 1 assert minimal_polynomial(3*sqrt(5) - 6)(x) == x**2 + 12*x - 9 assert minimal_polynomial(4*sqrt(6) - 7)(x) == x**2 + 14*x - 47 assert minimal_polynomial(sqrt(1 + sqrt(6)))(x) == x**4 - 2*x**2 - 5 assert minimal_polynomial(sqrt(I + sqrt(6)))(x) == x**8 - 10*x**4 + 49 assert minimal_polynomial(2*I + sqrt(2 + I))(x) == x**4 + 4*x**2 + 8*x + 37 assert minimal_polynomial(sqrt(2) + sqrt(3))(x) == x**4 - 10*x**2 + 1 assert minimal_polynomial(sqrt(2) + sqrt(3) + sqrt(6))(x) == x**4 - 22*x**2 - 48*x - 23 e = 1/sqrt(sqrt(1 + sqrt(3)) - 4) assert minimal_polynomial(e) == minimal_polynomial(e, method='groebner') assert minimal_polynomial(e)(x) == (222*x**8 + 240*x**6 + 94*x**4 + 16*x**2 + 1) a = 1 - 9*sqrt(2) + 7*sqrt(3) assert minimal_polynomial(1/a)(x) == 392*x**4 - 1232*x**3 + 612*x**2 + 4*x - 1 assert minimal_polynomial(1/sqrt(a))(x) == 392*x**8 - 1232*x**6 + 612*x**4 + 4*x**2 - 1 pytest.raises(NotAlgebraic, lambda: minimal_polynomial(oo)) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(2**y)) pytest.raises(NotAlgebraic, lambda: minimal_polynomial(sin(1))) assert minimal_polynomial(sqrt(2))(x) == x**2 - 2 assert minimal_polynomial(sqrt(2)) == PurePoly(x**2 - 2) assert minimal_polynomial(sqrt(2), method='groebner') == PurePoly(x**2 - 2) a = sqrt(2) b = sqrt(3) assert minimal_polynomial(b)(x) == x**2 - 3 assert minimal_polynomial(a) == PurePoly(x**2 - 2) assert minimal_polynomial(b) == PurePoly(x**2 - 3) assert minimal_polynomial(sqrt(a)) == PurePoly(x**4 - 2) assert minimal_polynomial(a + 1) == PurePoly(x**2 - 2*x - 1) assert minimal_polynomial(sqrt(a/2 + 17))(x) == 2*x**4 - 68*x**2 + 577 assert minimal_polynomial(sqrt(b/2 + 17))(x) == 4*x**4 - 136*x**2 + 1153 # issue diofant/diofant#431 K = QQ.algebraic_field(sqrt(2)) theta = K.to_expr(K([Rational(1, 2), 17])) assert minimal_polynomial(theta)(x) == 2*x**2 - 68*x + 577 K = QQ.algebraic_field(RootOf(x**7 + x - 1, 3)) theta = K.to_expr(K([1, 2, 0, 0, 1])) ans = minimal_polynomial(theta)(x) assert ans == (x**7 - 7*x**6 + 19*x**5 - 27*x**4 + 63*x**3 - 115*x**2 + 82*x - 147) assert minimal_polynomial(theta, method='groebner')(x) == ans K = QQ.algebraic_field(RootOf(x**5 + 5*x - 1, 2)) theta = K.to_expr(K([1, -1, 1])) ans = (x**30 - 15*x**28 - 10*x**27 + 135*x**26 + 330*x**25 - 705*x**24 - 150*x**23 + 3165*x**22 - 6850*x**21 + 7182*x**20 + 3900*x**19 + 4435*x**18 + 11970*x**17 - 259725*x**16 - 18002*x**15 + 808215*x**14 - 200310*x**13 - 647115*x**12 + 299280*x**11 - 1999332*x**10 + 910120*x**9 + 2273040*x**8 - 5560320*x**7 + 5302000*x**6 - 2405376*x**5 + 1016640*x**4 - 804480*x**3 + 257280*x**2 - 53760*x + 1280) assert minimal_polynomial(sqrt(theta) + root(theta, 3), method='groebner')(x) == ans K1 = QQ.algebraic_field(RootOf(x**3 + 4*x - 15, 1)) K2 = QQ.algebraic_field(RootOf(x**3 - x + 1, 0)) theta = sqrt(1 + 1/(K1.to_expr(K1([1, 0, 1])) + 1/(sqrt(3) + K2.to_expr(K2([1, 2, -1]))))) ans = (2262264837876687263*x**36 - 38939909597855051866*x**34 + 315720420314462950715*x**32 - 1601958657418182606114*x**30 + 5699493671077371036494*x**28 - 15096777696140985506150*x**26 + 30847690820556462893974*x**24 - 49706549068200640994022*x**22 + 64013601241426223813103*x**20 - 66358713088213594372990*x**18 + 55482571280904904971976*x**16 - 37309340229165533529076*x**14 + 20016999328983554519040*x**12 - 8446273798231518826782*x**10 + 2738866994867366499481*x**8 - 657825125060873756424*x**6 + 110036313740049140508*x**4 - 11416087328869938298*x**2 + 551322649782053543) assert minimal_polynomial(theta)(x) == ans a = sqrt(2)/3 + 7 f = 81*x**8 - 2268*x**6 - 4536*x**5 + 22644*x**4 + 63216*x**3 - \ 31608*x**2 - 189648*x + 141358 assert minimal_polynomial(sqrt(a) + sqrt(sqrt(a)))(x) == f assert minimal_polynomial(a**Rational(3, 2))(x) == 729*x**4 - 506898*x**2 + 84604519 K = QQ.algebraic_field(RootOf(x**3 + x - 1, 0)) a = K.to_expr(K([1, 0])) assert minimal_polynomial(1/a**2)(x) == x**3 - x**2 - 2*x - 1 # issue sympy/sympy#5994 eq = (-1/(800*sqrt(Rational(-1, 240) + 1/(18000*cbrt(Rational(-1, 17280000) + sqrt(15)*I/28800000)) + 2*cbrt(Rational(-1, 17280000) + sqrt(15)*I/28800000)))) assert minimal_polynomial(eq)(x) == 8000*x**2 - 1 ex = 1 + sqrt(2) + sqrt(3) mp = minimal_polynomial(ex)(x) assert mp == x**4 - 4*x**3 - 4*x**2 + 16*x - 8 ex = 1/(1 + sqrt(2) + sqrt(3)) mp = minimal_polynomial(ex)(x) assert mp == 8*x**4 - 16*x**3 + 4*x**2 + 4*x - 1 p = cbrt(expand((1 + sqrt(2) - 2*sqrt(3) + sqrt(7))**3)) mp = minimal_polynomial(p)(x) assert mp == x**8 - 8*x**7 - 56*x**6 + 448*x**5 + 480*x**4 - 5056*x**3 + 1984*x**2 + 7424*x - 3008 p = expand((1 + sqrt(2) - 2*sqrt(3) + sqrt(7))**3) mp = minimal_polynomial(p)(x) assert mp == x**8 - 512*x**7 - 118208*x**6 + 31131136*x**5 + 647362560*x**4 - 56026611712*x**3 + 116994310144*x**2 + 404854931456*x - 27216576512 assert minimal_polynomial(-sqrt(5)/2 - Rational(1, 2) + (-sqrt(5)/2 - Rational(1, 2))**2)(x) == x - 1 a = 1 + sqrt(2) assert minimal_polynomial((a*sqrt(2) + a)**3)(x) == x**2 - 198*x + 1 p = 1/(1 + sqrt(2) + sqrt(3)) assert minimal_polynomial(p, method='groebner')(x) == 8*x**4 - 16*x**3 + 4*x**2 + 4*x - 1 p = 2/(1 + sqrt(2) + sqrt(3)) assert minimal_polynomial(p, method='groebner')(x) == x**4 - 4*x**3 + 2*x**2 + 4*x - 2 assert minimal_polynomial(1 + sqrt(2)*I, method='groebner')(x) == x**2 - 2*x + 3 assert minimal_polynomial(1/(1 + sqrt(2)) + 1, method='groebner')(x) == x**2 - 2 assert minimal_polynomial(sqrt(2)*I + I*(1 + sqrt(2)), method='groebner')(x) == x**4 + 18*x**2 + 49 assert minimal_polynomial(exp_polar(0))(x) == x - 1
def test_expand(): assert expand((A * B)**2) == A * B * A * B assert expand(A * B - B * A) == A * B - B * A assert expand((A * B / A)**2) == A * B * B / A assert expand(B * A * (A + B) * B) == B * A**2 * B + B * A * B**2 assert expand(B * A * (A + C) * B) == B * A**2 * B + B * A * C * B
def test_inverse_mellin_transform(): IMT = inverse_mellin_transform assert IMT(gamma(s), s, x, (0, oo)) == exp(-x) assert IMT(gamma(-s), s, x, (-oo, 0)) == exp(-1/x) assert simplify(IMT(s/(2*s**2 - 2), s, x, (2, oo))) == \ (x**2 + 1)*Heaviside(1 - x)/(4*x) # test passing "None" assert IMT(1/(s**2 - 1), s, x, (-1, None)) == \ -x*Heaviside(-x + 1)/2 - Heaviside(x - 1)/(2*x) assert IMT(1/(s**2 - 1), s, x, (None, 1)) == \ (-x/2 + 1/(2*x))*Heaviside(-x + 1) # test expansion of sums assert IMT(gamma(s) + gamma(s - 1), s, x, (1, oo)) == (x + 1)*exp(-x)/x # test factorisation of polys r = symbols('r', extended_real=True) assert (IMT(1/(s**2 + 1), s, exp(-x), (None, oo)).subs({x: r}).rewrite(sin).simplify() == sin(r)*Heaviside(1 - exp(-r))) # test multiplicative substitution _a, _b = symbols('a b', positive=True) assert IMT(_b**(-s/_a)*factorial(s/_a)/s, s, x, (0, oo)) == exp(-_b*x**_a) assert IMT(factorial(_a/_b + s/_b)/(_a + s), s, x, (-_a, oo)) == x**_a*exp(-x**_b) def simp_pows(expr): return simplify(powsimp(expand_mul(expr, deep=False), force=True)).replace(exp_polar, exp) # Now test the inverses of all direct transforms tested above # Section 8.4.2 nu = symbols('nu', real=True) assert IMT(-1/(nu + s), s, x, (-oo, None)) == x**nu*Heaviside(x - 1) assert IMT(1/(nu + s), s, x, (None, oo)) == x**nu*Heaviside(1 - x) assert simp_pows(IMT(gamma(beta)*gamma(s)/gamma(s + beta), s, x, (0, oo))) \ == (1 - x)**(beta - 1)*Heaviside(1 - x) assert simp_pows(IMT(gamma(beta)*gamma(1 - beta - s)/gamma(1 - s), s, x, (-oo, None))) \ == (x - 1)**(beta - 1)*Heaviside(x - 1) assert simp_pows(IMT(gamma(s)*gamma(rho - s)/gamma(rho), s, x, (0, None))) \ == (1/(x + 1))**rho assert simp_pows(IMT(d**c*d**(s - 1)*sin(pi*c) * gamma(s)*gamma(s + c)*gamma(1 - s)*gamma(1 - s - c)/pi, s, x, (Max(-re(c), 0), Min(1 - re(c), 1)))) \ == (x**c - d**c)/(x - d) assert simplify(IMT(1/sqrt(pi)*(-c/2)*gamma(s)*gamma((1 - c)/2 - s) * gamma(-c/2 - s)/gamma(1 - c - s), s, x, (0, -re(c)/2))) == \ (1 + sqrt(x + 1))**c assert simplify(IMT(2**(a + 2*s)*b**(a + 2*s - 1)*gamma(s)*gamma(1 - a - 2*s) / gamma(1 - a - s), s, x, (0, (-re(a) + 1)/2))) == \ b**(a - 1)*(sqrt(1 + x/b**2) + 1)**(a - 1)*(b**2*sqrt(1 + x/b**2) + b**2 + x)/(b**2 + x) assert simplify(IMT(-2**(c + 2*s)*c*b**(c + 2*s)*gamma(s)*gamma(-c - 2*s) / gamma(-c - s + 1), s, x, (0, -re(c)/2))) == \ b**c*(sqrt(1 + x/b**2) + 1)**c # Section 8.4.5 assert IMT(24/s**5, s, x, (0, oo)) == log(x)**4*Heaviside(1 - x) assert expand(IMT(6/s**4, s, x, (-oo, 0)), force=True) == \ log(x)**3*Heaviside(x - 1) assert IMT(pi/(s*sin(pi*s)), s, x, (-1, 0)) == log(x + 1) assert IMT(pi/(s*sin(pi*s/2)), s, x, (-2, 0)) == log(x**2 + 1) assert IMT(pi/(s*sin(2*pi*s)), s, x, (-Rational(1, 2), 0)) == log(sqrt(x) + 1) assert IMT(pi/(s*sin(pi*s)), s, x, (0, 1)) == log(1 + 1/x) # TODO def mysimp(expr): return expand( powsimp(logcombine(expr, force=True), force=True, deep=True), force=True).replace(exp_polar, exp) assert mysimp(mysimp(IMT(pi/(s*tan(pi*s)), s, x, (-1, 0)))) in [ log(1 - x)*Heaviside(1 - x) + log(x - 1)*Heaviside(x - 1), log(x)*Heaviside(x - 1) + log(1 - 1/x)*Heaviside(x - 1) + log(-x + 1)*Heaviside(-x + 1)] # test passing cot assert mysimp(IMT(pi*cot(pi*s)/s, s, x, (0, 1))) in [ log(1/x - 1)*Heaviside(1 - x) + log(1 - 1/x)*Heaviside(x - 1), -log(x)*Heaviside(-x + 1) + log(1 - 1/x)*Heaviside(x - 1) + log(-x + 1)*Heaviside(-x + 1), ] # 8.4.14 assert IMT(-gamma(s + Rational(1, 2))/(sqrt(pi)*s), s, x, (-Rational(1, 2), 0)) == \ erf(sqrt(x)) # 8.4.19 assert simplify(IMT(gamma(a/2 + s)/gamma(a/2 - s + 1), s, x, (-re(a)/2, Rational(3, 4)))) \ == besselj(a, 2*sqrt(x)) assert simplify(IMT(2**a*gamma(Rational(1, 2) - 2*s)*gamma(s + (a + 1)/2) / (gamma(1 - s - a/2)*gamma(1 - 2*s + a)), s, x, (-(re(a) + 1)/2, Rational(1, 4)))) == \ sin(sqrt(x))*besselj(a, sqrt(x)) assert simplify(IMT(2**a*gamma(a/2 + s)*gamma(Rational(1, 2) - 2*s) / (gamma(Rational(1, 2) - s - a/2)*gamma(1 - 2*s + a)), s, x, (-re(a)/2, Rational(1, 4)))) == \ cos(sqrt(x))*besselj(a, sqrt(x)) # TODO this comes out as an amazing mess, but simplifies nicely assert simplify(IMT(gamma(a + s)*gamma(Rational(1, 2) - s) / (sqrt(pi)*gamma(1 - s)*gamma(1 + a - s)), s, x, (-re(a), Rational(1, 2)))) == \ besselj(a, sqrt(x))**2 assert simplify(IMT(gamma(s)*gamma(Rational(1, 2) - s) / (sqrt(pi)*gamma(1 - s - a)*gamma(1 + a - s)), s, x, (0, Rational(1, 2)))) == \ besselj(-a, sqrt(x))*besselj(a, sqrt(x)) assert simplify(IMT(4**s*gamma(-2*s + 1)*gamma(a/2 + b/2 + s) / (gamma(-a/2 + b/2 - s + 1)*gamma(a/2 - b/2 - s + 1) * gamma(a/2 + b/2 - s + 1)), s, x, (-(re(a) + re(b))/2, Rational(1, 2)))) == \ besselj(a, sqrt(x))*besselj(b, sqrt(x)) # Section 8.4.20 # TODO this can be further simplified! assert simplify(IMT(-2**(2*s)*cos(pi*a/2 - pi*b/2 + pi*s)*gamma(-2*s + 1) * gamma(a/2 - b/2 + s)*gamma(a/2 + b/2 + s) / (pi*gamma(a/2 - b/2 - s + 1)*gamma(a/2 + b/2 - s + 1)), s, x, (Max(-re(a)/2 - re(b)/2, -re(a)/2 + re(b)/2), Rational(1, 2)))) == \ besselj(a, sqrt(x))*-(besselj(-b, sqrt(x)) - besselj(b, sqrt(x))*cos(pi*b))/sin(pi*b) # TODO more # for coverage assert IMT(pi/cos(pi*s), s, x, (0, Rational(1, 2))) == sqrt(x)/(x + 1)