def test_powdenest_polar(): from sympy import powdenest x, y, z = symbols('x y z', polar=True) a, b, c = symbols('a b c') assert powdenest((x * y * z)**a) == x**a * y**a * z**a assert powdenest((x**a * y**b)**c) == x**(a * c) * y**(b * c) assert powdenest(((x**a)**b * y**c)**c) == x**(a * b * c) * y**(c**2)
def test_powdenest_fail_in_polys(): from sympy import powdenest from sympy.abc import x, y, z, a, b assert powdenest((((x**2 * y**4)**a)**(x * y)), force=True) == (x**2 * y**4)**(a * x * y) assert powdenest((((x**2 * y**4)**a)**(x * y))**3, force=True) == (x**2 * y**4)**(3 * a * x * y)
def test_powdenest_polar(): from sympy import powdenest x, y, z = symbols('x y z', polar=True) a, b, c = symbols('a b c') assert powdenest((x*y*z)**a) == x**a*y**a*z**a assert powdenest((x**a*y**b)**c) == x**(a*c)*y**(b*c) assert powdenest(((x**a)**b*y**c)**c) == x**(a*b*c)*y**(c**2)
def test_issue_19627(): # if you use force the user must verify assert powdenest(sqrt(sin(x)**2), force=True) == sin(x) assert powdenest((x**(S.Half / y))**(2 * y), force=True) == x from sympy import expand_power_base e = 1 - a expr = (exp(z / e) * x**(b / e) * y**((1 - b) / e))**e assert powdenest(expand_power_base(expr, force=True), force=True) == x**b * y**(1 - b) * exp(z)
def calc_gaussian_errorprop_single(equation, datadict): err_expr = 0 calc = {} for n, data in datadict.items(): if isinstance(data, tuple): if not len(data) == 2: raise ValueError( "{} tuple does not have two elements!".format(n)) else: raise ValueError("{} data is not a 2-tuple!".format(n)) # generate derivates symbol = sy.Symbol(n) symbol_err = sy.Symbol("sigma_{}".format(n)) symbol_der = sy.diff(equation, symbol) symbol_der = symbol_der * symbol_err calc[n] = (symbol, symbol_der, symbol_err) err_expr = err_expr + symbol_der**2 err_expr = sy.simplify(sy.sqrt(err_expr)) err_expr = sy.powdenest(err_expr, force=True) nominal = equation deviation = err_expr # calculate nominal + deviate values for n, d in datadict.items(): nominal = nominal.subs(calc[n][0], str(d[0])) deviation = deviation.subs(calc[n][0], str(d[0])) deviation = deviation.subs(calc[n][2], str(d[1])) return nominal, deviation
def mysimp(expr): return powsimp( powdenest(expand( unpolarify( simplify( expand(combsimp(expand_func( expr.rewrite(besselj))))))), polar=True))
def test_branch_bug(): from sympy import powdenest, lowergamma # TODO gammasimp cannot prove that the factor is unity assert powdenest(integrate(erf(x**3), x, meijerg=True).diff(x), polar=True) == 2*erf(x**3)*gamma(S(2)/3)/3/gamma(S(5)/3) assert integrate(erf(x**3), x, meijerg=True) == \ 2*x*erf(x**3)*gamma(S(2)/3)/(3*gamma(S(5)/3)) \ - 2*gamma(S(2)/3)*lowergamma(S(2)/3, x**6)/(3*sqrt(pi)*gamma(S(5)/3))
def test_branch_bug(): from sympy import powdenest, lowergamma # TODO combsimp cannot prove that the factor is unity assert powdenest(integrate(erf(x**3), x, meijerg=True).diff(x), polar=True) == 2*erf(x**3)*gamma(S(2)/3)/3/gamma(S(5)/3) assert integrate(erf(x**3), x, meijerg=True) == \ 2*x*erf(x**3)*gamma(S(2)/3)/(3*gamma(S(5)/3)) \ - 2*gamma(S(2)/3)*lowergamma(S(2)/3, x**6)/(3*sqrt(pi)*gamma(S(5)/3))
def Lame(metric, evalutation=0, contra=1): ''' calculate Lame coefficients from contravariant metric tensor g^{ij} where Hi = sqrt(g_{ii}) = 1/sqrt(g^{ii}) contra == 1: J = sqrt(|g_{ij}|) contra == 0: J = sqrt(|g^{ij}|) [email protected] 2020.06.17 ''' if contra == 1: # calculate Lame coefficients from cotra-variant metric tensor co_metric = metric.inv(method='GE') H = [ sympy.powdenest(sympy.sqrt(co_metric[0, 0]), force=True), sympy.powdenest(sympy.sqrt(co_metric[1, 1]), force=True), sympy.powdenest(sympy.sqrt(co_metric[2, 2]), force=True) ] elif contra == 0: # calculate Lame coefficients from co-variant metric tensor H = [ sympy.powdenest(sympy.sqrt(metric[0, 0]), force=True), sympy.powdenest(sympy.sqrt(metric[1, 1]), force=True), sympy.powdenest(sympy.sqrt(metric[2, 2]), force=True) ] return H
def test_bessel(): from sympy import (besselj, Heaviside, besseli, polar_lift, exp_polar, powdenest) assert simplify(integrate(besselj(a, z)*besselj(b, z)/z, (z, 0, oo), meijerg=True, conds='none')) == \ 2*sin(pi*a/2 - pi*b/2)/(pi*(a - b)*(a + b)) assert simplify(integrate(besselj(a, z)*besselj(a, z)/z, (z, 0, oo), meijerg=True, conds='none')) == 1/(2*a) # TODO more orthogonality integrals # TODO there is some improvement possible here: # - the result can be simplified to besselj(y, z)) assert powdenest(simplify(integrate(sin(z*x)*(x**2-1)**(-(y+S(1)/2)), (x, 1, oo), meijerg=True, conds='none') *2/((z/2)**y*sqrt(pi)*gamma(S(1)/2-y))), polar=True) == \ exp(-I*pi*y/2)*besseli(y, z*exp_polar(I*pi/2)) # Werner Rosenheinrich # SOME INDEFINITE INTEGRALS OF BESSEL FUNCTIONS assert integrate(x*besselj(0, x), x, meijerg=True) == x*besselj(1, x) assert integrate(x*besseli(0, x), x, meijerg=True) == x*besseli(1, x) # TODO can do higher powers, but come out as high order ... should they be # reduced to order 0, 1? assert integrate(besselj(1, x), x, meijerg=True) == -besselj(0, x) assert integrate(besselj(1, x)**2/x, x, meijerg=True) == \ -(besselj(0, x)**2 + besselj(1, x)**2)/2 # TODO more besseli when tables are extended or recursive mellin works assert integrate(besselj(0, x)**2/x**2, x, meijerg=True) == \ -2*x*besselj(0, x)**2 - 2*x*besselj(1, x)**2 \ + 2*besselj(0, x)*besselj(1, x) - besselj(0, x)**2/x assert integrate(besselj(0, x)*besselj(1, x), x, meijerg=True) == \ -besselj(0, x)**2/2 assert integrate(x**2*besselj(0, x)*besselj(1, x), x, meijerg=True) == \ x**2*besselj(1, x)**2/2 assert integrate(besselj(0, x)*besselj(1, x)/x, x, meijerg=True) == \ (x*besselj(0, x)**2 + x*besselj(1, x)**2 - \ besselj(0, x)*besselj(1, x)) # TODO how does besselj(0, a*x)*besselj(0, b*x) work? # TODO how does besselj(0, x)**2*besselj(1, x)**2 work? # TODO sin(x)*besselj(0, x) etc come out a mess # TODO can x*log(x)*besselj(0, x) be done? # TODO how does besselj(1, x)*besselj(0, x+a) work? # TODO more indefinite integrals when struve functions etc are implemented # test a substitution assert integrate(besselj(1, x**2)*x, x, meijerg=True) == \ -besselj(0, x**2)/2
def extra_simple(mul): """Simplification of pysb rates Arguments: mul: psyb reaction (sympy.Mul object) Returns: a simplified version denested of exponents. TODO: make sure it fully simplifies! """ return sp.powsimp((sp.expand_power_base(sp.powdenest(sp.logcombine( sp.expand_log(mul.simplify(), force=True), force=True), force=True), force=True)), force=True)
def Jacobian(metric, evaluation=0, contra=1): ''' calculate Jacobian from contravariant metric tensor g^{ij} where J = sqrt(|g_{ij}}) = 1/sqrt(|g^{ij}|) contra == 1: J = sqrt(|g_{ij}|) contra == 0: J = sqrt(|g^{ij}|) [email protected] 2020.06.08 ''' # Jacob = sympy.powdenest(sympy.sqrt(metric[0,0]*(metric[1,1]*metric[2,2] - metric[1,2]*metric[2,1]) - metric[0,1]*(metric[1,0]*metric[2,2] - metric[1,2]*metric[2,0]) + metric[0,2]*(metric[1,0]*metric[2,1] - metric[1,1]*metric[2,0])), force=True) Jacob = sympy.powdenest(sympy.sqrt(metric.det()), force=True) if contra == 1: J = Jacob**-1 else: J = Jacob return J
def get_s23zero_limit(exp): lexp = (exp.subs(s23, 0)).as_ordered_terms() new_exp = 0 bar = BAR("proceesing", len(lexp)) for term in lexp: dummy1 = 1 for f in term.as_ordered_factors(): dummy2 = 0 for ft in f.as_ordered_terms(): dummy2 += sp.powdenest(ft, force=True).simplify() dummy1 *= dummy2 new_exp += dummy1 bar.next() bar.finish() lexp = new_exp.as_ordered_terms() new_exp = sp.S(0) for term in lexp: if evaluate(term, 0, verb=False) == 0: continue new_exp += term.replace(sp.log(a), sp.log(sp.Abs(a))) return new_exp
def test_powdenest(): from sympy import powdenest from sympy.abc import x, y, z, a, b p, q = symbols('p q', positive=True) i, j = symbols('i,j', integer=True) assert powdenest(x) == x assert powdenest(x + 2*(x**(2*a/3))**(3*x)) == (x + 2*(x**(2*a/3))**(3*x)) assert powdenest((exp(2*a/3))**(3*x)) # -X-> (exp(a/3))**(6*x) assert powdenest((x**(2*a/3))**(3*x)) == ((x**(2*a/3))**(3*x)) assert powdenest(exp(3*x*log(2))) == 2**(3*x) assert powdenest(sqrt(p**2)) == p i, j = symbols('i,j', integer=True) eq = p**(2*i)*q**(4*i) assert powdenest(eq) == (p*q**2)**(2*i) assert powdenest((x**x)**(i + j)) # -X-> (x**x)**i*(x**x)**j == x**(x*(i + j)) assert powdenest(exp(3*y*log(x))) == x**(3*y) assert powdenest(exp(y*(log(a) + log(b)))) == (a*b)**y assert powdenest(exp(3*(log(a) + log(b)))) == a**3*b**3 assert powdenest(((x**(2*i))**(3*y))**x) == ((x**(2*i))**(3*y))**x assert powdenest(((x**(2*i))**(3*y))**x, force=True) == x**(6*i*x*y) assert powdenest(((x**(2*a/3))**(3*y/i))**x) == (((x**(2*a/3))**(3*y/i))**x) assert powdenest((x**(2*i)*y**(4*i))**z, force=True) == (x*y**2)**(2*i*z) assert powdenest((p**(2*i)*q**(4*i))**j) == (p*q**2)**(2*i*j) assert powdenest(((p**(2*a))**(3*y))**x) == p**(6*a*x*y) e = ((x**2*y**4)**a)**(x*y) assert powdenest(e) == e e = (((x**2*y**4)**a)**(x*y))**3 assert powdenest(e) == ((x**2*y**4)**a)**(3*x*y) assert powdenest((((x**2*y**4)**a)**(x*y)), force=True) == (x*y**2)**(2*a*x*y) assert powdenest((((x**2*y**4)**a)**(x*y))**3, force=True) == (x*y**2)**(6*a*x*y) assert powdenest((x**2*y**6)**i) != (x*y**3)**(2*i) x, y = symbols('x,y', positive=True) assert powdenest((x**2*y**6)**i) == (x*y**3)**(2*i) assert powdenest((x**(2*i/3)*y**(i/2))**(2*i)) == (x**(S(4)/3)*y)**(i**2) assert powdenest(sqrt(x**(2*i)*y**(6*i))) == (x*y**3)**i # issue 2706 assert powdenest(((gamma(x)*hyper((),(),x))*pi)**2) == (pi*gamma(x)*hyper((), (), x))**2 assert powdenest(4**x) == 2**(2*x) assert powdenest((4**x)**y) == 2**(2*x*y) assert powdenest(4**x*y) == 2**(2*x)*y
def test_powdenest(): from sympy import powdenest from sympy.abc import x, y, z, a, b p = symbols('p', positive=True) i, j = symbols('i,j', integer=1) assert powdenest(x) == x assert powdenest(x + 2*(x**(2*a/3))**(3*x)) == x + 2*(x**(a/3))**(6*x) assert powdenest((exp(2*a/3))**(3*x)) == (exp(a/3))**(6*x) assert powdenest((x**(2*a/3))**(3*x)) == (x**(a/3))**(6*x) assert powdenest(exp(3*x*log(2))) == 2**(3*x) assert powdenest(sqrt(p**2)) == p i, j = symbols('i,j', integer=1) assert powdenest((x**x)**(i + j)) # -X-> (x**x)**i*(x**x)**j == x**(x*(i + j)) assert powdenest(exp(3*y*log(x))) == x**(3*y) assert powdenest(exp(y*(log(a) + log(b)))) == (a*b)**y assert powdenest(exp(3*(log(a) + log(b)))) == a**3*b**3 assert powdenest(((x**(2*i))**(3*y))**x) == ((x**(2*i))**(3*y))**x assert powdenest(((x**(2*i))**(3*y))**x, force=True) == x**(6*i*x*y) assert powdenest(((x**(2*a/3))**(3*y/i))**x) == ((x**(a/3))**(y/i))**(6*x) assert powdenest((x**(2*i)*y**(4*i))**z, force=True) == (x*y**2)**(2*i*z) e = ((x**2*y**4)**a)**(x*y) assert powdenest(e) == e e = (((x**2*y**4)**a)**(x*y))**3 assert powdenest(e) == ((x**2*y**4)**a)**(3*x*y)
def test_powdenest_fail_in_polys(): from sympy import powdenest from sympy.abc import x, y, z, a, b assert powdenest((((x**2*y**4)**a)**(x*y)), force=True) == (x**2*y**4)**(a*x*y) assert powdenest((((x**2*y**4)**a)**(x*y))**3, force=True) == (x**2*y**4)**(3*a*x*y)
def test_inverse_mellin_transform(): from sympy import (sin, simplify, expand_func, powsimp, Max, Min, expand, powdenest, powsimp, exp_polar) 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 IMT(s/(2*s**2 - 2), s, x, (2, oo)) \ == (x**2/2 + S(1)/2)*Heaviside(1 - x)/(2*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*Heaviside(-x + 1)/2 - Heaviside(x - 1)/(2*x) # test expansion of sums assert IMT(gamma(s) + gamma(s - 1), s, x, (1, oo)) == (x + 1) * exp(-x) / x # test factorisation of polys assert simplify(expand_func(IMT(1/(s**2 + 1), s, exp(-x), (None, oo))).rewrite(sin)) \ == sin(x)*Heaviside(1 - exp(-x)) # test multiplicative substitution a, b = symbols('a b', positive=True) c, d = symbols('c d') 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) from sympy import expand_mul def simp_pows(expr): return expand_mul(simplify(powsimp(expr, force=True)), deep=True).replace(exp_polar, exp) # XXX ? # Now test the inverses of all direct transforms tested above # Section 8.4.2 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 # TODO should this simplify further? 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)))) \ == d**c*(x/d)**c/(-d + x) - d**c/(-d + x) # TODO is calling simplify twice a bug? assert simplify(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 + sqrt(b**2 + x))**(a - 1)*(b**2 + b*sqrt(b**2 + x) + 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 + sqrt(b**2 + x))**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, (-S(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 sympy 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)))) == \ log(1-x)*Heaviside(1-x) + log(x-1)*Heaviside(x-1) assert mysimp(IMT(pi/(s*tan(pi*s)), s, x, (0, 1))) == \ log(1/x - 1)*Heaviside(1-x) + log(1 - 1/x)*Heaviside(x-1) # 8.4.14 assert IMT(-gamma(s + S(1)/2)/(sqrt(pi)*s), s, x, (-S(1)/2, 0)) == \ erf(sqrt(x)) # 8.4.19 # TODO these come out ugly def mysimp(expr): return expand( unpolarify(simplify(expand(expand_func(expr.rewrite(besselj)))))) assert mysimp(IMT(gamma(a/2 + s)/gamma(a/2 - s + 1), s, x, (-re(a)/2, S(3)/4))) \ == besselj(a, 2*sqrt(x)*polar_lift(-1))*exp(-I*pi*a) assert mysimp(IMT(2**a*gamma(S(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, S(1)/4))) == \ exp(-I*pi*a)*sin(sqrt(x))*besselj(a, sqrt(x)*polar_lift(-1)) assert mysimp(IMT(2**a*gamma(a/2 + s)*gamma(S(1)/2 - 2*s) \ / (gamma(S(1)/2 - s - a/2)*gamma(1 - 2*s + a)), s, x, (-re(a)/2, S(1)/4))) == \ exp(-I*pi*a)*cos(sqrt(x))*besselj(a, sqrt(x)*polar_lift(-1)) # TODO this comes out as an amazing mess, but surprisingly enough mysimp is # effective ... assert powsimp(powdenest(mysimp(IMT(gamma(a + s)*gamma(S(1)/2 - s) \ / (sqrt(pi)*gamma(1 - s)*gamma(1 + a - s)), s, x, (-re(a), S(1)/2))), polar=True)) == \ exp(-2*I*pi*a)*besselj(a, sqrt(x)*polar_lift(-1))**2 # NOTE the next is indeed an even function of sqrt(x), so the result is # correct assert mysimp(IMT(gamma(s)*gamma(S(1)/2 - s) \ / (sqrt(pi)*gamma(1 - s - a)*gamma(1 + a - s)), s, x, (0, S(1)/2))) == \ besselj(-a, polar_lift(-1)*sqrt(x))*besselj(a, polar_lift(-1)*sqrt(x)) assert mysimp(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, S(1)/2))) == \ exp(-I*pi*a)*exp(-I*pi*b)*besselj(a, sqrt(x)*polar_lift(-1)) \ *besselj(b, sqrt(x)*polar_lift(-1))
def test_powdenest_polar(): x, y, z = symbols("x y z", polar=True) a, b, c = symbols("a b c") assert powdenest((x * y * z)**a) == x**a * y**a * z**a assert powdenest((x**a * y**b)**c) == x**(a * c) * y**(b * c) assert powdenest(((x**a)**b * y**c)**c) == x**(a * b * c) * y**(c**2)
4 * x) print(sympy.apart(expr)) # 三角化简 trigsimp expr = sympy.sin(x) / sympy.cos(x) print(sympy.trigsimp(expr)) # 三角展开 expand_trig expr = sympy.sin(x + y) print(sympy.expand_trig(expr)) # 指数化简 powsimp / 指数展开 expand_power_exp a, b = sympy.symbols('a b') expr = x**a * x**b print(sympy.powsimp(expr)) # 化简指数的指数 powdenest # 必须满足条件 底数 positive=True x = sympy.symbols('x', positive=True) expr = (x**a)**b print(sympy.powdenest(expr)) # 对数展开 expand_log / 对数合并 logcombine # 需要指出 log ln 在 sympy 中都是自然对数 # symbol 也需要满足条件 x, y = sympy.symbols('x y', positive=True) n = sympy.symbols('n', real=True) print(sympy.expand_log(sympy.log(x**n))) print(sympy.expand_log(sympy.log(x * y))) # more: # series-泰勒展开函数 # diff-求导 # pprint-将公式用更好看的格式打印出来 sympy.pprint(x / (y + 1))
def test_integrate_pole_part(self): for j in (0, 1): for i, I_j_before in enumerate([ Product(self.monomial_product1, self.regulator_poles, self.cal_I), Product(self.monomial_product2, self.regulator_poles, self.cal_I) ]): I_j_after = integrate_pole_part(I_j_before, j) I_j_pole_part = Sum(*I_j_after[:-1]) I_j_numerically_integrable_part = I_j_after[-1] if j == 0: expected_pole_part = sympify_expression(''' ( 1/(-2 + 0 + 1 - eps0 - 3*eps1) * (A + B*x0 + C*x0**2*x1 + D*x1) + 1/(-2 + 1 + 1 - eps0 - 3*eps1) * (B + 2*C*x0*x1) ) * (x1**2)**(-2 - eps0 - 3*eps1) ''').subs('x0', 0) expected_numerical_integrand = ( sympify_expression(str(self.cal_I)) - sympify_expression('A + D*x1 + x0*B') ) * sympify_expression(str(self.exponentiated_monomial1)) if i == 0: for summand in I_j_pole_part.summands: np.testing.assert_array_equal( summand.factors[0].factors[0].expolist, [(0, 2, 0, 0)]) np.testing.assert_array_equal( summand.factors[0].factors[0].coeffs, [1]) self.assertEqual( sympify_expression( str(summand.factors[0].factors[0].exponent) ) - sympify_expression('-2 - eps0 - 3*eps1'), 0) elif i == 1: for summand in I_j_pole_part.summands: np.testing.assert_array_equal( summand.factors[0].factors[0].expolist, [(0, 2, 0, 0)]) np.testing.assert_array_equal( summand.factors[0].factors[1].expolist, [(0, 4, 0, 0)]) np.testing.assert_array_equal( summand.factors[0].factors[0].coeffs, [1]) np.testing.assert_array_equal( summand.factors[0].factors[1].coeffs, [1]) self.assertEqual( sympify_expression( str(summand.factors[0].factors[0].exponent) ) - sympify_expression(-2), 0) self.assertEqual( sympify_expression( str(summand.factors[0].factors[1].exponent) ) - sympify_expression('- eps0 - 3*eps1') / 2, 0) else: raise IndexError('`i` should only run over `(0,1)`!') elif j == 1: expected_pole_part = sympify_expression(''' ( 1/( 2*(-2 - eps0 - 3*eps1) + 0 + 1 ) * (A + B*x0 + C*x0**2*x1 + D*x1) + 1/( 2*(-2 - eps0 - 3*eps1) + 1 + 1 ) * (C*x0**2 + D) + 0 ) * x0**(-2 - eps0 - 3*eps1) ''').subs('x1', 0) expected_numerical_integrand = ( sympify_expression(str(self.cal_I)) - sympify_expression('A + B*x0 + C*x0**2*x1 + D*x1') ) * sympify_expression(str(self.exponentiated_monomial1)) else: raise IndexError('`j` should only run over `(0,1)`!') self.assertEqual( sp.powdenest((sympify_expression(str(I_j_pole_part)) - expected_pole_part), force=True).simplify(), 0) for summand in I_j_pole_part.summands: self.assertEqual(type(summand), Product) self.assertEqual(type(summand.factors[0]), Product) for factor in summand.factors[0].factors: self.assertEqual(type(factor), ExponentiatedPolynomial) self.assertEqual(type(I_j_numerically_integrable_part), Product) self.assertEqual( type(I_j_numerically_integrable_part.factors[0]), Product) for factor in I_j_numerically_integrable_part.factors[ 0].factors: self.assertEqual(type(factor), ExponentiatedPolynomial) should_be_zero = ( sympify_expression(I_j_numerically_integrable_part) - expected_numerical_integrand).simplify() if i == 1: # need some simplifications that are not generally true for all complex numbers # see http://docs.sympy.org/dev/tutorial/simplification.html#powers for a discussion should_be_zero = sp.expand_power_base(should_be_zero, force=True) should_be_zero = sp.powdenest(should_be_zero, force=True) self.assertEqual(should_be_zero, 0)
def test_powdenest(): from sympy import powdenest from sympy.abc import x, y, z, a, b p, q = symbols('p q', positive=True) i, j = symbols('i,j', integer=True) assert powdenest(x) == x assert powdenest(x + 2 * (x**(a * Rational(2, 3)))**(3 * x)) == ( x + 2 * (x**(a * Rational(2, 3)))**(3 * x)) assert powdenest( (exp(a * Rational(2, 3)))**(3 * x)) # -X-> (exp(a/3))**(6*x) assert powdenest( (x**(a * Rational(2, 3)))**(3 * x)) == ((x**(a * Rational(2, 3)))**(3 * x)) assert powdenest(exp(3 * x * log(2))) == 2**(3 * x) assert powdenest(sqrt(p**2)) == p eq = p**(2 * i) * q**(4 * i) assert powdenest(eq) == (p * q**2)**(2 * i) # -X-> (x**x)**i*(x**x)**j == x**(x*(i + j)) assert powdenest((x**x)**(i + j)) assert powdenest(exp(3 * y * log(x))) == x**(3 * y) assert powdenest(exp(y * (log(a) + log(b)))) == (a * b)**y assert powdenest(exp(3 * (log(a) + log(b)))) == a**3 * b**3 assert powdenest(((x**(2 * i))**(3 * y))**x) == ((x**(2 * i))**(3 * y))**x assert powdenest(((x**(2 * i))**(3 * y))**x, force=True) == x**(6 * i * x * y) assert powdenest(((x**(a*Rational(2, 3)))**(3*y/i))**x) == \ (((x**(a*Rational(2, 3)))**(3*y/i))**x) assert powdenest((x**(2 * i) * y**(4 * i))**z, force=True) == (x * y**2)**(2 * i * z) assert powdenest((p**(2 * i) * q**(4 * i))**j) == (p * q**2)**(2 * i * j) e = ((p**(2 * a))**(3 * y))**x assert powdenest(e) == e e = ((x**2 * y**4)**a)**(x * y) assert powdenest(e) == e e = (((x**2 * y**4)**a)**(x * y))**3 assert powdenest(e) == ((x**2 * y**4)**a)**(3 * x * y) assert powdenest((((x**2*y**4)**a)**(x*y)), force=True) == \ (x*y**2)**(2*a*x*y) assert powdenest((((x**2*y**4)**a)**(x*y))**3, force=True) == \ (x*y**2)**(6*a*x*y) assert powdenest((x**2 * y**6)**i) != (x * y**3)**(2 * i) x, y = symbols('x,y', positive=True) assert powdenest((x**2 * y**6)**i) == (x * y**3)**(2 * i) assert powdenest((x**(i * Rational(2, 3)) * y**(i / 2))**(2 * i)) == (x**Rational(4, 3) * y)**(i**2) assert powdenest(sqrt(x**(2 * i) * y**(6 * i))) == (x * y**3)**i assert powdenest(4**x) == 2**(2 * x) assert powdenest((4**x)**y) == 2**(2 * x * y) assert powdenest(4**x * y) == 2**(2 * x) * y
def mysimp(expr): return powsimp(powdenest(expand(unpolarify(simplify(expand(combsimp(expand_func(expr.rewrite(besselj))))))), polar=True))
def test_powdenest(): from sympy import powdenest from sympy.abc import x, y, z, a, b p, q = symbols('p q', positive=True) i, j = symbols('i,j', integer=True) assert powdenest(x) == x assert powdenest(x + 2 * (x**(2 * a / 3))** (3 * x)) == x + 2 * (x**(a / 3))**(6 * x) assert powdenest((exp(2 * a / 3))**(3 * x)) == (exp(a / 3))**(6 * x) assert powdenest((x**(2 * a / 3))**(3 * x)) == (x**(a / 3))**(6 * x) assert powdenest(exp(3 * x * log(2))) == 2**(3 * x) assert powdenest(sqrt(p**2)) == p i, j = symbols('i,j', integer=True) eq = p**(2 * i) * q**(4 * i) assert powdenest(eq) == (p * q**2)**(2 * i) assert powdenest( (x**x)**(i + j)) # -X-> (x**x)**i*(x**x)**j == x**(x*(i + j)) assert powdenest(exp(3 * y * log(x))) == x**(3 * y) assert powdenest(exp(y * (log(a) + log(b)))) == (a * b)**y assert powdenest(exp(3 * (log(a) + log(b)))) == a**3 * b**3 assert powdenest(((x**(2 * i))**(3 * y))**x) == ((x**(2 * i))**(3 * y))**x assert powdenest(((x**(2 * i))**(3 * y))**x, force=True) == x**(6 * i * x * y) assert powdenest( ((x**(2 * a / 3))**(3 * y / i))**x) == ((x**(a / 3))**(y / i))**(6 * x) assert powdenest((x**(2 * i) * y**(4 * i))**z, force=True) == (x * y**2)**(2 * i * z) assert powdenest((p**(2 * i) * q**(4 * i))**j) == (p * q**2)**(2 * i * j) assert powdenest(((p**(2 * a))**(3 * y))**x) == p**(6 * a * x * y) e = ((x**2 * y**4)**a)**(x * y) assert powdenest(e) == e e = (((x**2 * y**4)**a)**(x * y))**3 assert powdenest(e) == ((x**2 * y**4)**a)**(3 * x * y) assert powdenest((((x**2 * y**4)**a)**(x * y)), force=True) == (x * y**2)**(2 * a * x * y) assert powdenest((((x**2 * y**4)**a)**(x * y))**3, force=True) == (x * y**2)**(6 * a * x * y) assert powdenest((x**2 * y**6)**i) != (x * y**3)**(2 * i) x, y = symbols('x,y', positive=True) assert powdenest((x**2 * y**6)**i) == (x * y**3)**(2 * i) assert powdenest( (x**(2 * i / 3) * y**(i / 2))**(2 * i)) == (x**(S(4) / 3) * y)**(i**2) assert powdenest(sqrt(x**(2 * i) * y**(6 * i))) == (x * y**3)**i # issue 2706 assert powdenest(((gamma(x) * hyper( (), (), x)) * pi)**2) == (pi * gamma(x) * hyper((), (), x))**2 assert powdenest(4**x) == 2**(2 * x) assert powdenest((4**x)**y) == 2**(2 * x * y) assert powdenest(4**x * y) == 2**(2 * x) * y
def cancel_unidades(self, unidades): s_unidades = str(powdenest(unidades, force=True).cancel()) # if s_unidades=='1': # s_unidades = '' return s_unidades
def test_H1(): assert simplify(2 * 2**n) == simplify(2**(n + 1)) assert powdenest(2 * 2**n) == simplify(2**(n + 1))
def test_inverse_mellin_transform(): from sympy import (sin, simplify, expand_func, powsimp, Max, Min, expand, powdenest, powsimp, exp_polar) 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 IMT(s/(2*s**2 - 2), s, x, (2, oo)) \ == (x**2/2 + S(1)/2)*Heaviside(1 - x)/(2*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*Heaviside(-x + 1)/2 - Heaviside(x - 1)/(2*x) # test expansion of sums assert IMT(gamma(s) + gamma(s-1), s, x, (1, oo)) == (x + 1)*exp(-x)/x # test factorisation of polys assert simplify(expand_func(IMT(1/(s**2 + 1), s, exp(-x), (None, oo))).rewrite(sin)) \ == sin(x)*Heaviside(1 - exp(-x)) # test multiplicative substitution a, b = symbols('a b', positive=True) c, d = symbols('c d') 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) from sympy import expand_mul def simp_pows(expr): return expand_mul(simplify(powsimp(expr, force=True)), deep=True).replace(exp_polar, exp) # XXX ? # Now test the inverses of all direct transforms tested above # Section 8.4.2 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 # TODO should this simplify further? 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)))) \ == d**c*(x/d)**c/(-d + x) - d**c/(-d + x) # TODO is calling simplify twice a bug? assert simplify(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 + sqrt(b**2 + x))**(a - 1)*(b**2 + b*sqrt(b**2 + x) + 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 + sqrt(b**2 + x))**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, (-S(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 sympy 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)))) == \ log(1-x)*Heaviside(1-x) + log(x-1)*Heaviside(x-1) assert mysimp(IMT(pi/(s*tan(pi*s)), s, x, (0, 1))) == \ log(1/x - 1)*Heaviside(1-x) + log(1 - 1/x)*Heaviside(x-1) # 8.4.14 assert IMT(-gamma(s + S(1)/2)/(sqrt(pi)*s), s, x, (-S(1)/2, 0)) == \ erf(sqrt(x)) # 8.4.19 # TODO these come out ugly def mysimp(expr): return expand(unpolarify(simplify(expand(expand_func(expr.rewrite(besselj)))))) assert mysimp(IMT(gamma(a/2 + s)/gamma(a/2 - s + 1), s, x, (-re(a)/2, S(3)/4))) \ == besselj(a, 2*sqrt(x)*polar_lift(-1))*exp(-I*pi*a) assert mysimp(IMT(2**a*gamma(S(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, S(1)/4))) == \ exp(-I*pi*a)*sin(sqrt(x))*besselj(a, sqrt(x)*polar_lift(-1)) assert mysimp(IMT(2**a*gamma(a/2 + s)*gamma(S(1)/2 - 2*s) \ / (gamma(S(1)/2 - s - a/2)*gamma(1 - 2*s + a)), s, x, (-re(a)/2, S(1)/4))) == \ exp(-I*pi*a)*cos(sqrt(x))*besselj(a, sqrt(x)*polar_lift(-1)) # TODO this comes out as an amazing mess, but surprisingly enough mysimp is # effective ... assert powsimp(powdenest(mysimp(IMT(gamma(a + s)*gamma(S(1)/2 - s) \ / (sqrt(pi)*gamma(1 - s)*gamma(1 + a - s)), s, x, (-re(a), S(1)/2))), polar=True)) == \ exp(-2*I*pi*a)*besselj(a, sqrt(x)*polar_lift(-1))**2 # NOTE the next is indeed an even function of sqrt(x), so the result is # correct assert mysimp(IMT(gamma(s)*gamma(S(1)/2 - s) \ / (sqrt(pi)*gamma(1 - s - a)*gamma(1 + a - s)), s, x, (0, S(1)/2))) == \ besselj(-a, polar_lift(-1)*sqrt(x))*besselj(a, polar_lift(-1)*sqrt(x)) assert mysimp(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, S(1)/2))) == \ exp(-I*pi*a)*exp(-I*pi*b)*besselj(a, sqrt(x)*polar_lift(-1)) \ *besselj(b, sqrt(x)*polar_lift(-1))
def _simplify(expr, doit): from sympy import powdenest, powsimp if doit: return simplify(powdenest(expr, polar=True)) return expr
def test_issue_5805(): arg = ((gamma(x) * hyper((), (), x)) * pi)**2 assert powdenest(arg) == (pi * gamma(x) * hyper((), (), x))**2 assert arg.is_positive is None
def Library_SympyExpressionSimplify( SympyExpression=None, ShowAttemptErrors=None, CheckArguments=True, PrintExtra=False, ): Result = None if ShowAttemptErrors is None: ShowAttemptErrors = False if (CheckArguments): ArgumentErrorMessage = "" if (len(ArgumentErrorMessage) > 0): if (PrintExtra): print("ArgumentErrorMessage:\n", ArgumentErrorMessage) raise Exception(ArgumentErrorMessage) try: Result = SympyExpression #sin = copy.deepcopy(sympy.sin) #cos = copy.deepcopy(sympy.cos) #exp = copy.deepcopy(sympy.exp) #make a copy of input #Result = copy.deepcopy(SympyExpression) #if(PrintExtra): Library_SympyExpressionPrintInfo.Main(Result) #First do the basic built-in simplify Result = Result.simplify().cancel().expand() #.logcombine() #Second -> expand everything in terms of exponents Result = Result.expand() #Try to simplify and gather exponents: Result = sympy.powsimp(Result, deep=True, force=True, combine='all') Result = sympy.powdenest(Result, force=True) #Force Trig Equalities, by plugging in the exp: Result = Result.rewrite(sympy.sin, sympy.exp).rewrite(sympy.cos, sympy.exp) if (PrintExtra): Library_SympyExpressionPrintInfo(Result) #Simplify the Exponentials and trig functions: Result = Result.trigsimp() if (PrintExtra): Library_SympyExpressionPrintInfo(Result) #Force consts to be evaluated: Result = Result.evalf() if (PrintExtra): Library_SympyExpressionPrintInfo(Result) #Do the built in symplifies one more time: Result = Result.simplify().cancel().expand() #.logcombine() if (PrintExtra): Library_SympyExpressionPrintInfo(Result) #Make another copy #FinalResult = copy.deepcopy(Result) #if(PrintExtra):Library_SympyExpressionPrintInfo.Main(FinalResult) except Exception as ExceptionObject: if ShowAttemptErrors: Library_PrintExceptionObject(ExceptionObject) Result = SympyExpression return Result
def test_powdenest(): from sympy import powdenest from sympy.abc import x, y, z, a, b p = symbols('p', positive=True) i, j = symbols('i,j', integer=1) assert powdenest(x) == x assert powdenest(x + 2 * (x**(2 * a / 3))** (3 * x)) == x + 2 * (x**(a / 3))**(6 * x) assert powdenest((exp(2 * a / 3))**(3 * x)) == (exp(a / 3))**(6 * x) assert powdenest((x**(2 * a / 3))**(3 * x)) == (x**(a / 3))**(6 * x) assert powdenest(exp(3 * x * log(2))) == 2**(3 * x) assert powdenest(sqrt(p**2)) == p i, j = symbols('i,j', integer=1) assert powdenest( (x**x)**(i + j)) # -X-> (x**x)**i*(x**x)**j == x**(x*(i + j)) assert powdenest(exp(3 * y * log(x))) == x**(3 * y) assert powdenest(exp(y * (log(a) + log(b)))) == (a * b)**y assert powdenest(exp(3 * (log(a) + log(b)))) == a**3 * b**3 assert powdenest(((x**(2 * i))**(3 * y))**x) == ((x**(2 * i))**(3 * y))**x assert powdenest(((x**(2 * i))**(3 * y))**x, force=True) == x**(6 * i * x * y) assert powdenest( ((x**(2 * a / 3))**(3 * y / i))**x) == ((x**(a / 3))**(y / i))**(6 * x) assert powdenest((x**(2 * i) * y**(4 * i))**z, force=True) == (x * y**2)**(2 * i * z) e = ((x**2 * y**4)**a)**(x * y) assert powdenest(e) == e e = (((x**2 * y**4)**a)**(x * y))**3 assert powdenest(e) == ((x**2 * y**4)**a)**(3 * x * y)
def _simplify(expr, doit): from sympy import powdenest, piecewise_fold if doit: return simplify(powdenest(piecewise_fold(expr), polar=True)) return expr
def test_issue_2706(): arg = ((gamma(x)*hyper((),(),x))*pi)**2 assert powdenest(arg) == (pi*gamma(x)*hyper((), (), x))**2 assert arg.is_positive is None
def test_H1(): assert simplify(2*2**n) == simplify(2**(n + 1)) assert powdenest(2*2**n) == simplify(2**(n + 1))