def test_exp_values(): k = Symbol('k', integer=True) assert exp(nan) == nan assert exp(oo) == oo assert exp(-oo) == 0 assert exp(0) == 1 assert exp(1) == E assert exp(-1 + x).as_base_exp() == (S.Exp1, x - 1) assert exp(1 + x).as_base_exp() == (S.Exp1, x + 1) assert exp(pi * I / 2) == I assert exp(pi * I) == -1 assert exp(3 * pi * I / 2) == -I assert exp(2 * pi * I) == 1 assert refine(exp(pi * I * 2 * k)) == 1 assert refine(exp(pi * I * 2 * (k + Rational(1, 2)))) == -1 assert refine(exp(pi * I * 2 * (k + Rational(1, 4)))) == I assert refine(exp(pi * I * 2 * (k + Rational(3, 4)))) == -I assert exp(log(x)) == x assert exp(2 * log(x)) == x**2 assert exp(pi * log(x)) == x**pi assert exp(17 * log(x) + E * log(y)) == x**17 * y**E assert exp(x * log(x)) != x**x assert exp(sin(x) * log(x)) != x assert exp(3 * log(x) + oo * x) == exp(oo * x) * x**3 assert exp(4 * log(x) * log(y) + 3 * log(x)) == x**3 * exp(4 * log(x) * log(y))
def test_exp_values(): k = Symbol('k', integer=True) assert exp(nan) == nan assert exp(oo) == oo assert exp(-oo) == 0 assert exp(0) == 1 assert exp(1) == E assert exp(-1 + x).as_base_exp() == (S.Exp1, x - 1) assert exp(1 + x).as_base_exp() == (S.Exp1, x + 1) assert exp(pi*I/2) == I assert exp(pi*I) == -1 assert exp(3*pi*I/2) == -I assert exp(2*pi*I) == 1 assert refine(exp(pi*I*2*k)) == 1 assert refine(exp(pi*I*2*(k + Rational(1, 2)))) == -1 assert refine(exp(pi*I*2*(k + Rational(1, 4)))) == I assert refine(exp(pi*I*2*(k + Rational(3, 4)))) == -I assert exp(log(x)) == x assert exp(2*log(x)) == x**2 assert exp(pi*log(x)) == x**pi assert exp(17*log(x) + E*log(y)) == x**17 * y**E assert exp(x*log(x)) != x**x assert exp(sin(x)*log(x)) != x assert exp(3*log(x) + oo*x) == exp(oo*x) * x**3 assert exp(4*log(x)*log(y) + 3*log(x)) == x**3 * exp(4*log(x)*log(y))
def test_pow2(): # powers of (-1) assert refine((-1)**(x + y), Q.even(x)) == (-1)**y assert refine((-1)**(x + y + z), Q.odd(x) & Q.odd(z)) == (-1)**y assert refine((-1)**(x + y + 1), Q.odd(x)) == (-1)**y assert refine((-1)**(x + y + 2), Q.odd(x)) == (-1)**(y + 1) assert refine((-1)**(x + 3)) == (-1)**(x + 1)
def test_atan2(): assert refine(atan2(y, x), Q.real(y) & Q.positive(x)) == atan(y / x) assert refine(atan2(y, x), Q.negative(y) & Q.positive(x)) == atan(y / x) assert refine(atan2(y, x), Q.negative(y) & Q.negative(x)) == atan(y / x) - pi assert refine(atan2(y, x), Q.positive(y) & Q.negative(x)) == atan(y / x) + pi
def symbolic_stuff(): from sympy import Symbol, pi, sqrt, pprint, solve, Eq, solveset, refine Kv = Symbol("Kv", real=True, positive=True) # Kv measured in RPM per volt back_emf - Kv * V Rm = Symbol("Rm", real=True, positive=True) # Winding Resistance V = Symbol("V", real=True, positive=True) I = Symbol("I", real=True, positive=True) # Peak Current I0 = Symbol("I0", real=True, positive=True) # No load current V0 = Symbol("V0", real=True, positive=True) # No load voltage rpm2omega = pi / 30 # multiply RPM by this value to get angular frequency omega Kv_SI = Kv * rpm2omega # Kv in rad/s per volt. # Torque Constant Kq = 1 / Kv_SI # RPM at current I RPM = Kv * (I - I0) Q = Kq * (I - I0) # RPM at voltage V and torque q_in q_in = Symbol("q_in", real=True, positive=True) rpm_in = Symbol("rpm_in", real=True, positive=True) eqns = Eq(Q, q_in) soln = solve(eqns, I, exclude=[I0]) pprint(eqns) print(("RPM at torque Q: {}".format(RPM.subs(I, soln[0])))) # Efficiency eta = (V - I * Rm) * (I - I0) / (V * I) print(("efficiency={}".format(eta))) # Current at Max Efficiency Imax = sqrt(V * I0 / Rm) # Torque at max efficiency: Qmax = Kq * (Imax - I0) # RPM at max eff. RPMmax = Kv * (V - Imax * Rm) print("Current at Max Efficiency: {}".format(Imax)) print("RPM at Max Efficiency : {}".format(RPMmax)) print("Torque at Max Efficiency : {}".format(Qmax)) I_max = Symbol("I_max", real=True, positive=True) eqns = Imax - I_max pprint(eqns) IOsoln = refine(solve(eqns, I0)) print("No-load-current : {}".format(IOsoln)) IOsoln = refine(solveset(eqns, I0)) print("No-load-current : {}".format(IOsoln))
def test_exp_infinity(): assert exp(I * y) != nan assert refine(exp(I * oo)) is nan assert refine(exp(-I * oo)) is nan assert exp(y * I * oo) != nan assert exp(zoo) is nan x = Symbol('x', extended_real=True, finite=False) assert exp(x).is_complex is None
def test_pow4(): assert refine((-1)**((-1)**x/2 - 7*S.Half), Q.integer(x)) == (-1)**(x + 1) assert refine((-1)**((-1)**x/2 - 9*S.Half), Q.integer(x)) == (-1)**x # powers of Abs assert refine(Abs(x)**2, Q.real(x)) == x**2 assert refine(Abs(x)**3, Q.real(x)) == Abs(x)**3 assert refine(Abs(x)**2) == Abs(x)**2
def test_pow2(): assert refine((-1)**((-1)**x/2 - 7*S.Half), Q.integer(x)) == (-1)**(x + 1) assert refine((-1)**((-1)**x/2 - 9*S.Half), Q.integer(x)) == (-1)**x # powers of Abs assert refine(Abs(x)**2, Q.real(x)) == x**2 assert refine(Abs(x)**3, Q.real(x)) == Abs(x)**3 assert refine(Abs(x)**2) == Abs(x)**2
def test_refine_issue_12724(): expr1 = refine(Abs(x * y), Q.positive(x)) expr2 = refine(Abs(x * y * z), Q.positive(x)) assert expr1 == x * Abs(y) assert expr2 == x * Abs(y * z) y1 = Symbol('y1', real = True) expr3 = refine(Abs(x * y1**2 * z), Q.positive(x)) assert expr3 == x * y1**2 * Abs(z)
def test_matrixelement(): x = MatrixSymbol('x', 3, 3) i = Symbol('i', positive = True) j = Symbol('j', positive = True) assert refine(x[0, 1], Q.symmetric(x)) == x[0, 1] assert refine(x[1, 0], Q.symmetric(x)) == x[0, 1] assert refine(x[i, j], Q.symmetric(x)) == x[j, i] assert refine(x[j, i], Q.symmetric(x)) == x[j, i]
def test_exp(): x = symbols('x') assert refine(exp(pi * I * 2 * x), Assume(x, Q.integer)) == 1 assert refine(exp(pi * I * 2 * (x + Rational(1, 2))), Assume(x, Q.integer)) == -1 assert refine(exp(pi * I * 2 * (x + Rational(1, 4))), Assume(x, Q.integer)) == I assert refine(exp(pi * I * 2 * (x + Rational(3, 4))), Assume(x, Q.integer)) == -I
def test_complex(): assert refine(re(1/(x + I*y)), Q.real(x) & Q.real(y)) == \ x/(x**2 + y**2) assert refine(im(1/(x + I*y)), Q.real(x) & Q.real(y)) == \ -y/(x**2 + y**2) assert refine(re((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y) & Q.real(z)) == w*y - x*z assert refine(im((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y) & Q.real(z)) == w*z + x*y
def test_Abs(): x = Symbol('x', positive=True) assert Abs(x) == x assert 1 + Abs(x) == 1 + x x = Symbol('x', negative=True) assert Abs(x) == -x assert 1 + Abs(x) == 1 - x x = Symbol('x') assert refine(Abs(x**2)) != x**2 x = Symbol('x', real=True) assert refine(Abs(x**2)) == x**2
def r_lambda(M): _N = M[:-1, :-1] nb_rows, nb_cols = _N.shape hnm = _h(n, m)(_N).evalf() knm = _k(n, m)(_N).evalf() iknm = sp.refine(invert(knm), sp.Q.integer(k)) eN = sp.refine(sp.simplify(hnm) * iknm, sp.Q.integer(k)) return sp.Matrix( sp.BlockMatrix( [[eN, sp.zeros(nb_rows, 1)], [sp.zeros(1, nb_cols), sp.Matrix([sp.exp(M[-1, -1])])]]))
def set_weighted_error_model(model): """Encode error model with one epsilon and W as weight""" stats, y, f = _preparations(model) epsilons = model.random_variables.epsilons expr = stats.find_assignment(y.name).expression ssum = 0 q = sympy.Q.real(y) # Dummy predicate for term in expr.args: eps = [x for x in term.free_symbols if x.name in epsilons.names] if len(eps) > 0: eps = eps[0] remaining = term / eps ssum += remaining ** 2 for symb in remaining.free_symbols: q &= sympy.Q.positive(symb) w = sympy.sqrt(ssum) w = sympy.refine(w, q) for i, s in enumerate(stats): if isinstance(s, Assignment) and s.symbol == y: stats.insert(i, Assignment('W', w)) break stats.reassign(y, f + sympy.Symbol('W') * sympy.Symbol(epsilons[0].name)) model.remove_unused_parameters_and_rvs() return model
def calculate_absolute_uncertainty( self, *assumptions: List[AppliedPredicate], refine: bool = False, delta_char: str = '\\Delta ') -> 'Expression': """Calculate the absolute uncertainty in the expression (IB way), assuming all args given are independent. :return: the absolute uncertainty of this expression :rtype: Expression >>> Expression([a], c * a).calculate_absolute_uncertainty(sympy.Q.positive(c), refine=True, delta_char='Δ') f(Δa) = c*Δa >>> Expression([a, b, c], a + b - c).calculate_absolute_uncertainty(refine=True, delta_char='Δ') f(Δa, Δb, Δc) = Δa + Δb + Δc """ uncertainty_expr = sympy.Integer(0) # just in case uncertainty_args = [] global_assumptions.add(*assumptions) for var in self.args: d_var = sympy.Symbol(delta_char + sympy.latex(var)) uncertainty_args.append(d_var) uncertainty_expr += sympy.Abs(self.expr.diff(var)) * d_var global_assumptions.add(sympy.Q.positive(var)) if refine: uncertainty_expr = sympy.refine(uncertainty_expr) global_assumptions.clear() return Expression(uncertainty_args, uncertainty_expr)
def test_issue_8545(): from sympy import refine eq = 1 - x - abs(1 - x) ans = And(Lt(1, x), Lt(x, oo)) assert reduce_abs_inequality(eq, '<', x) == ans eq = 1 - x - sqrt((1 - x)**2) assert reduce_inequalities(refine(eq) < 0) == ans
def test_eval_refine(): class MockExpr(Expr): def _eval_refine(self, assumptions): return True mock_obj = MockExpr() assert refine(mock_obj)
def test_atan2(): assert refine(atan2(y, x), Q.real(y) & Q.positive(x)) == atan(y/x) assert refine(atan2(y, x), Q.negative(y) & Q.positive(x)) == atan(y/x) assert refine(atan2(y, x), Q.negative(y) & Q.negative(x)) == atan(y/x) - pi assert refine(atan2(y, x), Q.positive(y) & Q.negative(x)) == atan(y/x) + pi assert refine(atan2(y, x), Q.zero(y) & Q.negative(x)) == pi assert refine(atan2(y, x), Q.positive(y) & Q.zero(x)) == pi/2 assert refine(atan2(y, x), Q.negative(y) & Q.zero(x)) == -pi/2 assert refine(atan2(y, x), Q.zero(y) & Q.zero(x)) == nan
def test_eval_refine(): from sympy.core.expr import Expr class MockExpr(Expr): def _eval_refine(self): return True mock_obj = MockExpr() assert refine(mock_obj)
def test_eval_refine(): from sympy.core.expr import Expr class MockExpr(Expr): def _eval_refine(self, assumptions): return True mock_obj = MockExpr() assert refine(mock_obj)
def test_im(): assert refine(im(x), Q.imaginary(x)) == -I*x assert refine(im(x), Q.real(x)) is S.Zero assert refine(im(x+y), Q.imaginary(x) & Q.imaginary(y)) == -I*x - I*y assert refine(im(x+y), Q.real(x) & Q.imaginary(y)) == -I*y assert refine(im(x*y), Q.imaginary(x) & Q.real(y)) == -I*x*y assert refine(im(x*y), Q.imaginary(x) & Q.imaginary(y)) == 0 assert refine(im(1/x), Q.imaginary(x)) == -I/x assert refine(im(x*y*z), Q.imaginary(x) & Q.imaginary(y) & Q.imaginary(z)) == -I*x*y*z
def test_atan2(): assert atan2.nargs == FiniteSet(2) assert atan2(0, 0) == S.NaN assert atan2(0, 1) == 0 assert atan2(1, 1) == pi/4 assert atan2(1, 0) == pi/2 assert atan2(1, -1) == 3*pi/4 assert atan2(0, -1) == pi assert atan2(-1, -1) == -3*pi/4 assert atan2(-1, 0) == -pi/2 assert atan2(-1, 1) == -pi/4 i = symbols('i', imaginary=True) r = symbols('r', real=True) eq = atan2(r, i) ans = -I*log((i + I*r)/sqrt(i**2 + r**2)) reps = ((r, 2), (i, I)) assert eq.subs(reps) == ans.subs(reps) x = Symbol('x', negative=True) y = Symbol('y', negative=True) assert atan2(y, x) == atan(y/x) - pi y = Symbol('y', nonnegative=True) assert atan2(y, x) == atan(y/x) + pi y = Symbol('y') assert atan2(y, x) == atan2(y, x, evaluate=False) u = Symbol("u", positive=True) assert atan2(0, u) == 0 u = Symbol("u", negative=True) assert atan2(0, u) == pi assert atan2(y, oo) == 0 assert atan2(y, -oo)== 2*pi*Heaviside(re(y)) - pi assert atan2(y, x).rewrite(log) == -I*log((x + I*y)/sqrt(x**2 + y**2)) assert atan2(y, x).rewrite(atan) == 2*atan(y/(x + sqrt(x**2 + y**2))) ex = atan2(y, x) - arg(x + I*y) assert ex.subs({x:2, y:3}).rewrite(arg) == 0 assert ex.subs({x:2, y:3*I}).rewrite(arg) == -pi - I*log(sqrt(5)*I/5) assert ex.subs({x:2*I, y:3}).rewrite(arg) == -pi/2 - I*log(sqrt(5)*I) assert ex.subs({x:2*I, y:3*I}).rewrite(arg) == -pi + atan(2/S(3)) + atan(3/S(2)) i = symbols('i', imaginary=True) r = symbols('r', real=True) e = atan2(i, r) rewrite = e.rewrite(arg) reps = {i: I, r: -2} assert rewrite == -I*log(abs(I*i + r)/sqrt(abs(i**2 + r**2))) + arg((I*i + r)/sqrt(i**2 + r**2)) assert refine((e - rewrite).subs(reps)).equals(0) assert conjugate(atan2(x, y)) == atan2(conjugate(x), conjugate(y)) assert diff(atan2(y, x), x) == -y/(x**2 + y**2) assert diff(atan2(y, x), y) == x/(x**2 + y**2) assert simplify(diff(atan2(y, x).rewrite(log), x)) == -y/(x**2 + y**2) assert simplify(diff(atan2(y, x).rewrite(log), y)) == x/(x**2 + y**2)
def test_issue_8514(): from sympy import simplify, refine a, b, c, = symbols('a b c', positive=True) t = symbols('t', positive=True) ft = simplify(inverse_laplace_transform(1 / (a * s**2 + b * s + c), s, t)) assert ft == ( (exp(t * (exp(I * atan2(0, -4 * a * c + b**2) / 2) - exp(-I * atan2( 0, -4 * a * c + b**2) / 2)) * sqrt(refine(Abs(4 * a * c - b**2))) / (4 * a)) * exp(t * cos(atan2(0, -4 * a * c + b**2) / 2) * sqrt(refine(Abs(4 * a * c - b**2))) / a) + I * sin(t * sin(atan2(0, -4 * a * c + b**2) / 2) * sqrt(refine(Abs(4 * a * c - b**2))) / (2 * a)) - cos(t * sin(atan2(0, -4 * a * c + b**2) / 2) * sqrt(refine(Abs(4 * a * c - b**2))) / (2 * a))) * exp(-t * (b + cos(atan2(0, -4 * a * c + b**2) / 2) * sqrt(refine(Abs(4 * a * c - b**2)))) / (2 * a)) / sqrt(-4 * a * c + b**2))
def test_sign(): x = Symbol('x', real = True) assert refine(sign(x), Q.positive(x)) == 1 assert refine(sign(x), Q.negative(x)) == -1 assert refine(sign(x), Q.zero(x)) == 0 assert refine(sign(x), True) == sign(x) assert refine(sign(Abs(x)), Q.nonzero(x)) == 1 x = Symbol('x', imaginary=True) assert refine(sign(x), Q.positive(im(x))) == S.ImaginaryUnit assert refine(sign(x), Q.negative(im(x))) == -S.ImaginaryUnit assert refine(sign(x), True) == sign(x) x = Symbol('x', complex=True) assert refine(sign(x), Q.zero(x)) == 0
def test_re(): assert refine(re(x), Q.real(x)) == x assert refine(re(x), Q.imaginary(x)) is S.Zero assert refine(re(x+y), Q.real(x) & Q.real(y)) == x + y assert refine(re(x+y), Q.real(x) & Q.imaginary(y)) == x assert refine(re(x*y), Q.real(x) & Q.real(y)) == x * y assert refine(re(x*y), Q.real(x) & Q.imaginary(y)) == 0 assert refine(re(x*y*z), Q.real(x) & Q.real(y) & Q.real(z)) == x * y * z
def test_make_ode_01(): ode, params = _make_ode_01() t, y, y0, k = params result = dsolve(ode, y[1](t)) eq_assumption = sympy.Q.is_true(Ne(k[1], k[0])) refined = refine(result, eq_assumption) ignore = k + y0 + (t,) int_const = [fs for fs in refined.free_symbols if fs not in ignore][0] ref = int_const*exp(-k[1]*t) - exp(-k[0]*t)*k[0]*y0[0]/(k[0] - k[1]) assert (refined.rhs - ref).simplify() == 0
def test_exp_values(): if global_parameters.exp_is_pow: assert type(exp(x)) is Pow else: assert type(exp(x)) is exp k = Symbol('k', integer=True) assert exp(nan) is nan assert exp(oo) is oo assert exp(-oo) == 0 assert exp(0) == 1 assert exp(1) == E assert exp(-1 + x).as_base_exp() == (S.Exp1, x - 1) assert exp(1 + x).as_base_exp() == (S.Exp1, x + 1) assert exp(pi * I / 2) == I assert exp(pi * I) == -1 assert exp(pi * I * Rational(3, 2)) == -I assert exp(2 * pi * I) == 1 assert refine(exp(pi * I * 2 * k)) == 1 assert refine(exp(pi * I * 2 * (k + S.Half))) == -1 assert refine(exp(pi * I * 2 * (k + Rational(1, 4)))) == I assert refine(exp(pi * I * 2 * (k + Rational(3, 4)))) == -I assert exp(log(x)) == x assert exp(2 * log(x)) == x**2 assert exp(pi * log(x)) == x**pi assert exp(17 * log(x) + E * log(y)) == x**17 * y**E assert exp(x * log(x)) != x**x assert exp(sin(x) * log(x)) != x assert exp(3 * log(x) + oo * x) == exp(oo * x) * x**3 assert exp(4 * log(x) * log(y) + 3 * log(x)) == x**3 * exp(4 * log(x) * log(y)) assert exp(-oo, evaluate=False).is_finite is True assert exp(oo, evaluate=False).is_finite is False
def test_issue_8514(): from sympy import simplify, refine a, b, c, = symbols("a b c", positive=True) t = symbols("t", positive=True) ft = simplify(inverse_laplace_transform(1 / (a * s ** 2 + b * s + c), s, t)) assert ft == ( ( exp( t * (exp(I * atan2(0, -4 * a * c + b ** 2) / 2) - exp(-I * atan2(0, -4 * a * c + b ** 2) / 2)) * sqrt(refine(Abs(4 * a * c - b ** 2))) / (4 * a) ) * exp(t * cos(atan2(0, -4 * a * c + b ** 2) / 2) * sqrt(refine(Abs(4 * a * c - b ** 2))) / a) + I * sin(t * sin(atan2(0, -4 * a * c + b ** 2) / 2) * sqrt(refine(Abs(4 * a * c - b ** 2))) / (2 * a)) - cos(t * sin(atan2(0, -4 * a * c + b ** 2) / 2) * sqrt(refine(Abs(4 * a * c - b ** 2))) / (2 * a)) ) * exp(-t * (b + cos(atan2(0, -4 * a * c + b ** 2) / 2) * sqrt(refine(Abs(4 * a * c - b ** 2)))) / (2 * a)) / sqrt(-4 * a * c + b ** 2) )
def get_det_g(self, covariant=True): """Return determinant of covariant metric tensor""" if self._det_g[covariant] is not None: return self._det_g[covariant] if covariant: g = sp.Matrix(self.get_covariant_metric_tensor()).det() else: g = sp.Matrix(self.get_contravariant_metric_tensor()).det() g = sp.refine(g, self._assumptions) g = sp.simplify(g) self._det_g[covariant] = g return g
def Dx(test, x, k=1): """Return k'th order partial derivative in direction x Parameters ---------- test: Expr or BasisFunction x: int axis to take derivative over k: int Number of derivatives """ assert isinstance(test, (Expr, BasisFunction)) if k > 1: for _ in range(k): test = Dx(test, x, 1) return test if isinstance(test, BasisFunction): test = Expr(test) test = copy.copy(test) coors = test.function_space().coors if coors.is_cartesian: v = np.array(test.terms()) v[..., x] += k test._terms = v.tolist() else: assert test.expr_rank( ) < 1, 'Cannot (yet) take derivative of tensor in curvilinear coordinates' psi = coors.psi v = copy.deepcopy(test.terms()) sc = copy.deepcopy(test.scales()) ind = copy.deepcopy(test.indices()) num_terms = test.num_terms() for i in range(test.num_components()): for j in range(num_terms[i]): sc0 = sp.simplify(sp.diff(sc[i][j], psi[x], k)) sc0 = sp.refine(sc0, coors._assumptions) if not sc0 == 0: v[i].append(copy.deepcopy(v[i][j])) sc[i].append(sc0) ind[i].append(ind[i][j]) v[i][j][x] += k test._terms = v test._scales = sc test._indices = ind return test
def test_Abs(): assert refine(Abs(x), Q.positive(x)) == x assert refine(1 + Abs(x), Q.positive(x)) == 1 + x assert refine(Abs(x), Q.negative(x)) == -x assert refine(1 + Abs(x), Q.negative(x)) == 1 - x assert refine(Abs(x ** 2)) != x ** 2 assert refine(Abs(x ** 2), Q.real(x)) == x ** 2
def test_Abs(): assert refine(Abs(x), Q.positive(x)) == x assert refine(1 + Abs(x), Q.positive(x)) == 1 + x assert refine(Abs(x), Q.negative(x)) == -x assert refine(1 + Abs(x), Q.negative(x)) == 1 - x assert refine(Abs(x**2)) != x**2 assert refine(Abs(x**2), Q.real(x)) == x**2
def test_abs(): x = symbols('x') assert refine(abs(x), Assume(x, Q.positive)) == x assert refine(1+abs(x), Assume(x, Q.positive)) == 1+x assert refine(abs(x), Assume(x, Q.negative)) == -x assert refine(1+abs(x), Assume(x, Q.negative)) == 1-x assert refine(abs(x**2)) != x**2 assert refine(abs(x**2), Assume(x, Q.real)) == x**2
def test_abs(): x = symbols('x') assert refine(abs(x), Assume(x, Q.positive)) == x assert refine(1 + abs(x), Assume(x, Q.positive)) == 1 + x assert refine(abs(x), Assume(x, Q.negative)) == -x assert refine(1 + abs(x), Assume(x, Q.negative)) == 1 - x assert refine(abs(x**2)) != x**2 assert refine(abs(x**2), Assume(x, Q.real)) == x**2
def test_action_verbs(): assert nsimplify((1/(exp(3*pi*x/5)+1))) == (1/(exp(3*pi*x/5)+1)).nsimplify() assert ratsimp(1/x + 1/y) == (1/x + 1/y).ratsimp() assert trigsimp(log(x), deep=True) == (log(x)).trigsimp(deep = True) assert radsimp(1/(2+sqrt(2))) == (1/(2+sqrt(2))).radsimp() assert powsimp(x**y*x**z*y**z, combine='all') == (x**y*x**z*y**z).powsimp(combine='all') assert simplify(x**y*x**z*y**z) == (x**y*x**z*y**z).simplify() assert together(1/x + 1/y) == (1/x + 1/y).together() assert separate((x*(y*z)**3)**2) == ((x*(y*z)**3)**2).separate() assert collect(a*x**2 + b*x**2 + a*x - b*x + c, x) == (a*x**2 + b*x**2 + a*x - b*x + c).collect(x) assert apart(y/(y+2)/(y+1), y) == (y/(y+2)/(y+1)).apart(y) assert combsimp(y/(x+2)/(x+1)) == (y/(x+2)/(x+1)).combsimp() assert factor(x**2+5*x+6) == (x**2+5*x+6).factor() assert refine(sqrt(x**2)) == sqrt(x**2).refine() assert cancel((x**2+5*x+6)/(x+2)) == ((x**2+5*x+6)/(x+2)).cancel()
def get_sqrt_det_g(self, covariant=True): """Return square root of determinant of covariant metric tensor""" if self._sqrt_det_g[covariant] is not None: return self._sqrt_det_g[covariant] g = self.get_det_g(covariant) sg = sp.refine(sp.simplify(sp.sqrt(g)), self._assumptions) if isinstance(sg, numbers.Number): if isinstance(sg, numbers.Real): sg = np.float(sg) elif isinstance(sg, numbers.Complex): sg = np.complex(sg) else: raise NotImplementedError self._sqrt_det_g[covariant] = sg return sg
def test_make_integral_01(): integral, params = _make_integral_01() intgr = integral.doit() u0, k, l, t = params # eq: k == l, neq: k != l ref_eq = k * u0 * t ref_neq = -k * u0 / (k - l) * (exp(t * (l - k)) - 1) refined_eq = integral.subs({l: k}).doit() assert (refined_eq - ref_eq).simplify() == 0 eq_assumption = sympy.Q.is_true(sympy.Ne(l, k)) refined_neq = sympy.refine(intgr, eq_assumption).simplify() assert (refined_neq - ref_neq).simplify() == 0
def test_recursive(): from sympy import symbols, refine a, b, c = symbols('a b c', positive=True) r = exp(-(x - a)**2)*exp(-(x - b)**2) e = integrate(r, (x, 0, oo), meijerg=True) assert simplify(e.expand()) == ( sqrt(2)*sqrt(pi)*( (erf(sqrt(2)*(a + b)/2) + 1)*exp(-a**2/2 + a*b - b**2/2))/4) e = integrate(exp(-(x - a)**2)*exp(-(x - b)**2)*exp(c*x), (x, 0, oo), meijerg=True) assert simplify(e) == ( sqrt(2)*sqrt(pi)*(erf(sqrt(2)*(2*a + 2*b + c)/4) + 1)*exp(-a**2 - b**2 + (2*a + 2*b + c)**2/8)/4) assert simplify(integrate(exp(-(x - a - b - c)**2), (x, 0, oo), meijerg=True)) == \ sqrt(pi)/2*(1 + erf(a + b + c)) assert simplify(refine(integrate(exp(-(x + a + b + c)**2), (x, 0, oo), meijerg=True))) == \ sqrt(pi)/2*(1 - erf(a + b + c))
def test_make_integral_01(): integral, params = _make_integral_01() intgr = integral.doit() u0, k, l, t = params # eq: k == l, neq: k != l ref_eq = k*u0*t ref_neq = -k*u0/(k-l)*(exp(t*(l-k)) - 1) refined_eq = integral.subs({l: k}).doit() assert (refined_eq - ref_eq).simplify() == 0 eq_assumption = sympy.Q.is_true(sympy.Eq(l, k)) refined_neq = sympy.refine(intgr, ~eq_assumption).simplify() print(refined_neq) print(ref_neq) assert (refined_neq - ref_neq).simplify() == 0
def test_func_args(): class MyClass(Expr): # A class with nontrivial .func def __init__(self, *args): self.my_member = "" @property def func(self): def my_func(*args): obj = MyClass(*args) obj.my_member = self.my_member return obj return my_func x = MyClass() x.my_member = "A very important value" assert x.my_member == refine(x).my_member
def test_piecewise_fold_piecewise_in_cond(): p1 = Piecewise((cos(x), x < 0), (0, True)) p2 = Piecewise((0, Eq(p1, 0)), (p1 / Abs(p1), True)) p3 = piecewise_fold(p2) assert(p2.subs(x, -pi/2) == 0.0) assert(p2.subs(x, 1) == 0.0) assert(refine(p2.subs(x, -pi/4)) == 1.0) p4 = Piecewise((0, Eq(p1, 0)), (1,True)) assert(piecewise_fold(p4) == Piecewise( (0, Or(And(Eq(cos(x), 0), x < 0), Not(x < 0))), (1, True))) r1 = 1 < Piecewise((1, x < 1), (3, True)) assert(piecewise_fold(r1) == Not(x < 1)) p5 = Piecewise((1, x < 0), (3, True)) p6 = Piecewise((1, x < 1), (3, True)) p7 = piecewise_fold(Piecewise((1, p5 < p6), (0, True))) assert(Piecewise((1, And(Not(x < 1), x < 0)), (0, True)))
def test_pow(): x, y, z = symbols('x y z') assert refine((-1)**x, Assume(x, Q.even)) == 1 assert refine((-1)**x, Assume(x, Q.odd)) == -1 assert refine((-2)**x, Assume(x, Q.even)) == 2**x # nested powers assert refine(sqrt(x**2)) != Abs(x) assert refine(sqrt(x**2), Assume(x, Q.complex)) != Abs(x) assert refine(sqrt(x**2), Assume(x, Q.real)) == Abs(x) assert refine(sqrt(x**2), Assume(x, Q.positive)) == x assert refine((x**3)**(S(1)/3)) != x assert refine((x**3)**(S(1)/3), Assume(x, Q.real)) != x assert refine((x**3)**(S(1)/3), Assume(x, Q.positive)) == x assert refine(sqrt(1/x), Assume(x, Q.real)) != 1/sqrt(x) assert refine(sqrt(1/x), Assume(x, Q.positive)) == 1/sqrt(x) # powers of (-1) assert refine((-1)**(x+y), Assume(x, Q.even)) == (-1)**y assert refine((-1)**(x+y+z), Assume(x, Q.odd)&Assume(z, Q.odd))==(-1)**y assert refine((-1)**(x+y+1), Assume(x, Q.odd))==(-1)**y assert refine((-1)**(x+y+2), Assume(x, Q.odd))==(-1)**(y+1) assert refine((-1)**(x+3)) == (-1)**(x+1)
def test_exp(): assert refine(exp(pi * I * 2 * x), Q.integer(x)) == 1 assert refine(exp(pi * I * 2 * (x + Rational(1, 2))), Q.integer(x)) == -1 assert refine(exp(pi * I * 2 * (x + Rational(1, 4))), Q.integer(x)) == I assert refine(exp(pi * I * 2 * (x + Rational(3, 4))), Q.integer(x)) == -I
def test_exp_infinity(): y = Symbol('y') assert exp(I*y) != nan assert refine(exp(I*oo)) == nan assert refine(exp(-I*oo)) == nan assert exp(y*I*oo) != nan
def test_pow(): assert refine((-1) ** x, Q.even(x)) == 1 assert refine((-1) ** x, Q.odd(x)) == -1 assert refine((-2) ** x, Q.even(x)) == 2 ** x # nested powers assert refine(sqrt(x ** 2)) != Abs(x) assert refine(sqrt(x ** 2), Q.complex(x)) != Abs(x) assert refine(sqrt(x ** 2), Q.real(x)) == Abs(x) assert refine(sqrt(x ** 2), Q.positive(x)) == x assert refine((x ** 3) ** (S(1) / 3)) != x assert refine((x ** 3) ** (S(1) / 3), Q.real(x)) != x assert refine((x ** 3) ** (S(1) / 3), Q.positive(x)) == x assert refine(sqrt(1 / x), Q.real(x)) != 1 / sqrt(x) assert refine(sqrt(1 / x), Q.positive(x)) == 1 / sqrt(x) # powers of (-1) assert refine((-1) ** (x + y), Q.even(x)) == (-1) ** y assert refine((-1) ** (x + y + z), Q.odd(x) & Q.odd(z)) == (-1) ** y assert refine((-1) ** (x + y + 1), Q.odd(x)) == (-1) ** y assert refine((-1) ** (x + y + 2), Q.odd(x)) == (-1) ** (y + 1) assert refine((-1) ** (x + 3)) == (-1) ** (x + 1) assert refine((-1) ** ((-1) ** x / 2 - S.Half), Q.integer(x)) == (-1) ** x assert refine((-1) ** ((-1) ** x / 2 + S.Half), Q.integer(x)) == (-1) ** (x + 1) assert refine((-1) ** ((-1) ** x / 2 + 5 * S.Half), Q.integer(x)) == (-1) ** (x + 1) assert refine((-1) ** ((-1) ** x / 2 - 7 * S.Half), Q.integer(x)) == (-1) ** (x + 1) assert refine((-1) ** ((-1) ** x / 2 - 9 * S.Half), Q.integer(x)) == (-1) ** x # powers of Abs assert refine(Abs(x) ** 2, Q.real(x)) == x ** 2 assert refine(Abs(x) ** 3, Q.real(x)) == Abs(x) ** 3 assert refine(Abs(x) ** 2) == Abs(x) ** 2
def test_pow(): x = Symbol('x', even=True) assert refine((-1)**x) == 1 x = Symbol('x', odd=True) assert refine((-1)**x) == -1 x = Symbol('x', even=True) assert refine((-2)**x) == 2**x # nested powers x = Symbol('x') assert refine(sqrt(x**2)) != Abs(x) x = Symbol('x', complex=True) assert refine(sqrt(x**2)) != Abs(x) x = Symbol('x', real=True) assert refine(sqrt(x**2)) == Abs(x) p = Symbol('p', positive=True) assert refine(sqrt(p**2)) == p x = Symbol('x') assert refine((x**3)**(S(1)/3)) != x x = Symbol('x', real=True) assert refine((x**3)**(S(1)/3)) != x x = Symbol('x', positive=True) assert refine((x**3)**(S(1)/3)) == x x = Symbol('x', real=True) assert refine(sqrt(1/x)) != 1/sqrt(x) x = Symbol('x', positive=True) assert refine(sqrt(1/x)) == 1/sqrt(x) # powers of (-1) x = Symbol('x', even=True) assert refine((-1)**(x + y), Q.even(x)) == (-1)**y x = Symbol('x', odd=True) z = Symbol('z', odd=True) assert refine((-1)**(x + y + z), Q.odd(x) & Q.odd(z)) == (-1)**y assert refine((-1)**(x + y + 1), Q.odd(x)) == (-1)**y assert refine((-1)**(x + y + 2), Q.odd(x)) == (-1)**(y + 1) x = Symbol('x') assert refine((-1)**(x + 3)) == (-1)**(x + 1) x = Symbol('x', integer=True) assert refine((-1)**((-1)**x/2 - S.Half), Q.integer(x)) == (-1)**x assert refine((-1)**((-1)**x/2 + S.Half), Q.integer(x)) == (-1)**(x + 1) assert refine((-1)**((-1)**x/2 + 5*S.Half), Q.integer(x)) == (-1)**(x + 1) assert refine((-1)**((-1)**x/2 - 7*S.Half), Q.integer(x)) == (-1)**(x + 1) assert refine((-1)**((-1)**x/2 - 9*S.Half), Q.integer(x)) == (-1)**x # powers of Abs x = Symbol('x', real=True) assert refine(Abs(x)**2, Q.real(x)) == x**2 assert refine(Abs(x)**3, Q.real(x)) == Abs(x)**3 x = Symbol('x') assert refine(Abs(x)**2) == Abs(x)**2
def test_Piecewise(): assert refine(Piecewise((1, x < 0), (3, True)), Q.is_true(x < 0)) == 1 assert refine(Piecewise((1, x < 0), (3, True)), ~Q.is_true(x < 0)) == 3 assert refine(Piecewise((1, x < 0), (3, True)), Q.is_true(y < 0)) == \ Piecewise((1, x < 0), (3, True)) assert refine(Piecewise((1, x > 0), (3, True)), Q.is_true(x > 0)) == 1 assert refine(Piecewise((1, x > 0), (3, True)), ~Q.is_true(x > 0)) == 3 assert refine(Piecewise((1, x > 0), (3, True)), Q.is_true(y > 0)) == \ Piecewise((1, x > 0), (3, True)) assert refine(Piecewise((1, x <= 0), (3, True)), Q.is_true(x <= 0)) == 1 assert refine(Piecewise((1, x <= 0), (3, True)), ~Q.is_true(x <= 0)) == 3 assert refine(Piecewise((1, x <= 0), (3, True)), Q.is_true(y <= 0)) == \ Piecewise((1, x <= 0), (3, True)) assert refine(Piecewise((1, x >= 0), (3, True)), Q.is_true(x >= 0)) == 1 assert refine(Piecewise((1, x >= 0), (3, True)), ~Q.is_true(x >= 0)) == 3 assert refine(Piecewise((1, x >= 0), (3, True)), Q.is_true(y >= 0)) == \ Piecewise((1, x >= 0), (3, True)) assert refine(Piecewise((1, Eq(x, 0)), (3, True)), Q.is_true(Eq(x, 0)))\ == 1 assert refine(Piecewise((1, Eq(x, 0)), (3, True)), ~Q.is_true(Eq(x, 0)))\ == 3 assert refine(Piecewise((1, Eq(x, 0)), (3, True)), Q.is_true(Eq(y, 0)))\ == Piecewise((1, Eq(x, 0)), (3, True)) assert refine(Piecewise((1, Ne(x, 0)), (3, True)), Q.is_true(Ne(x, 0)))\ == 1 assert refine(Piecewise((1, Ne(x, 0)), (3, True)), ~Q.is_true(Ne(x, 0)))\ == 3 assert refine(Piecewise((1, Ne(x, 0)), (3, True)), Q.is_true(Ne(y, 0)))\ == Piecewise((1, Ne(x, 0)), (3, True))
def test_Relational(): assert not refine(x < 0, ~Q.is_true(x < 0)) assert refine(x < 0, Q.is_true(x < 0)) assert refine(x < 0, Q.is_true(y < 0)) == (x < 0) assert not refine(x <= 0, ~Q.is_true(x <= 0)) assert refine(x <= 0, Q.is_true(x <= 0)) assert refine(x <= 0, Q.is_true(y <= 0)) == (x <= 0) assert not refine(x > 0, ~Q.is_true(x > 0)) assert refine(x > 0, Q.is_true(x > 0)) assert refine(x > 0, Q.is_true(y > 0)) == (x > 0) assert not refine(x >= 0, ~Q.is_true(x >= 0)) assert refine(x >= 0, Q.is_true(x >= 0)) assert refine(x >= 0, Q.is_true(y >= 0)) == (x >= 0) assert not refine(Eq(x, 0), ~Q.is_true(Eq(x, 0))) assert refine(Eq(x, 0), Q.is_true(Eq(x, 0))) assert refine(Eq(x, 0), Q.is_true(Eq(y, 0))) == Eq(x, 0) assert not refine(Ne(x, 0), ~Q.is_true(Ne(x, 0))) assert refine(Ne(x, 0), Q.is_true(Ne(x, 0))) assert refine(Ne(x, 0), Q.is_true(Ne(y, 0))) == (Ne(x, 0))
def test_exp(): x = Symbol('x', integer=True) assert refine(exp(pi*I*2*x)) == 1 assert refine(exp(pi*I*2*(x + Rational(1, 2)))) == -1 assert refine(exp(pi*I*2*(x + Rational(1, 4)))) == I assert refine(exp(pi*I*2*(x + Rational(3, 4)))) == -I
def test_refine(): assert refine(C.T, Q.symmetric(C)) == C
def test_exp(): x = symbols('x') assert refine(exp(pi*I*2*x), Assume(x, Q.integer)) == 1 assert refine(exp(pi*I*2*(x+Rational(1,2))), Assume(x, Q.integer)) == -1 assert refine(exp(pi*I*2*(x+Rational(1,4))), Assume(x, Q.integer)) == I assert refine(exp(pi*I*2*(x+Rational(3,4))), Assume(x, Q.integer)) == -I
def test_transpose1x1(): m = MatrixSymbol('m', 1, 1) assert m == refine(m.T) assert m == refine(m.T.T)
def test_pow(): x, y = symbols('x y') assert refine((-1)**x, Assume(x, Q.even)) == 1 assert refine((-1)**x, Assume(x, Q.odd)) == -1 assert refine((-2)**x, Assume(x, Q.even)) == 2**x # nested powers assert refine(sqrt(x**2)) != abs(x) assert refine(sqrt(x**2), Assume(x, Q.complex)) != abs(x) assert refine(sqrt(x**2), Assume(x, Q.real)) == abs(x) assert refine(sqrt(x**2), Assume(x, Q.positive)) == x assert refine((x**3)**(S(1)/3)) != x assert refine((x**3)**(S(1)/3), Assume(x, Q.real)) != x assert refine((x**3)**(S(1)/3), Assume(x, Q.positive)) == x assert refine(sqrt(1/x), Assume(x, Q.real)) != 1/sqrt(x) assert refine(sqrt(1/x), Assume(x, Q.positive)) == 1/sqrt(x)
def test_refine(): assert refine(C*C.T*D, Q.orthogonal(C)).doit() == D kC = k*C assert refine(kC*C.T, Q.orthogonal(C)).doit() == k*Identity(n) assert refine(kC* kC.T, Q.orthogonal(C)).doit() == (k**2)*Identity(n)