def test_function_series3(): """ Test our easy "tanh" function. This test tests two things: * that the Function interface works as expected and it's easy to use * that the general algorithm for the series expansion works even when the derivative is defined recursively in terms of the original function, since tanh(x).diff(x) == 1-tanh(x)**2 """ class mytanh(Function): nargs = 1 def fdiff(self, argindex = 1): return 1-mytanh(self.args[0])**2 @classmethod def canonize(cls, arg): arg = sympify(arg) if arg == 0: return sympify(0) e = tanh(x) f = mytanh(x) assert tanh(x).series(x, 0, 6) == mytanh(x).series(x, 0, 6)
def test_tan_rewrite(): neg_exp, pos_exp = exp(-x*I), exp(x*I) assert tan(x).rewrite(exp) == I*(neg_exp - pos_exp)/(neg_exp + pos_exp) assert tan(x).rewrite(sin) == 2*sin(x)**2/sin(2*x) assert tan(x).rewrite(cos) == -cos(x + S.Pi/2)/cos(x) assert tan(x).rewrite(cot) == 1/cot(x) assert tan(sinh(x)).rewrite( exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, sinh(3)).n() assert tan(cosh(x)).rewrite( exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cosh(3)).n() assert tan(tanh(x)).rewrite( exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, tanh(3)).n() assert tan(coth(x)).rewrite( exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, coth(3)).n() assert tan(sin(x)).rewrite( exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, sin(3)).n() assert tan(cos(x)).rewrite( exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cos(3)).n() assert tan(tan(x)).rewrite( exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, tan(3)).n() assert tan(cot(x)).rewrite( exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cot(3)).n() assert tan(log(x)).rewrite(Pow) == I*(x**-I - x**I)/(x**-I + x**I) assert 0 == (cos(pi/15)*tan(pi/15) - sin(pi/15)).rewrite(pow) assert tan(pi/19).rewrite(pow) == tan(pi/19) assert tan(8*pi/19).rewrite(sqrt) == tan(8*pi/19)
def test_simplifications(): x = Symbol('x') assert sinh(asinh(x)) == x assert sinh(acosh(x)) == sqrt(x - 1) * sqrt(x + 1) assert sinh(atanh(x)) == x/sqrt(1 - x**2) assert sinh(acoth(x)) == 1/(sqrt(x - 1) * sqrt(x + 1)) assert cosh(asinh(x)) == sqrt(1 + x**2) assert cosh(acosh(x)) == x assert cosh(atanh(x)) == 1/sqrt(1 - x**2) assert cosh(acoth(x)) == x/(sqrt(x - 1) * sqrt(x + 1)) assert tanh(asinh(x)) == x/sqrt(1 + x**2) assert tanh(acosh(x)) == sqrt(x - 1) * sqrt(x + 1) / x assert tanh(atanh(x)) == x assert tanh(acoth(x)) == 1/x assert coth(asinh(x)) == sqrt(1 + x**2)/x assert coth(acosh(x)) == x/(sqrt(x - 1) * sqrt(x + 1)) assert coth(atanh(x)) == 1/x assert coth(acoth(x)) == x assert csch(asinh(x)) == 1/x assert csch(acosh(x)) == 1/(sqrt(x - 1) * sqrt(x + 1)) assert csch(atanh(x)) == sqrt(1 - x**2)/x assert csch(acoth(x)) == sqrt(x - 1) * sqrt(x + 1) assert sech(asinh(x)) == 1/sqrt(1 + x**2) assert sech(acosh(x)) == 1/x assert sech(atanh(x)) == sqrt(1 - x**2) assert sech(acoth(x)) == sqrt(x - 1) * sqrt(x + 1)/x
def test_exp_rewrite(): assert exp(x).rewrite(sin) == sinh(x) + cosh(x) assert exp(x*I).rewrite(cos) == cos(x) + I*sin(x) assert exp(1).rewrite(cos) == sinh(1) + cosh(1) assert exp(1).rewrite(sin) == sinh(1) + cosh(1) assert exp(1).rewrite(sin) == sinh(1) + cosh(1) assert exp(x).rewrite(tanh) == (1 + tanh(x/2))/(1 - tanh(x/2))
def test_evalc(): x = Symbol("x", real=True) y = Symbol("y", real=True) z = Symbol("z") assert ((x+I*y)**2).expand(complex=True) == x**2+2*I*x*y - y**2 assert expand_complex(z**(2*I)) == I*im(z**(2*I)) + re(z**(2*I)) assert exp(I*x) != cos(x)+I*sin(x) assert exp(I*x).expand(complex=True) == cos(x)+I*sin(x) assert exp(I*x+y).expand(complex=True) == exp(y)*cos(x)+I*sin(x)*exp(y) assert sin(I*x).expand(complex=True) == I * sinh(x) assert sin(x+I*y).expand(complex=True) == sin(x)*cosh(y) + \ I * sinh(y) * cos(x) assert cos(I*x).expand(complex=True) == cosh(x) assert cos(x+I*y).expand(complex=True) == cos(x)*cosh(y) - \ I * sinh(y) * sin(x) assert tan(I*x).expand(complex=True) == tanh(x) * I assert tan(x+I*y).expand(complex=True) == \ ((sin(x)*cos(x) + I*cosh(y)*sinh(y)) / (cos(x)**2 + sinh(y)**2)).expand() assert sinh(I*x).expand(complex=True) == I * sin(x) assert sinh(x+I*y).expand(complex=True) == sinh(x)*cos(y) + \ I * sin(y) * cosh(x) assert cosh(I*x).expand(complex=True) == cos(x) assert cosh(x+I*y).expand(complex=True) == cosh(x)*cos(y) + \ I * sin(y) * sinh(x) assert tanh(I*x).expand(complex=True) == tan(x) * I assert tanh(x+I*y).expand(complex=True) == \ ((sinh(x)*cosh(x) + I*cos(y)*sin(y)) / (sinh(x)**2 + cos(y)**2)).expand()
def test_tanh_rewrite(): x = Symbol('x') assert tanh(x).rewrite(exp) == (exp(x) - exp(-x))/(exp(x) + exp(-x)) \ == tanh(x).rewrite('tractable') assert tanh(x).rewrite(sinh) == I*sinh(x)/sinh(I*pi/2 - x) assert tanh(x).rewrite(cosh) == I*cosh(I*pi/2 - x)/cosh(x) assert tanh(x).rewrite(coth) == 1/coth(x)
def test_tan(): x, y = symbols('x,y') r = Symbol('r', real=True) k = Symbol('k', integer=True) assert tan(nan) == nan assert tan(oo*I) == I assert tan(-oo*I) == -I assert tan(0) == 0 assert tan(atan(x)) == x assert tan(asin(x)) == x / sqrt(1 - x**2) assert tan(acos(x)) == sqrt(1 - x**2) / x assert tan(acot(x)) == 1 / x assert tan(atan2(y, x)) == y/x assert tan(pi*I) == tanh(pi)*I assert tan(-pi*I) == -tanh(pi)*I assert tan(-2*I) == -tanh(2)*I assert tan(pi) == 0 assert tan(-pi) == 0 assert tan(2*pi) == 0 assert tan(-2*pi) == 0 assert tan(-3*10**73*pi) == 0 assert tan(pi/2) == zoo assert tan(3*pi/2) == zoo assert tan(pi/3) == sqrt(3) assert tan(-2*pi/3) == sqrt(3) assert tan(pi/4) == S.One assert tan(-pi/4) == -S.One assert tan(17*pi/4) == S.One assert tan(-3*pi/4) == S.One assert tan(pi/6) == 1/sqrt(3) assert tan(-pi/6) == -1/sqrt(3) assert tan(7*pi/6) == 1/sqrt(3) assert tan(-5*pi/6) == 1/sqrt(3) assert tan(x*I) == tanh(x)*I assert tan(k*pi) == 0 assert tan(17*k*pi) == 0 assert tan(k*pi*I) == tanh(k*pi)*I assert tan(r).is_real is True assert tan(10*pi/7) == tan(3*pi/7) assert tan(11*pi/7) == -tan(3*pi/7) assert tan(-11*pi/7) == tan(3*pi/7)
def test_tan(): assert tan(nan) == nan assert tan.nargs == FiniteSet(1) assert tan(oo*I) == I assert tan(-oo*I) == -I assert tan(0) == 0 assert tan(atan(x)) == x assert tan(asin(x)) == x / sqrt(1 - x**2) assert tan(acos(x)) == sqrt(1 - x**2) / x assert tan(acot(x)) == 1 / x assert tan(atan2(y, x)) == y/x assert tan(pi*I) == tanh(pi)*I assert tan(-pi*I) == -tanh(pi)*I assert tan(-2*I) == -tanh(2)*I assert tan(pi) == 0 assert tan(-pi) == 0 assert tan(2*pi) == 0 assert tan(-2*pi) == 0 assert tan(-3*10**73*pi) == 0 assert tan(pi/2) == zoo assert tan(3*pi/2) == zoo assert tan(pi/3) == sqrt(3) assert tan(-2*pi/3) == sqrt(3) assert tan(pi/4) == S.One assert tan(-pi/4) == -S.One assert tan(17*pi/4) == S.One assert tan(-3*pi/4) == S.One assert tan(pi/6) == 1/sqrt(3) assert tan(-pi/6) == -1/sqrt(3) assert tan(7*pi/6) == 1/sqrt(3) assert tan(-5*pi/6) == 1/sqrt(3) assert tan(x*I) == tanh(x)*I assert tan(k*pi) == 0 assert tan(17*k*pi) == 0 assert tan(k*pi*I) == tanh(k*pi)*I assert tan(r).is_real is True assert tan(0, evaluate=False).is_algebraic assert tan(a).is_algebraic is None assert tan(na).is_algebraic is False assert tan(10*pi/7) == tan(3*pi/7) assert tan(11*pi/7) == -tan(3*pi/7) assert tan(-11*pi/7) == tan(3*pi/7)
def test_derivs(): x = Symbol('x') assert coth(x).diff(x) == -sinh(x)**(-2) assert sinh(x).diff(x) == cosh(x) assert cosh(x).diff(x) == sinh(x) assert tanh(x).diff(x) == -tanh(x)**2 + 1 assert acoth(x).diff(x) == 1/(-x**2 + 1) assert asinh(x).diff(x) == 1/sqrt(x**2 + 1) assert acosh(x).diff(x) == 1/sqrt(x**2 - 1) assert atanh(x).diff(x) == 1/(-x**2 + 1)
def splice(a, b, x0, width, x, dx): from sympy import tanh ax = a(x) bx = b(x) dax = symdiff(a)(x) dbx = symdiff(b)(x) f = ax + (bx-ax) * (1+tanh((x-x0)/width)) / 2 df = (dax + (dbx-dax) * (1+tanh((x-x0)/width)) / 2 + (bx - ax) * (1-tanh((x-x0)/width)**2) / (2*width)) * dx return f, df
def test_trigsimp1a(): assert trigsimp(sin(2)**2*cos(3)*exp(2)/cos(2)**2) == tan(2)**2*cos(3)*exp(2) assert trigsimp(tan(2)**2*cos(3)*exp(2)*cos(2)**2) == sin(2)**2*cos(3)*exp(2) assert trigsimp(cot(2)*cos(3)*exp(2)*sin(2)) == cos(3)*exp(2)*cos(2) assert trigsimp(tan(2)*cos(3)*exp(2)/sin(2)) == cos(3)*exp(2)/cos(2) assert trigsimp(cot(2)*cos(3)*exp(2)/cos(2)) == cos(3)*exp(2)/sin(2) assert trigsimp(cot(2)*cos(3)*exp(2)*tan(2)) == cos(3)*exp(2) assert trigsimp(sinh(2)*cos(3)*exp(2)/cosh(2)) == tanh(2)*cos(3)*exp(2) assert trigsimp(tanh(2)*cos(3)*exp(2)*cosh(2)) == sinh(2)*cos(3)*exp(2) assert trigsimp(coth(2)*cos(3)*exp(2)*sinh(2)) == cosh(2)*cos(3)*exp(2) assert trigsimp(tanh(2)*cos(3)*exp(2)/sinh(2)) == cos(3)*exp(2)/cosh(2) assert trigsimp(coth(2)*cos(3)*exp(2)/cosh(2)) == cos(3)*exp(2)/sinh(2) assert trigsimp(coth(2)*cos(3)*exp(2)*tanh(2)) == cos(3)*exp(2)
def test_sin_rewrite(): assert sin(x).rewrite(exp) == -I * (exp(I * x) - exp(-I * x)) / 2 assert sin(x).rewrite(tan) == 2 * tan(x / 2) / (1 + tan(x / 2) ** 2) assert sin(x).rewrite(cot) == 2 * cot(x / 2) / (1 + cot(x / 2) ** 2) assert sin(sinh(x)).rewrite(exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, sinh(3)).n() assert sin(cosh(x)).rewrite(exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, cosh(3)).n() assert sin(tanh(x)).rewrite(exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, tanh(3)).n() assert sin(coth(x)).rewrite(exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, coth(3)).n() assert sin(sin(x)).rewrite(exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, sin(3)).n() assert sin(cos(x)).rewrite(exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, cos(3)).n() assert sin(tan(x)).rewrite(exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, tan(3)).n() assert sin(cot(x)).rewrite(exp).subs(x, 3).n() == sin(x).rewrite(exp).subs(x, cot(3)).n() assert sin(log(x)).rewrite(Pow) == I * x ** -I / 2 - I * x ** I / 2
def test_cos_rewrite(): assert cos(x).rewrite(exp) == exp(I * x) / 2 + exp(-I * x) / 2 assert cos(x).rewrite(tan) == (1 - tan(x / 2) ** 2) / (1 + tan(x / 2) ** 2) assert cos(x).rewrite(cot) == -(1 - cot(x / 2) ** 2) / (1 + cot(x / 2) ** 2) assert cos(sinh(x)).rewrite(exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, sinh(3)).n() assert cos(cosh(x)).rewrite(exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, cosh(3)).n() assert cos(tanh(x)).rewrite(exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, tanh(3)).n() assert cos(coth(x)).rewrite(exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, coth(3)).n() assert cos(sin(x)).rewrite(exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, sin(3)).n() assert cos(cos(x)).rewrite(exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, cos(3)).n() assert cos(tan(x)).rewrite(exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, tan(3)).n() assert cos(cot(x)).rewrite(exp).subs(x, 3).n() == cos(x).rewrite(exp).subs(x, cot(3)).n() assert cos(log(x)).rewrite(Pow) == x ** I / 2 + x ** -I / 2
def test_simplifications(): x = Symbol("x") assert sinh(asinh(x)) == x assert sinh(acosh(x)) == sqrt(x - 1) * sqrt(x + 1) assert sinh(atanh(x)) == x / sqrt(1 - x ** 2) assert cosh(asinh(x)) == sqrt(1 + x ** 2) assert cosh(acosh(x)) == x assert cosh(atanh(x)) == 1 / sqrt(1 - x ** 2) assert tanh(asinh(x)) == x / sqrt(1 + x ** 2) assert tanh(acosh(x)) == sqrt(x - 1) * sqrt(x + 1) / x assert tanh(atanh(x)) == x
def test_derivs(): x = Symbol('x') assert coth(x).diff(x) == -sinh(x)**(-2) assert sinh(x).diff(x) == cosh(x) assert cosh(x).diff(x) == sinh(x) assert tanh(x).diff(x) == -tanh(x)**2 + 1 assert csch(x).diff(x) == -coth(x)*csch(x) assert sech(x).diff(x) == -tanh(x)*sech(x) assert acoth(x).diff(x) == 1/(-x**2 + 1) assert asinh(x).diff(x) == 1/sqrt(x**2 + 1) assert acosh(x).diff(x) == 1/sqrt(x**2 - 1) assert atanh(x).diff(x) == 1/(-x**2 + 1) assert asech(x).diff(x) == -1/(x*sqrt(1 - x**2)) assert acsch(x).diff(x) == -1/(x**2*sqrt(1 + x**(-2)))
def test_cot_rewrite(): x = Symbol('x') neg_exp, pos_exp = exp(-x*I), exp(x*I) assert cot(x).rewrite(exp) == I*(pos_exp+neg_exp)/(pos_exp-neg_exp) assert cot(x).rewrite(sin) == 2*sin(2*x)/sin(x)**2 assert cot(x).rewrite(cos) == -cos(x)/cos(x + S.Pi/2) assert cot(x).rewrite(tan) == 1/tan(x) assert cot(sinh(x)).rewrite(exp).subs(x, 3).n() == cot(x).rewrite(exp).subs(x, sinh(3)).n() assert cot(cosh(x)).rewrite(exp).subs(x, 3).n() == cot(x).rewrite(exp).subs(x, cosh(3)).n() assert cot(tanh(x)).rewrite(exp).subs(x, 3).n() == cot(x).rewrite(exp).subs(x, tanh(3)).n() assert cot(coth(x)).rewrite(exp).subs(x, 3).n() == cot(x).rewrite(exp).subs(x, coth(3)).n() assert cot(sin(x)).rewrite(exp).subs(x, 3).n() == cot(x).rewrite(exp).subs(x, sin(3)).n() assert cot(tan(x)).rewrite(exp).subs(x, 3).n() == cot(x).rewrite(exp).subs(x, tan(3)).n() assert cot(log(x)).rewrite(Pow) == -I*(x**-I + x**I)/(x**-I - x**I)
def test_sign_assumptions(): p = Symbol('p', positive=True) n = Symbol('n', negative=True) assert sinh(n).is_negative is True assert sinh(p).is_positive is True assert cosh(n).is_positive is True assert cosh(p).is_positive is True assert tanh(n).is_negative is True assert tanh(p).is_positive is True assert csch(n).is_negative is True assert csch(p).is_positive is True assert sech(n).is_positive is True assert sech(p).is_positive is True assert coth(n).is_negative is True assert coth(p).is_positive is True
def test_intrinsic_math1_codegen(): # not included: log10 from sympy import acos, asin, atan, ceiling, cos, cosh, floor, log, ln, \ sin, sinh, sqrt, tan, tanh, N x = symbols('x') name_expr = [ ("test_fabs", abs(x)), ("test_acos", acos(x)), ("test_asin", asin(x)), ("test_atan", atan(x)), ("test_cos", cos(x)), ("test_cosh", cosh(x)), ("test_log", log(x)), ("test_ln", ln(x)), ("test_sin", sin(x)), ("test_sinh", sinh(x)), ("test_sqrt", sqrt(x)), ("test_tan", tan(x)), ("test_tanh", tanh(x)), ] numerical_tests = [] for name, expr in name_expr: for xval in 0.2, 0.5, 0.8: expected = N(expr.subs(x, xval)) numerical_tests.append((name, (xval,), expected, 1e-14)) for lang, commands in valid_lang_commands: if lang == "C": name_expr_C = [("test_floor", floor(x)), ("test_ceil", ceiling(x))] else: name_expr_C = [] run_test("intrinsic_math1", name_expr + name_expr_C, numerical_tests, lang, commands)
def test_tan_rewrite(): x = Symbol('x') neg_exp, pos_exp = exp(-x*I), exp(x*I) assert tan(x).rewrite(exp) == I*(neg_exp-pos_exp)/(neg_exp+pos_exp) assert tan(x).rewrite(sin) == 2*sin(x)**2/sin(2*x) assert tan(x).rewrite(cos) == -cos(x + S.Pi/2)/cos(x) assert tan(x).rewrite(cot) == 1/cot(x) assert tan(sinh(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, sinh(3)).n() assert tan(cosh(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cosh(3)).n() assert tan(tanh(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, tanh(3)).n() assert tan(coth(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, coth(3)).n() assert tan(sin(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, sin(3)).n() assert tan(cos(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cos(3)).n() assert tan(tan(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, tan(3)).n() assert tan(cot(x)).rewrite(exp).subs(x, 3).n() == tan(x).rewrite(exp).subs(x, cot(3)).n() assert tan(log(x)).rewrite(Pow) == I*(x**-I - x**I)/(x**-I + x**I)
def test_hyper_as_trig(): from sympy.simplify.fu import _osborne, _osbornei eq = sinh(x)**2 + cosh(x)**2 t, f = hyper_as_trig(eq) assert f(fu(t)) == cosh(2*x) assert _osborne(cosh(x)) == cos(x) assert _osborne(sinh(x)) == I*sin(x) assert _osborne(tanh(x)) == I*tan(x) assert _osborne(coth(x)) == cot(x)/I assert _osbornei(cos(x)) == cosh(x) assert _osbornei(sin(x)) == sinh(x)/I assert _osbornei(tan(x)) == tanh(x)/I assert _osbornei(cot(x)) == coth(x)*I assert _osbornei(sec(x)) == 1/cosh(x) assert _osbornei(csc(x)) == I/sinh(x)
def test_heurisch_trigonometric(): assert heurisch(sin(x), x) == -cos(x) assert heurisch(pi*sin(x) + 1, x) == x - pi*cos(x) assert heurisch(cos(x), x) == sin(x) assert heurisch(tan(x), x) in [ log(1 + tan(x)**2)/2, log(tan(x) + I) + I*x, log(tan(x) - I) - I*x, ] assert heurisch(sin(x)*sin(y), x) == -cos(x)*sin(y) assert heurisch(sin(x)*sin(y), y) == -cos(y)*sin(x) # gives sin(x) in answer when run via setup.py and cos(x) when run via py.test assert heurisch(sin(x)*cos(x), x) in [sin(x)**2 / 2, -cos(x)**2 / 2] assert heurisch(cos(x)/sin(x), x) == log(sin(x)) assert heurisch(x*sin(7*x), x) == sin(7*x) / 49 - x*cos(7*x) / 7 assert heurisch(1/pi/4 * x**2*cos(x), x) == 1/pi/4*(x**2*sin(x) - 2*sin(x) + 2*x*cos(x)) assert heurisch(acos(x/4) * asin(x/4), x) == 2*x - (sqrt(16 - x**2))*asin(x/4) \ + (sqrt(16 - x**2))*acos(x/4) + x*asin(x/4)*acos(x/4) assert heurisch(sin(x)/(cos(x)**2+1), x) == -atan(cos(x)) #fixes issue 13723 assert heurisch(1/(cos(x)+2), x) == 2*sqrt(3)*atan(sqrt(3)*tan(x/2)/3)/3 assert heurisch(2*sin(x)*cos(x)/(sin(x)**4 + 1), x) == atan(sqrt(2)*sin(x) - 1) - atan(sqrt(2)*sin(x) + 1) assert heurisch(1/cosh(x), x) == 2*atan(tanh(x/2))
def test_exp_rewrite(): from sympy.concrete.summations import Sum assert exp(x).rewrite(sin) == sinh(x) + cosh(x) assert exp(x*I).rewrite(cos) == cos(x) + I*sin(x) assert exp(1).rewrite(cos) == sinh(1) + cosh(1) assert exp(1).rewrite(sin) == sinh(1) + cosh(1) assert exp(1).rewrite(sin) == sinh(1) + cosh(1) assert exp(x).rewrite(tanh) == (1 + tanh(x/2))/(1 - tanh(x/2)) assert exp(pi*I/4).rewrite(sqrt) == sqrt(2)/2 + sqrt(2)*I/2 assert exp(pi*I/3).rewrite(sqrt) == 1/2 + sqrt(3)*I/2 n = Symbol('n', integer=True) assert Sum((exp(pi*I/2)/2)**n, (n, 0, oo)).rewrite(sqrt).doit() == 4/5 + 2*I/5 assert Sum((exp(pi*I/4)/2)**n, (n, 0, oo)).rewrite(sqrt).doit() == 1/(1 - sqrt(2)*(1 + I)/4) assert Sum((exp(pi*I/3)/2)**n, (n, 0, oo)).rewrite(sqrt).doit() == 1/(3/4 - sqrt(3)*I/4)
def test_ansi_math1_codegen(): # not included: log10 from sympy import acos, asin, atan, ceiling, cos, cosh, floor, log, ln, \ sin, sinh, sqrt, tan, tanh, N x = symbols('x') name_expr = [ ("test_fabs", abs(x)), ("test_acos", acos(x)), ("test_asin", asin(x)), ("test_atan", atan(x)), ("test_ceil", ceiling(x)), ("test_cos", cos(x)), ("test_cosh", cosh(x)), ("test_floor", floor(x)), ("test_log", log(x)), ("test_ln", ln(x)), ("test_sin", sin(x)), ("test_sinh", sinh(x)), ("test_sqrt", sqrt(x)), ("test_tan", tan(x)), ("test_tanh", tanh(x)), ] numerical_tests = [] for name, expr in name_expr: for xval in 0.2, 0.5, 0.8: expected = N(expr.subs(x, xval)) numerical_tests.append((name, (xval,), expected, 1e-14)) run_cc_test("ansi_math1", name_expr, numerical_tests)
def test_csch_rewrite(): x = Symbol("x") assert csch(x).rewrite(exp) == 1 / (exp(x) / 2 - exp(-x) / 2) == csch(x).rewrite("tractable") assert csch(x).rewrite(cosh) == I / cosh(x + I * pi / 2) tanh_half = tanh(S.Half * x) assert csch(x).rewrite(tanh) == (1 - tanh_half ** 2) / (2 * tanh_half) coth_half = coth(S.Half * x) assert csch(x).rewrite(coth) == (coth_half ** 2 - 1) / (2 * coth_half)
def test_sech_rewrite(): x = Symbol("x") assert sech(x).rewrite(exp) == 1 / (exp(x) / 2 + exp(-x) / 2) == sech(x).rewrite("tractable") assert sech(x).rewrite(sinh) == I / sinh(x + I * pi / 2) tanh_half = tanh(S.Half * x) ** 2 assert sech(x).rewrite(tanh) == (1 - tanh_half) / (1 + tanh_half) coth_half = coth(S.Half * x) ** 2 assert sech(x).rewrite(coth) == (coth_half - 1) / (coth_half + 1)
def test_real_assumptions(): z = Symbol('z', real=False) assert sinh(z).is_real is None assert cosh(z).is_real is None assert tanh(z).is_real is None assert sech(z).is_real is None assert csch(z).is_real is None assert coth(z).is_real is None
def f(self, yvec, params): import sympy ymax = self.eqsys.upper_conc_bounds( params[:self.eqsys.ns], min_=lambda a, b: sympy.Piecewise((a, a < b), (b, True))) ytanh = [yimax*(4 + 5*sympy.tanh(yi))/8 for yimax, yi in zip(ymax, yvec)] return NumSysLin.f(self, ytanh, params)
def test_cosh_rewrite(): x = Symbol('x') assert cosh(x).rewrite(exp) == (exp(x)+exp(-x))/2 assert cosh(x).rewrite(sinh) == -I*sinh(x+I*pi/2) tanh_half = tanh(S.Half*x)**2 assert cosh(x).rewrite(tanh) == (1+tanh_half)/(1-tanh_half) coth_half = coth(S.Half*x)**2 assert cosh(x).rewrite(coth) == (coth_half+1)/(coth_half-1)
def test_sinh_rewrite(): x = Symbol('x') assert sinh(x).rewrite(exp) == (exp(x)-exp(-x))/2 assert sinh(x).rewrite(cosh) == -I*cosh(x+I*pi/2) tanh_half = tanh(S.Half*x) assert sinh(x).rewrite(tanh) == 2*tanh_half/(1-tanh_half**2) coth_half = coth(S.Half*x) assert sinh(x).rewrite(coth) == 2*coth_half/(coth_half**2-1)
def test_issue_3900(): s = tanh(x).lseries(x, 1) assert next(s) == tanh(1) assert next(s) == x - (x - 1)*tanh(1)**2 - 1 assert next(s) == -(x - 1)**2*tanh(1) + (x - 1)**2*tanh(1)**3 assert next(s) == -(x - 1)**3*tanh(1)**4 - (x - 1)**3/3 + \ 4*(x - 1)**3*tanh(1)**2/3
(y / y_decay)**2) - 2 * (x + x_min) / x_decay**2 * depth * np.exp(-((x + x_min) / x_decay)**2 - (y / y_decay)**2), -2 * beta * (y - yc) + barrier / y_decay_barrier * np.exp(-(x / x_decay_barrier)**2) / np.cosh(-(y - y_barrier) / y_decay_barrier)**2 - 2 * y / y_decay**2 * depth * np.exp(-((x - x_min) / x_decay)**2 - (y / y_decay)**2) - 2 * y / y_decay**2 * depth * np.exp(-((x + x_min) / x_decay)**2 - (y / y_decay)**2) ]) #sympy force matrix force_matrix = sp.Matrix([ -2 * alpha * x + barrier * (1 + tanh(-(y - y_barrier) / y_decay_barrier)) * 2 * x / x_decay_barrier**2 * exp(-(x / x_decay_barrier)**2) - 2 * (x - x_min) / x_decay**2 * depth * exp(-((x - x_min) / x_decay)**2 - (y / y_decay)**2) - 2 * (x + x_min) / x_decay**2 * depth * exp(-((x + x_min) / x_decay)**2 - (y / y_decay)**2), -2 * beta * (y - yc) + barrier / y_decay_barrier * exp(-(x / x_decay_barrier)**2) / cosh(-(y - y_barrier) / y_decay_barrier)**2 - 2 * y / y_decay**2 * depth * exp(-((x - x_min) / x_decay)**2 - (y / y_decay)**2) - 2 * y / y_decay**2 * depth * exp(-((x + x_min) / x_decay)**2 - (y / y_decay)**2) ]) #noise matrix noise_matrix = None #(identity matrix)
def Vwitch(rho, params={}): tanh = sy.tanh((rho - params['rhomax']) / params['cushion']) return (params['maxscale'] * params['s2'] * (tanh + 1) * (rho / params['rhomax']))
def func_friction(v, rh, rv, h, axis): return - (tanh(1.5 * v / h) * rh + rv * v) * axis
def test_polygamma(): from sympy import I assert polygamma(n, nan) is nan assert polygamma(0, oo) is oo assert polygamma(0, -oo) is oo assert polygamma(0, I * oo) is oo assert polygamma(0, -I * oo) is oo assert polygamma(1, oo) == 0 assert polygamma(5, oo) == 0 assert polygamma(0, -9) is zoo assert polygamma(0, -9) is zoo assert polygamma(0, -1) is zoo assert polygamma(0, 0) is zoo assert polygamma(0, 1) == -EulerGamma assert polygamma(0, 7) == Rational(49, 20) - EulerGamma assert polygamma(1, 1) == pi**2 / 6 assert polygamma(1, 2) == pi**2 / 6 - 1 assert polygamma(1, 3) == pi**2 / 6 - Rational(5, 4) assert polygamma(3, 1) == pi**4 / 15 assert polygamma(3, 5) == 6 * (Rational(-22369, 20736) + pi**4 / 90) assert polygamma(5, 1) == 8 * pi**6 / 63 assert polygamma(1, S.Half) == pi**2 / 2 assert polygamma(2, S.Half) == -14 * zeta(3) assert polygamma(11, S.Half) == 176896 * pi**12 def t(m, n): x = S(m) / n r = polygamma(0, x) if r.has(polygamma): return False return abs(polygamma(0, x.n()).n() - r.n()).n() < 1e-10 assert t(1, 2) assert t(3, 2) assert t(-1, 2) assert t(1, 4) assert t(-3, 4) assert t(1, 3) assert t(4, 3) assert t(3, 4) assert t(2, 3) assert t(123, 5) assert polygamma(0, x).rewrite(zeta) == polygamma(0, x) assert polygamma(1, x).rewrite(zeta) == zeta(2, x) assert polygamma(2, x).rewrite(zeta) == -2 * zeta(3, x) assert polygamma(I, 2).rewrite(zeta) == polygamma(I, 2) n1 = Symbol('n1') n2 = Symbol('n2', real=True) n3 = Symbol('n3', integer=True) n4 = Symbol('n4', positive=True) n5 = Symbol('n5', positive=True, integer=True) assert polygamma(n1, x).rewrite(zeta) == polygamma(n1, x) assert polygamma(n2, x).rewrite(zeta) == polygamma(n2, x) assert polygamma(n3, x).rewrite(zeta) == polygamma(n3, x) assert polygamma(n4, x).rewrite(zeta) == polygamma(n4, x) assert polygamma( n5, x).rewrite(zeta) == (-1)**(n5 + 1) * factorial(n5) * zeta(n5 + 1, x) assert polygamma(3, 7 * x).diff(x) == 7 * polygamma(4, 7 * x) assert polygamma(0, x).rewrite(harmonic) == harmonic(x - 1) - EulerGamma assert polygamma( 2, x).rewrite(harmonic) == 2 * harmonic(x - 1, 3) - 2 * zeta(3) ni = Symbol("n", integer=True) assert polygamma( ni, x).rewrite(harmonic) == (-1)**(ni + 1) * (-harmonic(x - 1, ni + 1) + zeta(ni + 1)) * factorial(ni) # Polygamma of non-negative integer order is unbranched: from sympy import exp_polar k = Symbol('n', integer=True, nonnegative=True) assert polygamma(k, exp_polar(2 * I * pi) * x) == polygamma(k, x) # but negative integers are branched! k = Symbol('n', integer=True) assert polygamma(k, exp_polar(2 * I * pi) * x).args == (k, exp_polar(2 * I * pi) * x) # Polygamma of order -1 is loggamma: assert polygamma(-1, x) == loggamma(x) # But smaller orders are iterated integrals and don't have a special name assert polygamma(-2, x).func is polygamma # Test a bug assert polygamma(0, -x).expand(func=True) == polygamma(0, -x) assert polygamma(2, 2.5).is_positive == False assert polygamma(2, -2.5).is_positive == False assert polygamma(3, 2.5).is_positive == True assert polygamma(3, -2.5).is_positive is True assert polygamma(-2, -2.5).is_positive is None assert polygamma(-3, -2.5).is_positive is None assert polygamma(2, 2.5).is_negative == True assert polygamma(3, 2.5).is_negative == False assert polygamma(3, -2.5).is_negative == False assert polygamma(2, -2.5).is_negative is True assert polygamma(-2, -2.5).is_negative is None assert polygamma(-3, -2.5).is_negative is None assert polygamma(I, 2).is_positive is None assert polygamma(I, 3).is_negative is None # issue 17350 assert polygamma(pi, 3).evalf() == polygamma(pi, 3) assert (I*polygamma(I, pi)).as_real_imag() == \ (-im(polygamma(I, pi)), re(polygamma(I, pi))) assert (tanh(polygamma(I, 1))).rewrite(exp) == \ (exp(polygamma(I, 1)) - exp(-polygamma(I, 1)))/(exp(polygamma(I, 1)) + exp(-polygamma(I, 1))) assert (I / polygamma(I, 4)).rewrite(exp) == \ I*sqrt(re(polygamma(I, 4))**2 + im(polygamma(I, 4))**2)\ /((re(polygamma(I, 4)) + I*im(polygamma(I, 4)))*Abs(polygamma(I, 4))) assert unchanged(polygamma, 2.3, 1.0) # issue 12569 assert unchanged(im, polygamma(0, I)) assert polygamma(Symbol('a', positive=True), Symbol( 'b', positive=True)).is_real is True assert polygamma(0, I).is_real is None
def characteristic_derivative(f): b_a = calc_sound_speed() b = rel_vel_add(b_a, c * sympy.tanh(psi)) return f.diff(t) + b * f.diff(r)
def test_coth_rewrite(): x = Symbol('x') assert coth(x).rewrite(exp) == (exp(x) + exp(-x)) / (exp(x) - exp(-x)) assert coth(x).rewrite(sinh) == -I * sinh(I * pi / 2 - x) / sinh(x) assert coth(x).rewrite(cosh) == -I * cosh(x) / cosh(I * pi / 2 - x) assert coth(x).rewrite(tanh) == 1 / tanh(x)
import sys, os sys.path.insert(0, os.path.join(os.pardir, 'src')) from fe_approx1D_numint import approximate from sympy import tanh, Symbol x = Symbol('x') steepness = 20 arg = steepness * (x - 0.5) approximate(tanh(arg), symbolic=False, numint='GaussLegendre2', d=1, N_e=4, filename='fe_p1_tanh_4e') approximate(tanh(arg), symbolic=False, numint='GaussLegendre2', d=1, N_e=8, filename='fe_p1_tanh_8e') approximate(tanh(arg), symbolic=False, numint='GaussLegendre2', d=1, N_e=16, filename='fe_p1_tanh_16e') approximate(tanh(arg), symbolic=False, numint='GaussLegendre3', d=2, N_e=2,
def test_tanh_series(): x = Symbol('x') assert tanh(x).series(x, 0, 10) == \ x - x**3/3 + 2*x**5/15 - 17*x**7/315 + 62*x**9/2835 + O(x**10)
def _test_manufactured_solution(damping=True): import sympy as sp t, m, k, b = sp.symbols('t m k b') # Choose solution u = sp.sin(t) v = sp.diff(u, t) # Choose f, s, F f = b * v s = k * sp.tanh(u) F = sp.cos(2 * t) equation = m * sp.diff(v, t) + f + s - F # Adjust F (source term because of manufactured solution) F += equation print 'F:', F # Set values for the symbols m, b, k m = 0.5 k = 1.5 b = 0.5 if damping else 0 F = F.subs('m', m).subs('b', b).subs('k', k) print f, s, F # Turn sympy expression into Python function F = sp.lambdify([t], F) # Define Python functions for f and s # (the expressions above are functions of t, we need # s(u) and f(v) from numpy import tanh s = lambda u: k * tanh(u) f = lambda v: b * v # Add modules='numpy' such that exact u and v work # with t as array argument exact_u = sp.lambdify([t], u, modules='numpy') exact_v = sp.lambdify([t], v, modules='numpy') # Solve problem for different dt from numpy import pi, sqrt, sum, log P = 2 * pi time_intervals_per_period = [20, 40, 80, 160, 240] h = [] # store discretization parameters E_u = [] # store errors in u E_v = [] # store errors in v for n in time_intervals_per_period: dt = P / n T = 8 * P computed_u, computed_v, t = EulerCromer(f=f, s=s, F=F, m=m, T=T, U_0=exact_u(0), V_0=exact_v(0), dt=dt) error_u = sqrt(dt * sum((exact_u(t) - computed_u)**2)) error_v = sqrt(dt * sum((exact_v(t) - computed_v)**2)) h.append(dt) E_u.append(error_u) E_v.append(error_v) """ # Compare exact and computed curves for this resolution figure() plot_u(computed_u, t, show=False) hold('on') plot(t, exact_u(t), show=True) legend(['numerical', 'exact']) savefig('tmp_%d.pdf' % n); savefig('tmp_%d.png' % n) """ # Compute convergence rates r_u = [ log(E_u[i] / E_u[i - 1]) / log(h[i] / h[i - 1]) for i in range(1, len(h)) ] r_v = [ log(E_u[i] / E_u[i - 1]) / log(h[i] / h[i - 1]) for i in range(1, len(h)) ] tol = 0.02 exact_r_u = 1.0 if damping else 2.0 exact_r_v = 1.0 if damping else 2.0 success = abs(exact_r_u - r_u[-1]) < tol and \ abs(exact_r_v - r_v[-1]) < tol msg = ' u rate: %.2f, v rate: %.2f' % (r_u[-1], r_v[-1]) assert success, msg
def test_atanh(): x = Symbol('x') #at specific points assert atanh(0) == 0 assert atanh(I) == I*pi/4 assert atanh(-I) == -I*pi/4 assert atanh(1) is oo assert atanh(-1) is -oo assert atanh(nan) is nan # at infinites assert atanh(oo) == -I*pi/2 assert atanh(-oo) == I*pi/2 assert atanh(I*oo) == I*pi/2 assert atanh(-I*oo) == -I*pi/2 assert atanh(zoo) == I*AccumBounds(-pi/2, pi/2) #properties assert atanh(-x) == -atanh(x) assert atanh(I/sqrt(3)) == I*pi/6 assert atanh(-I/sqrt(3)) == -I*pi/6 assert atanh(I*sqrt(3)) == I*pi/3 assert atanh(-I*sqrt(3)) == -I*pi/3 assert atanh(I*(1 + sqrt(2))) == pi*I*Rational(3, 8) assert atanh(I*(sqrt(2) - 1)) == pi*I/8 assert atanh(I*(1 - sqrt(2))) == -pi*I/8 assert atanh(-I*(1 + sqrt(2))) == pi*I*Rational(-3, 8) assert atanh(I*sqrt(5 + 2*sqrt(5))) == I*pi*Rational(2, 5) assert atanh(-I*sqrt(5 + 2*sqrt(5))) == I*pi*Rational(-2, 5) assert atanh(I*(2 - sqrt(3))) == pi*I/12 assert atanh(I*(sqrt(3) - 2)) == -pi*I/12 assert atanh(oo) == -I*pi/2 # Symmetry assert atanh(Rational(-1, 2)) == -atanh(S.Half) # inverse composition assert unchanged(atanh, tanh(Symbol('v1'))) assert atanh(tanh(-5, evaluate=False)) == -5 assert atanh(tanh(0, evaluate=False)) == 0 assert atanh(tanh(7, evaluate=False)) == 7 assert atanh(tanh(I, evaluate=False)) == I assert atanh(tanh(-I, evaluate=False)) == -I assert atanh(tanh(-11*I, evaluate=False)) == -11*I + 4*I*pi assert atanh(tanh(3 + I)) == 3 + I assert atanh(tanh(4 + 5*I)) == 4 - 2*I*pi + 5*I assert atanh(tanh(pi/2)) == pi/2 assert atanh(tanh(pi)) == pi assert atanh(tanh(-3 + 7*I)) == -3 - 2*I*pi + 7*I assert atanh(tanh(9 - I*Rational(2, 3))) == 9 - I*Rational(2, 3) assert atanh(tanh(-32 - 123*I)) == -32 - 123*I + 39*I*pi
def test_coth(): x, y = symbols('x,y') k = Symbol('k', integer=True) assert coth(nan) == nan assert coth(zoo) == nan assert coth(oo) == 1 assert coth(-oo) == -1 assert coth(0) == coth(0) assert coth(0) == zoo assert coth(1) == coth(1) assert coth(-1) == -coth(1) assert coth(x) == coth(x) assert coth(-x) == -coth(x) assert coth(pi * I) == -I * cot(pi) assert coth(-pi * I) == cot(pi) * I assert coth(2**1024 * E) == coth(2**1024 * E) assert coth(-2**1024 * E) == -coth(2**1024 * E) assert coth(pi * I) == -I * cot(pi) assert coth(-pi * I) == I * cot(pi) assert coth(2 * pi * I) == -I * cot(2 * pi) assert coth(-2 * pi * I) == I * cot(2 * pi) assert coth(-3 * 10**73 * pi * I) == I * cot(3 * 10**73 * pi) assert coth(7 * 10**103 * pi * I) == -I * cot(7 * 10**103 * pi) assert coth(pi * I / 2) == 0 assert coth(-pi * I / 2) == 0 assert coth(5 * pi * I / 2) == 0 assert coth(7 * pi * I / 2) == 0 assert coth(pi * I / 3) == -I / sqrt(3) assert coth(-2 * pi * I / 3) == -I / sqrt(3) assert coth(pi * I / 4) == -I assert coth(-pi * I / 4) == I assert coth(17 * pi * I / 4) == -I assert coth(-3 * pi * I / 4) == -I assert coth(pi * I / 6) == -sqrt(3) * I assert coth(-pi * I / 6) == sqrt(3) * I assert coth(7 * pi * I / 6) == -sqrt(3) * I assert coth(-5 * pi * I / 6) == -sqrt(3) * I assert coth(pi * I / 105) == -cot(pi / 105) * I assert coth(-pi * I / 105) == cot(pi / 105) * I assert coth(2 + 3 * I) == coth(2 + 3 * I) assert coth(x * I) == -cot(x) * I assert coth(k * pi * I) == -cot(k * pi) * I assert coth(17 * k * pi * I) == -cot(17 * k * pi) * I assert coth(k * pi * I) == -cot(k * pi) * I assert coth(log(tan(2))) == coth(log(-tan(2))) assert coth(1 + I * pi / 2) == tanh(1)
def test_coth(): x, y = symbols('x,y') k = Symbol('k', integer=True) assert coth(nan) is nan assert coth(zoo) is nan assert coth(oo) == 1 assert coth(-oo) == -1 assert coth(0) is zoo assert unchanged(coth, 1) assert coth(-1) == -coth(1) assert unchanged(coth, x) assert coth(-x) == -coth(x) assert coth(pi*I) == -I*cot(pi) assert coth(-pi*I) == cot(pi)*I assert unchanged(coth, 2**1024 * E) assert coth(-2**1024 * E) == -coth(2**1024 * E) assert coth(pi*I) == -I*cot(pi) assert coth(-pi*I) == I*cot(pi) assert coth(2*pi*I) == -I*cot(2*pi) assert coth(-2*pi*I) == I*cot(2*pi) assert coth(-3*10**73*pi*I) == I*cot(3*10**73*pi) assert coth(7*10**103*pi*I) == -I*cot(7*10**103*pi) assert coth(pi*I/2) == 0 assert coth(-pi*I/2) == 0 assert coth(pi*I*Rational(5, 2)) == 0 assert coth(pi*I*Rational(7, 2)) == 0 assert coth(pi*I/3) == -I/sqrt(3) assert coth(pi*I*Rational(-2, 3)) == -I/sqrt(3) assert coth(pi*I/4) == -I assert coth(-pi*I/4) == I assert coth(pi*I*Rational(17, 4)) == -I assert coth(pi*I*Rational(-3, 4)) == -I assert coth(pi*I/6) == -sqrt(3)*I assert coth(-pi*I/6) == sqrt(3)*I assert coth(pi*I*Rational(7, 6)) == -sqrt(3)*I assert coth(pi*I*Rational(-5, 6)) == -sqrt(3)*I assert coth(pi*I/105) == -cot(pi/105)*I assert coth(-pi*I/105) == cot(pi/105)*I assert unchanged(coth, 2 + 3*I) assert coth(x*I) == -cot(x)*I assert coth(k*pi*I) == -cot(k*pi)*I assert coth(17*k*pi*I) == -cot(17*k*pi)*I assert coth(k*pi*I) == -cot(k*pi)*I assert coth(log(tan(2))) == coth(log(-tan(2))) assert coth(1 + I*pi/2) == tanh(1) assert coth(x).as_real_imag(deep=False) == (sinh(re(x))*cosh(re(x))/(sin(im(x))**2 + sinh(re(x))**2), -sin(im(x))*cos(im(x))/(sin(im(x))**2 + sinh(re(x))**2)) x = Symbol('x', extended_real=True) assert coth(x).as_real_imag(deep=False) == (coth(x), 0)
def test_tanh_fdiff(): x = Symbol('x') raises(ArgumentIndexError, lambda: tanh(x).fdiff(2))
def test_tanh(): x, y = symbols('x,y') k = Symbol('k', integer=True) assert tanh(nan) is nan assert tanh(zoo) is nan assert tanh(oo) == 1 assert tanh(-oo) == -1 assert tanh(0) == 0 assert unchanged(tanh, 1) assert tanh(-1) == -tanh(1) assert unchanged(tanh, x) assert tanh(-x) == -tanh(x) assert unchanged(tanh, pi) assert tanh(-pi) == -tanh(pi) assert unchanged(tanh, 2**1024 * E) assert tanh(-2**1024 * E) == -tanh(2**1024 * E) assert tanh(pi*I) == 0 assert tanh(-pi*I) == 0 assert tanh(2*pi*I) == 0 assert tanh(-2*pi*I) == 0 assert tanh(-3*10**73*pi*I) == 0 assert tanh(7*10**103*pi*I) == 0 assert tanh(pi*I/2) is zoo assert tanh(-pi*I/2) is zoo assert tanh(pi*I*Rational(5, 2)) is zoo assert tanh(pi*I*Rational(7, 2)) is zoo assert tanh(pi*I/3) == sqrt(3)*I assert tanh(pi*I*Rational(-2, 3)) == sqrt(3)*I assert tanh(pi*I/4) == I assert tanh(-pi*I/4) == -I assert tanh(pi*I*Rational(17, 4)) == I assert tanh(pi*I*Rational(-3, 4)) == I assert tanh(pi*I/6) == I/sqrt(3) assert tanh(-pi*I/6) == -I/sqrt(3) assert tanh(pi*I*Rational(7, 6)) == I/sqrt(3) assert tanh(pi*I*Rational(-5, 6)) == I/sqrt(3) assert tanh(pi*I/105) == tan(pi/105)*I assert tanh(-pi*I/105) == -tan(pi/105)*I assert unchanged(tanh, 2 + 3*I) assert tanh(x*I) == tan(x)*I assert tanh(k*pi*I) == 0 assert tanh(17*k*pi*I) == 0 assert tanh(k*pi*I/2) == tan(k*pi/2)*I assert tanh(x).as_real_imag(deep=False) == (sinh(re(x))*cosh(re(x))/(cos(im(x))**2 + sinh(re(x))**2), sin(im(x))*cos(im(x))/(cos(im(x))**2 + sinh(re(x))**2)) x = Symbol('x', extended_real=True) assert tanh(x).as_real_imag(deep=False) == (tanh(x), 0) assert tanh(I*pi/3 + 1).is_real is False assert tanh(x).is_real is True assert tanh(I*pi*x/2).is_real is None
N = ReferenceFrame('N') t = symbols('t') # symbolic form # alpha = symbols('a') A1, A2 = symbols('A1 A2') B1, B2 = symbols('B1 B2') C2 = symbols('C2') # Define interface offset (alpha) alpha = 0.25 + A1 * t * sin(B1 * N[0]) + A2 * sin(B2 * N[0] + C2 * t) # Define the solution equation (eta) xi = (N[1] - alpha) / sqrt(2 * kappa) eta_sol = (1 - tanh(xi)) / 2 eq_sol = simplify( time_derivative(eta_sol, N) + 4 * eta_sol * (eta_sol - 1) * (eta_sol - 0.5) - divergence(kappa * gradient(eta_sol, N), N)) # substitute coefficient values parameters = ((kappa, params['kappa']), (A1, 0.0075), (B1, 8.0 * pi), (A2, 0.03), (B2, 22.0 * pi), (C2, 0.0625 * pi)) subs = [sub.subs(parameters) for sub in (eq_sol, eta_sol)] # generate FiPy lambda functions from sympy.utilities.lambdify import lambdify
def test_hyperbolic_simp(): x, y = symbols("x,y") assert trigsimp(sinh(x)**2 + 1) == cosh(x)**2 assert trigsimp(cosh(x)**2 - 1) == sinh(x)**2 assert trigsimp(cosh(x)**2 - sinh(x)**2) == 1 assert trigsimp(1 - tanh(x)**2) == 1 / cosh(x)**2 assert trigsimp(1 - 1 / cosh(x)**2) == tanh(x)**2 assert trigsimp(tanh(x)**2 + 1 / cosh(x)**2) == 1 assert trigsimp(coth(x)**2 - 1) == 1 / sinh(x)**2 assert trigsimp(1 / sinh(x)**2 + 1) == 1 / tanh(x)**2 assert trigsimp(coth(x)**2 - 1 / sinh(x)**2) == 1 assert trigsimp(5 * cosh(x)**2 - 5 * sinh(x)**2) == 5 assert trigsimp(5 * cosh(x / 2)**2 - 2 * sinh(x / 2)**2) == 3 * cosh(x) / 2 + Rational(7, 2) assert trigsimp(sinh(x) / cosh(x)) == tanh(x) assert trigsimp(tanh(x)) == trigsimp(sinh(x) / cosh(x)) assert trigsimp(cosh(x) / sinh(x)) == 1 / tanh(x) assert trigsimp(2 * tanh(x) * cosh(x)) == 2 * sinh(x) assert trigsimp(coth(x)**3 * sinh(x)**3) == cosh(x)**3 assert trigsimp(y * tanh(x)**2 / sinh(x)**2) == y / cosh(x)**2 assert trigsimp(coth(x) / cosh(x)) == 1 / sinh(x) for a in (pi / 6 * I, pi / 4 * I, pi / 3 * I): assert trigsimp(sinh(a) * cosh(x) + cosh(a) * sinh(x)) == sinh(x + a) assert trigsimp(-sinh(a) * cosh(x) + cosh(a) * sinh(x)) == sinh(x - a) e = 2 * cosh(x)**2 - 2 * sinh(x)**2 assert trigsimp(log(e)) == log(2) assert (trigsimp( cosh(x)**2 * cosh(y)**2 - cosh(x)**2 * sinh(y)**2 - sinh(x)**2, recursive=True, ) == 1) assert (trigsimp( sinh(x)**2 * sinh(y)**2 - sinh(x)**2 * cosh(y)**2 + cosh(x)**2, recursive=True, ) == 1) assert abs(trigsimp(2.0 * cosh(x)**2 - 2.0 * sinh(x)**2) - 2.0) < 1e-10 assert trigsimp(sinh(x)**2 / cosh(x)**2) == tanh(x)**2 assert trigsimp(sinh(x)**3 / cosh(x)**3) == tanh(x)**3 assert trigsimp(sinh(x)**10 / cosh(x)**10) == tanh(x)**10 assert trigsimp(cosh(x)**3 / sinh(x)**3) == 1 / tanh(x)**3 assert trigsimp(cosh(x) / sinh(x)) == 1 / tanh(x) assert trigsimp(cosh(x)**2 / sinh(x)**2) == 1 / tanh(x)**2 assert trigsimp(cosh(x)**10 / sinh(x)**10) == 1 / tanh(x)**10 assert trigsimp(x * cosh(x) * tanh(x)) == x * sinh(x) assert trigsimp(-sinh(x) + cosh(x) * tanh(x)) == 0 assert tan(x) != 1 / cot(x) # cot doesn't auto-simplify assert trigsimp(tan(x) - 1 / cot(x)) == 0 assert trigsimp(3 * tanh(x)**7 - 2 / coth(x)**7) == tanh(x)**7
def test_tanh(): x, y = symbols('xy') k = Symbol('k', integer=True) assert tanh(nan) == nan assert tanh(oo) == 1 assert tanh(-oo) == -1 assert tanh(0) == 0 assert tanh(1) == tanh(1) assert tanh(-1) == -tanh(1) assert tanh(x) == tanh(x) assert tanh(-x) == -tanh(x) assert tanh(pi) == tanh(pi) assert tanh(-pi) == -tanh(pi) assert tanh(2**1024 * E) == tanh(2**1024 * E) assert tanh(-2**1024 * E) == -tanh(2**1024 * E) assert tanh(pi * I) == 0 assert tanh(-pi * I) == 0 assert tanh(2 * pi * I) == 0 assert tanh(-2 * pi * I) == 0 assert tanh(-3 * 10**73 * pi * I) == 0 assert tanh(7 * 10**103 * pi * I) == 0 assert tanh(pi * I / 2) == tanh(pi * I / 2) assert tanh(-pi * I / 2) == -tanh(pi * I / 2) assert tanh(5 * pi * I / 2) == tanh(5 * pi * I / 2) assert tanh(7 * pi * I / 2) == tanh(7 * pi * I / 2) assert tanh(pi * I / 3) == sqrt(3) * I assert tanh(-2 * pi * I / 3) == sqrt(3) * I assert tanh(pi * I / 4) == I assert tanh(-pi * I / 4) == -I assert tanh(17 * pi * I / 4) == I assert tanh(-3 * pi * I / 4) == I assert tanh(pi * I / 6) == I / sqrt(3) assert tanh(-pi * I / 6) == -I / sqrt(3) assert tanh(7 * pi * I / 6) == I / sqrt(3) assert tanh(-5 * pi * I / 6) == I / sqrt(3) assert tanh(pi * I / 105) == tan(pi / 105) * I assert tanh(-pi * I / 105) == -tan(pi / 105) * I assert tanh(2 + 3 * I) == tanh(2 + 3 * I) assert tanh(x * I) == tan(x) * I assert tanh(k * pi * I) == 0 assert tanh(17 * k * pi * I) == 0 assert tanh(k * pi * I / 2) == tan(k * pi / 2) * I
sympy_mappings = { 'div': lambda x, y: x / y, 'mult': lambda x, y: x * y, 'sqrtm': lambda x: sympy.sqrt(abs(x)), 'square': lambda x: x**2, 'cube': lambda x: x**3, 'plus': lambda x, y: x + y, 'sub': lambda x, y: x - y, 'neg': lambda x: -x, 'pow': lambda x, y: sympy.sign(x) * abs(x)**y, 'cos': lambda x: sympy.cos(x), 'sin': lambda x: sympy.sin(x), 'tan': lambda x: sympy.tan(x), 'cosh': lambda x: sympy.cosh(x), 'sinh': lambda x: sympy.sinh(x), 'tanh': lambda x: sympy.tanh(x), 'exp': lambda x: sympy.exp(x), 'acos': lambda x: sympy.acos(x), 'asin': lambda x: sympy.asin(x), 'atan': lambda x: sympy.atan(x), 'acosh': lambda x: sympy.acosh(x), 'asinh': lambda x: sympy.asinh(x), 'atanh': lambda x: sympy.atanh(x), 'abs': lambda x: abs(x), 'mod': lambda x, y: sympy.Mod(x, y), 'erf': lambda x: sympy.erf(x), 'erfc': lambda x: sympy.erfc(x), 'logm': lambda x: sympy.log(abs(x)), 'logm10': lambda x: sympy.log10(abs(x)), 'logm2': lambda x: sympy.log2(abs(x)), 'log1p': lambda x: sympy.log(x + 1),
def test_issue_8901(): assert integrate(sinh(1.0 * x)) == 1.0 * cosh(1.0 * x) assert integrate(tanh(1.0 * x)) == 1.0 * x - 1.0 * log(tanh(1.0 * x) + 1) assert integrate(tanh(x)) == x - log(tanh(x) + 1)
def test_intrinsic_math_codegen(): # not included: log10 from sympy import (acos, asin, atan, ceiling, cos, cosh, floor, log, ln, sin, sinh, sqrt, tan, tanh, N, Abs) x = symbols('x') name_expr = [ ("test_abs", Abs(x)), ("test_acos", acos(x)), ("test_asin", asin(x)), ("test_atan", atan(x)), # ("test_ceil", ceiling(x)), ("test_cos", cos(x)), ("test_cosh", cosh(x)), # ("test_floor", floor(x)), ("test_log", log(x)), ("test_ln", ln(x)), ("test_sin", sin(x)), ("test_sinh", sinh(x)), ("test_sqrt", sqrt(x)), ("test_tan", tan(x)), ("test_tanh", tanh(x)), ] result = codegen(name_expr, "F95", "file", header=False, empty=False) assert result[0][0] == "file.f90" expected = ( 'REAL*8 function test_abs(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_abs = Abs(x)\n' 'end function\n' 'REAL*8 function test_acos(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_acos = acos(x)\n' 'end function\n' 'REAL*8 function test_asin(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_asin = asin(x)\n' 'end function\n' 'REAL*8 function test_atan(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_atan = atan(x)\n' 'end function\n' 'REAL*8 function test_cos(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_cos = cos(x)\n' 'end function\n' 'REAL*8 function test_cosh(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_cosh = cosh(x)\n' 'end function\n' 'REAL*8 function test_log(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_log = log(x)\n' 'end function\n' 'REAL*8 function test_ln(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_ln = log(x)\n' 'end function\n' 'REAL*8 function test_sin(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_sin = sin(x)\n' 'end function\n' 'REAL*8 function test_sinh(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_sinh = sinh(x)\n' 'end function\n' 'REAL*8 function test_sqrt(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_sqrt = sqrt(x)\n' 'end function\n' 'REAL*8 function test_tan(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_tan = tan(x)\n' 'end function\n' 'REAL*8 function test_tanh(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'test_tanh = tanh(x)\n' 'end function\n' ) assert result[0][1] == expected assert result[1][0] == "file.h" expected = ( 'interface\n' 'REAL*8 function test_abs(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_acos(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_asin(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_atan(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_cos(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_cosh(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_log(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_ln(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_sin(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_sinh(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_sqrt(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_tan(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' 'interface\n' 'REAL*8 function test_tanh(x)\n' 'implicit none\n' 'REAL*8, intent(in) :: x\n' 'end function\n' 'end interface\n' ) assert result[1][1] == expected
def ExactSolution(mesh, params): Re = 1. / params[2] Ha = sqrt(params[0] / (params[1] * params[2])) G = 10. x = sy.Symbol('x[0]') y = sy.Symbol('x[1]') b = (G / params[0]) * (sy.sinh(y * Ha) / sy.sinh(Ha) - y) d = sy.diff(x, x) p = -G * x - (G** 2) / (2 * params[0]) * (sy.sinh(y * Ha) / sy.sinh(Ha) - y)**2 u = (G / (params[2] * Ha * sy.tanh(Ha))) * (1 - sy.cosh(y * Ha) / sy.cosh(Ha)) v = sy.diff(x, y) r = sy.diff(x, y) uu = y * x * sy.exp(x + y) u = sy.diff(uu, y) v = -sy.diff(uu, x) p = sy.sin(x) * sy.exp(y) bb = x * y * sy.cos(x) b = sy.diff(bb, y) d = -sy.diff(bb, x) r = x * sy.sin(2 * sy.pi * y) * sy.sin(2 * sy.pi * x) # b = y # d = sy.diff(x, y) # r = sy.diff(y, y) J11 = p - params[2] * sy.diff(u, x) J12 = -params[2] * sy.diff(u, y) J21 = -params[2] * sy.diff(v, x) J22 = p - params[2] * sy.diff(v, y) L1 = sy.diff(u, x, x) + sy.diff(u, y, y) L2 = sy.diff(v, x, x) + sy.diff(v, y, y) A1 = u * sy.diff(u, x) + v * sy.diff(u, y) A2 = u * sy.diff(v, x) + v * sy.diff(v, y) P1 = sy.diff(p, x) P2 = sy.diff(p, y) C1 = sy.diff(d, x, y) - sy.diff(b, y, y) C2 = sy.diff(b, x, y) - sy.diff(d, x, x) NS1 = -d * (sy.diff(d, x) - sy.diff(b, y)) NS2 = b * (sy.diff(d, x) - sy.diff(b, y)) R1 = sy.diff(r, x) R2 = sy.diff(r, y) M1 = sy.diff(u * d - v * b, y) M2 = -sy.diff(u * d - v * b, x) u0 = Expression((myCCode(u), myCCode(v)), degree=4) p0 = Expression(myCCode(p), degree=4) b0 = Expression((myCCode(b), myCCode(d)), degree=4) r0 = Expression(myCCode(r), degree=4) print " u = (", str(u).replace('x[0]', 'x').replace( 'x[1]', 'y'), ", ", str(v).replace('x[0]', 'x').replace('x[1]', 'y'), ")\n" print " p = (", str(p).replace('x[0]', 'x').replace('x[1]', 'y'), ")\n" print " b = (", str(b).replace('x[0]', 'x').replace( 'x[1]', 'y'), ", ", str(d).replace('x[0]', 'x').replace('x[1]', 'y'), ")\n" print " r = (", str(r).replace('x[0]', 'x').replace('x[1]', 'y'), ")\n" Laplacian = Expression((myCCode(L1), myCCode(L2)), degree=4) Advection = Expression((myCCode(A1), myCCode(A2)), degree=4) gradPres = Expression((myCCode(P1), myCCode(P2)), degree=4) NScouple = Expression((myCCode(NS1), myCCode(NS2)), degree=4) CurlCurl = Expression((myCCode(C1), myCCode(C2)), degree=4) gradLagr = Expression((myCCode(R1), myCCode(R2)), degree=4) Mcouple = Expression((myCCode(M1), myCCode(M2)), degree=4) # pN = as_matrix(((Expression(myCCode(J11)), Expression(myCCode(J12))), (Expression(myCCode(J21)), Expression(myCCode(J22))))) return u0, p0, b0, r0, 1, Laplacian, Advection, gradPres, NScouple, CurlCurl, gradLagr, Mcouple
for i in range(N + 1): psi = [sym.sin((2 * i + 1) * x)] next_term, c = least_squares_orth(f, psi, Omega, False) u = u + next_term comparison_plot(f, u, Omega, 'tmp_sin%02dx' % i, legend_loc='upper left', show=False, plot_title='s=%g, i=%d' % (s, i)) if __name__ == '__main__': s = 20 # steepness f = sym.tanh(s * (x - sym.pi)) from math import pi Omega = [0, 2 * pi] # sym.pi did not work here efficient(f, s, Omega, N=10) # Make movie # avconv/ffmpeg skips frames, use convert instead (few files) cmd = 'convert -delay 200 tmp_sin*.png tanh_sines_approx.gif' os.system(cmd) # Make static plots, 3 figures on 2 lines for ext in 'pdf', 'png': cmd = 'doconce combine_images %s -3 ' % ext cmd += 'tmp_sin00x tmp_sin01x tmp_sin02x tmp_sin04x ' cmd += 'tmp_sin07x tmp_sin10x tanh_sines_approx' os.system(cmd) plt.show()
def kernel_function(time_points, time_points2, kernel_type='rbf', kernel_param=[10, 0.2]): '''Populates the GP covariance matrix and it's derivatives. Input time points (list of real numbers) and kernel parameters (list of real values of size 2)''' # error handeling # if len(kernel_param) != 3: # raise ValueError('kernel_param input requires two floats') if type(time_points) is not np.ndarray: raise ValueError('time points is not a numpy array') elif len(time_points.shape) > 1: raise ValueError('time points must be a one dimensional numpy array') t = sym.var('t0,t1') if kernel_type == 'rbf': # rbf kernel dist = ((t[0] - t[1]) / kernel_param[0])**2 kernel = sym.exp(-.5 * dist) #kernel = kernel_param[0] * sym.exp(- dist**2) if kernel_type == 'periodic': # periodic kernel dist = (t[0] - t[1]) / kernel_param[1] kernel = sym.exp( -2 * sym.sin(np.pi * sym.sqrt(dist**2) / kernel_param[1])**2 / kernel_param[0]**2) if kernel_type == 'locally_periodic': # locally periodic kernel dist = (t[0] - t[1]) kernel = sym.exp(-dist**2 / 2 * kernel_param[1]**2) * sym.exp( -2 * sym.sin(np.pi * sym.sqrt( (t[0] - t[1])**2) / kernel_param[2])**2 / kernel_param[1]**2) elif kernel_type == 'rbf+lin': # rbf kernel + linear kernel dist = (t[0] - t[1]) kernel = sym.exp(-dist**2 / kernel_param[1]** 2) + kernel_param[2] + kernel_param[3] * ( t[0] - kernel_param[4]) * (t[1] - kernel_param[4]) elif kernel_type == 'sigmoid': # sigmoid kernel kernel = sym.asin( (kernel_param[1] + kernel_param[2] * t[0] * t[1]) / sym.sqrt( (kernel_param[1] + kernel_param[2] * t[0]**2 + 1) * (kernel_param[1] + kernel_param[2] * t[1]**2 + 1))) elif kernel_type == 'sigmoid2': # sigmoid kernel 2 kernel = sym.tanh(kernel_param[0] * t[0] * t[1] + kernel_param[1]) elif kernel_type == 'exp_sin_squared': # periodic kernel dist = sym.sqrt((t[0] - t[1])**2) arg = np.pi * dist / kernel_param[1] sin_of_arg = sym.sin(arg) kernel = sym.exp(-2 * (sin_of_arg / kernel_param[0])**2) elif kernel_type == 'RQ': dist = (t[0] - t[1])**2 tmp = dist / (2 * kernel_param[0] * kernel_param[1]**2) base = (1 + tmp) kernel = base**-kernel_param[0] elif kernel_type == 'matern': # periodic kernel dist = sym.sqrt(((t[0] - t[1]) / kernel_param[0])**2) #kernel = dist * np.sqrt(3) #kernel = (1. + kernel) * sym.exp(-kernel) #kernel = kernel_param[1]**2 * (1 + kernel_param[2] * np.sqrt(3) * kernel_param[3] * dist) * sym.exp(-kernel_param[2] * np.sqrt(3) * kernel_param[3] * dist) if kernel_param[1] == 0.5: kernel = sym.exp(-dist) elif kernel_param[1] == 1.5: kernel = dist * np.sqrt(3) kernel = (1. + kernel) * sym.exp(-kernel) elif kernel_param[1] == 2.5: kernel = dist * np.sqrt(5) kernel = (1. + kernel + kernel**2 / 3.0) * sym.exp(-kernel) else: # general case; expensive to evaluate kernel = dist kernel[kernel == 0.0] += np.finfo( float).eps # strict zeros result in nan tmp = (sym.sqrt(2 * kernel_param[1]) * kernel) kernel.fill((2**(1. - kernel_param[1])) / gamma(kernel_param[1])) kernel *= tmp**kernel_param[1] kernel *= kv(kernel_param[1], tmp) kernel *= kernel_param[-1]**2 # kernel derivative functions kernel_diff = kernel.diff(t[0]) kernel_diff_diff = kernel_diff.diff(t[1]) cov_func = sym.lambdify(t, kernel) cov_func_diff = sym.lambdify(t, kernel_diff) cov_func_diff_diff = sym.lambdify(t, kernel_diff_diff) cov = np.zeros((len(time_points), len(time_points))) cov_diff = np.zeros((len(time_points), len(time_points))) cov_diff_diff = np.zeros((len(time_points), len(time_points))) for i in range(len(time_points)): for j in range(len(time_points)): cov[i, j] = cov_func(time_points[i], time_points[j]) cov_diff[i, j] = cov_func_diff(time_points[i], time_points[j]) cov_diff_diff[i, j] = cov_func_diff_diff(time_points[i], time_points[j]) cov_obs = np.zeros((len(time_points2), len(time_points2))) for i in range(len(time_points2)): for j in range(len(time_points2)): cov_obs[i, j] = cov_func(time_points2[i], time_points2[j]) cov_state_obs = np.zeros((len(time_points), len(time_points2))) for i in range(len(time_points)): for j in range(len(time_points2)): cov_state_obs[i, j] = cov_func(time_points[i], time_points2[j]) # compute $\mathbf{C}_{\boldsymbol\phi_k}' ~ \mathbf{C}_{\boldsymbol\phi_k}^{-1}$ cov_diff_times_inv_cov = np.linalg.solve(cov.T, cov_diff.T).T # plot sample state trajectories from GP prior mean = np.zeros((cov.shape[0])) prior_state_sample1 = np.random.multivariate_normal(mean, cov) prior_state_sample2 = np.random.multivariate_normal(mean, cov) plot_trajectories(time_points, prior_state_sample1, prior_state_sample2) eps_cov = cov_diff_diff - cov_diff_times_inv_cov.dot(cov_diff.T) return cov_diff_times_inv_cov, eps_cov, cov, cov_obs, cov_state_obs
def _eval_rewrite_as_tanh(self, arg): from sympy import tanh return (1 + tanh(arg / 2)) / (1 - tanh(arg / 2))
class TestAllGood(object): # These latex strings should parse to the corresponding SymPy expression GOOD_PAIRS = [ ("0", 0), ("1", 1), ("-3.14", -3.14), ("5-3", _Add(5, -3)), ("(-7.13)(1.5)", _Mul(Rational('-7.13'), Rational('1.5'))), ("\\left(-7.13\\right)\\left(1.5\\right)", _Mul(Rational('-7.13'), Rational('1.5'))), ("x", x), ("2x", 2 * x), ("x^2", x**2), ("x^{3 + 1}", x**_Add(3, 1)), ("x^{\\left\\{3 + 1\\right\\}}", x**_Add(3, 1)), ("-3y + 2x", _Add(_Mul(2, x), Mul(-1, 3, y, evaluate=False))), ("-c", -c), ("a \\cdot b", a * b), ("a / b", a / b), ("a \\div b", a / b), ("a + b", a + b), ("a + b - a", Add(a, b, _Mul(-1, a), evaluate=False)), ("a^2 + b^2 = c^2", Eq(a**2 + b**2, c**2)), ("a^2 + b^2 != 2c^2", Ne(a**2 + b**2, 2 * c**2)), ("a\\mod b", Mod(a, b)), ("\\sin \\theta", sin(theta)), ("\\sin(\\theta)", sin(theta)), ("\\sin\\left(\\theta\\right)", sin(theta)), ("\\sin^{-1} a", asin(a)), ("\\sin a \\cos b", _Mul(sin(a), cos(b))), ("\\sin \\cos \\theta", sin(cos(theta))), ("\\sin(\\cos \\theta)", sin(cos(theta))), ("\\arcsin(a)", asin(a)), ("\\arccos(a)", acos(a)), ("\\arctan(a)", atan(a)), ("\\sinh(a)", sinh(a)), ("\\cosh(a)", cosh(a)), ("\\tanh(a)", tanh(a)), ("\\sinh^{-1}(a)", asinh(a)), ("\\cosh^{-1}(a)", acosh(a)), ("\\tanh^{-1}(a)", atanh(a)), ("\\arcsinh(a)", asinh(a)), ("\\arccosh(a)", acosh(a)), ("\\arctanh(a)", atanh(a)), ("\\arsinh(a)", asinh(a)), ("\\arcosh(a)", acosh(a)), ("\\artanh(a)", atanh(a)), ("\\operatorname{arcsinh}(a)", asinh(a)), ("\\operatorname{arccosh}(a)", acosh(a)), ("\\operatorname{arctanh}(a)", atanh(a)), ("\\operatorname{arsinh}(a)", asinh(a)), ("\\operatorname{arcosh}(a)", acosh(a)), ("\\operatorname{artanh}(a)", atanh(a)), ("\\cos^2(x)", cos(x)**2), ("\\cos(x)^2", cos(x)**2), ("\\frac{a}{b}", a / b), ("\\frac{a + b}{c}", _Mul(a + b, _Pow(c, -1))), ("\\frac{7}{3}", _Mul(7, _Pow(3, -1))), ("(\\csc x)(\\sec y)", csc(x) * sec(y)), ("\\lim_{x \\to 3} a", Limit(a, x, 3)), ("\\lim_{x \\rightarrow 3} a", Limit(a, x, 3)), ("\\lim_{x \\Rightarrow 3} a", Limit(a, x, 3)), ("\\lim_{x \\longrightarrow 3} a", Limit(a, x, 3)), ("\\lim_{x \\Longrightarrow 3} a", Limit(a, x, 3)), ("\\lim_{x \\to 3^{+}} a", Limit(a, x, 3, dir='+')), ("\\lim_{x \\to 3^{-}} a", Limit(a, x, 3, dir='-')), ("\\infty", oo), ("\\infty\\%", oo), ("\\$\\infty", oo), ("-\\infty", -oo), ("-\\infty\\%", -oo), ("-\\$\\infty", -oo), ("\\lim_{x \\to \\infty} \\frac{1}{x}", Limit(_Mul(1, _Pow(x, -1)), x, oo)), ("\\frac{d}{dx} x", Derivative(x, x)), ("\\frac{d}{dt} x", Derivative(x, t)), # ("f(x)", f(x)), # ("f(x, y)", f(x, y)), # ("f(x, y, z)", f(x, y, z)), # ("\\frac{d f(x)}{dx}", Derivative(f(x), x)), # ("\\frac{d\\theta(x)}{dx}", Derivative(theta(x), x)), ("|x|", _Abs(x)), ("\\left|x\\right|", _Abs(x)), ("||x||", _Abs(Abs(x))), ("|x||y|", _Abs(x) * _Abs(y)), ("||x||y||", _Abs(_Abs(x) * _Abs(y))), ("\\pi^{|xy|}", pi**_Abs(x * y)), ("\\frac{\\pi}{3}", _Mul(pi, _Pow(3, -1))), ("\\sin{\\frac{\\pi}{2}}", sin(_Mul(pi, _Pow(2, -1)), evaluate=False)), ("a+bI", a + I * b), ("e^{I\\pi}", -1), ("\\int x dx", Integral(x, x)), ("\\int x d\\theta", Integral(x, theta)), ("\\int (x^2 - y)dx", Integral(x**2 - y, x)), ("\\int x + a dx", Integral(_Add(x, a), x)), ("\\int da", Integral(1, a)), ("\\int_0^7 dx", Integral(1, (x, 0, 7))), ("\\int_a^b x dx", Integral(x, (x, a, b))), ("\\int^b_a x dx", Integral(x, (x, a, b))), ("\\int_{a}^b x dx", Integral(x, (x, a, b))), ("\\int^{b}_a x dx", Integral(x, (x, a, b))), ("\\int_{a}^{b} x dx", Integral(x, (x, a, b))), ("\\int_{ }^{}x dx", Integral(x, x)), ("\\int^{ }_{ }x dx", Integral(x, x)), ("\\int^{b}_{a} x dx", Integral(x, (x, a, b))), # ("\\int_{f(a)}^{f(b)} f(z) dz", Integral(f(z), (z, f(a), f(b)))), ("\\int (x+a)", Integral(_Add(x, a), x)), ("\\int a + b + c dx", Integral(Add(a, b, c, evaluate=False), x)), ("\\int \\frac{dz}{z}", Integral(Pow(z, -1), z)), ("\\int \\frac{3 dz}{z}", Integral(3 * Pow(z, -1), z)), ("\\int \\frac{1}{x} dx", Integral(Pow(x, -1), x)), ("\\int \\frac{1}{a} + \\frac{1}{b} dx", Integral(_Add(_Pow(a, -1), Pow(b, -1)), x)), ("\\int \\frac{3 \\cdot d\\theta}{\\theta}", Integral(3 * _Pow(theta, -1), theta)), ("\\int \\frac{1}{x} + 1 dx", Integral(_Add(_Pow(x, -1), 1), x)), ("x_0", Symbol('x_{0}', real=True)), ("x_{1}", Symbol('x_{1}', real=True)), ("x_a", Symbol('x_{a}', real=True)), ("x_{b}", Symbol('x_{b}', real=True)), ("h_\\theta", Symbol('h_{theta}', real=True)), ("h_{\\theta}", Symbol('h_{theta}', real=True)), # ("h_{\\theta}(x_0, x_1)", Symbol('h_{theta}', real=True)(Symbol('x_{0}', real=True), Symbol('x_{1}', real=True))), ("x!", _factorial(x)), ("100!", _factorial(100)), ("\\theta!", _factorial(theta)), ("(x + 1)!", _factorial(_Add(x, 1))), ("\\left(x + 1\\right)!", _factorial(_Add(x, 1))), ("(x!)!", _factorial(_factorial(x))), ("x!!!", _factorial(_factorial(_factorial(x)))), ("5!7!", _Mul(_factorial(5), _factorial(7))), ("\\sqrt{x}", sqrt(x)), ("\\sqrt{x + b}", sqrt(_Add(x, b))), ("\\sqrt[3]{\\sin x}", root(sin(x), 3)), ("\\sqrt[y]{\\sin x}", root(sin(x), y)), ("\\sqrt[\\theta]{\\sin x}", root(sin(x), theta)), ("x < y", StrictLessThan(x, y)), ("x \\leq y", LessThan(x, y)), ("x > y", StrictGreaterThan(x, y)), ("x \\geq y", GreaterThan(x, y)), ("\\sum_{k = 1}^{3} c", Sum(c, (k, 1, 3))), ("\\sum_{k = 1}^3 c", Sum(c, (k, 1, 3))), ("\\sum^{3}_{k = 1} c", Sum(c, (k, 1, 3))), ("\\sum^3_{k = 1} c", Sum(c, (k, 1, 3))), ("\\sum_{k = 1}^{10} k^2", Sum(k**2, (k, 1, 10))), ("\\sum_{n = 0}^{\\infty} \\frac{1}{n!}", Sum(_Pow(_factorial(n), -1), (n, 0, oo))), ("\\prod_{a = b}^{c} x", Product(x, (a, b, c))), ("\\prod_{a = b}^c x", Product(x, (a, b, c))), ("\\prod^{c}_{a = b} x", Product(x, (a, b, c))), ("\\prod^c_{a = b} x", Product(x, (a, b, c))), ("\\ln x", _log(x, E)), ("\\ln xy", _log(x * y, E)), ("\\log x", _log(x, 10)), ("\\log xy", _log(x * y, 10)), # ("\\log_2 x", _log(x, 2)), ("\\log_{2} x", _log(x, 2)), # ("\\log_a x", _log(x, a)), ("\\log_{a} x", _log(x, a)), ("\\log_{11} x", _log(x, 11)), ("\\log_{a^2} x", _log(x, _Pow(a, 2))), ("[x]", x), ("[a + b]", _Add(a, b)), ("\\frac{d}{dx} [ \\tan x ]", Derivative(tan(x), x)), ("2\\overline{x}", 2 * Symbol('xbar', real=True)), ("2\\overline{x}_n", 2 * Symbol('xbar_{n}', real=True)), ("\\frac{x}{\\overline{x}_n}", x / Symbol('xbar_{n}', real=True)), ("\\frac{\\sin(x)}{\\overline{x}_n}", sin(Symbol('x', real=True)) / Symbol('xbar_{n}', real=True)), ("2\\bar{x}", 2 * Symbol('xbar', real=True)), ("2\\bar{x}_n", 2 * Symbol('xbar_{n}', real=True)), ("\\sin\\left(\\theta\\right) \\cdot4", sin(theta) * 4), ("\\ln\\left(\\theta\\right)", _log(theta, E)), ("\\ln\\left(x-\\theta\\right)", _log(x - theta, E)), ("\\ln\\left(\\left(x-\\theta\\right)\\right)", _log(x - theta, E)), ("\\ln\\left(\\left[x-\\theta\\right]\\right)", _log(x - theta, E)), ("\\ln\\left(\\left\\{x-\\theta\\right\\}\\right)", _log(x - theta, E)), ("\\ln\\left(\\left|x-\\theta\\right|\\right)", _log(_Abs(x - theta), E)), ("\\frac{1}{2}xy(x+y)", Mul(_Pow(2, -1), x, y, (x + y), evaluate=False)), ("\\frac{1}{2}\\theta(x+y)", Mul(_Pow(2, -1), theta, (x + y), evaluate=False)), ("1-f(x)", 1 - f * x), ("\\begin{matrix}1&2\\\\3&4\\end{matrix}", Matrix([[1, 2], [3, 4]])), ("\\begin{matrix}x&x^2\\\\\\sqrt{x}&x\\end{matrix}", Matrix([[x, x**2], [_Pow(x, S.Half), x]])), ("\\begin{matrix}\\sqrt{x}\\\\\\sin(\\theta)\\end{matrix}", Matrix([_Pow(x, S.Half), sin(theta)])), ("\\begin{pmatrix}1&2\\\\3&4\\end{pmatrix}", Matrix([[1, 2], [3, 4]])), ("\\begin{bmatrix}1&2\\\\3&4\\end{bmatrix}", Matrix([[1, 2], [3, 4]])), # scientific notation ("2.5\\times 10^2", 250), ("1,500\\times 10^{-1}", 150), # e notation ("2.5E2", 250), ("1,500E-1", 150), # multiplication without cmd ("2x2y", Mul(2, x, 2, y, evaluate=False)), ("2x2", Mul(2, x, 2, evaluate=False)), ("x2", x * 2), # lin alg processing ("\\theta\\begin{matrix}1&2\\\\3&4\\end{matrix}", MatMul(theta, Matrix([[1, 2], [3, 4]]), evaluate=False)), ("\\theta\\begin{matrix}1\\\\3\\end{matrix} - \\begin{matrix}-1\\\\2\\end{matrix}", MatAdd(MatMul(theta, Matrix([[1], [3]]), evaluate=False), MatMul(-1, Matrix([[-1], [2]]), evaluate=False), evaluate=False)), ("\\theta\\begin{matrix}1&0\\\\0&1\\end{matrix}*\\begin{matrix}3\\\\-2\\end{matrix}", MatMul(theta, Matrix([[1, 0], [0, 1]]), Matrix([3, -2]), evaluate=False)), ("\\frac{1}{9}\\theta\\begin{matrix}1&2\\\\3&4\\end{matrix}", MatMul(Pow(9, -1, evaluate=False), theta, Matrix([[1, 2], [3, 4]]), evaluate=False)), ("\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]), ("\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix};\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]), ("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix}\\right\\}", [Matrix([1, 2, 3]), Matrix([4, 3, 1])]), ("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix},\\begin{pmatrix}4\\\\3\\\\1\\end{pmatrix},\\begin{pmatrix}1\\\\1\\\\1\\end{pmatrix}\\right\\}", [Matrix([1, 2, 3]), Matrix([4, 3, 1]), Matrix([1, 1, 1])]), ("\\left\\{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}\\right\\}", Matrix([1, 2, 3])), ("\\left{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}\\right}", Matrix([1, 2, 3])), ("{\\begin{pmatrix}1\\\\2\\\\3\\end{pmatrix}}", Matrix([1, 2, 3])), # us dollars ("\\$1,000.00", 1000), ("\\$543.21", 543.21), ("\\$0.009", 0.009), # percentages ("100\\%", 1), ("1.5\\%", 0.015), ("0.05\\%", 0.0005), # empty set ("\\emptyset", S.EmptySet) ] def test_good_pair(self, s, eq): assert_equal(s, eq)
def test_hyperbolic_simp(): x, y = symbols('x,y') assert trigsimp(sinh(x)**2 + 1) == cosh(x)**2 assert trigsimp(cosh(x)**2 - 1) == sinh(x)**2 assert trigsimp(cosh(x)**2 - sinh(x)**2) == 1 assert trigsimp(1 - tanh(x)**2) == 1 / cosh(x)**2 assert trigsimp(1 - 1 / cosh(x)**2) == tanh(x)**2 assert trigsimp(tanh(x)**2 + 1 / cosh(x)**2) == 1 assert trigsimp(coth(x)**2 - 1) == 1 / sinh(x)**2 assert trigsimp(1 / sinh(x)**2 + 1) == 1 / tanh(x)**2 assert trigsimp(coth(x)**2 - 1 / sinh(x)**2) == 1 assert trigsimp(5 * cosh(x)**2 - 5 * sinh(x)**2) == 5 assert trigsimp(5 * cosh(x / 2)**2 - 2 * sinh(x / 2)**2) == 3 * cosh(x) / 2 + S(7) / 2 assert trigsimp(sinh(x) / cosh(x)) == tanh(x) assert trigsimp(tanh(x)) == trigsimp(sinh(x) / cosh(x)) assert trigsimp(cosh(x) / sinh(x)) == 1 / tanh(x) assert trigsimp(2 * tanh(x) * cosh(x)) == 2 * sinh(x) assert trigsimp(coth(x)**3 * sinh(x)**3) == cosh(x)**3 assert trigsimp(y * tanh(x)**2 / sinh(x)**2) == y / cosh(x)**2 assert trigsimp(coth(x) / cosh(x)) == 1 / sinh(x) e = 2 * cosh(x)**2 - 2 * sinh(x)**2 assert trigsimp(log(e)) == log(2) assert trigsimp(cosh(x)**2 * cosh(y)**2 - cosh(x)**2 * sinh(y)**2 - sinh(x)**2, recursive=True) == 1 assert trigsimp(sinh(x)**2 * sinh(y)**2 - sinh(x)**2 * cosh(y)**2 + cosh(x)**2, recursive=True) == 1 assert abs(trigsimp(2.0 * cosh(x)**2 - 2.0 * sinh(x)**2) - 2.0) < 1e-10 assert trigsimp(sinh(x)**2 / cosh(x)**2) == tanh(x)**2 assert trigsimp(sinh(x)**3 / cosh(x)**3) == tanh(x)**3 assert trigsimp(sinh(x)**10 / cosh(x)**10) == tanh(x)**10 assert trigsimp(cosh(x)**3 / sinh(x)**3) == 1 / tanh(x)**3 assert trigsimp(cosh(x) / sinh(x)) == 1 / tanh(x) assert trigsimp(cosh(x)**2 / sinh(x)**2) == 1 / tanh(x)**2 assert trigsimp(cosh(x)**10 / sinh(x)**10) == 1 / tanh(x)**10 assert trigsimp(x * cosh(x) * tanh(x)) == x * sinh(x) assert trigsimp(-sinh(x) + cosh(x) * tanh(x)) == 0 assert tan(x) != 1 / cot(x) # cot doesn't auto-simplify assert trigsimp(tan(x) - 1 / cot(x)) == 0 assert trigsimp(3 * tanh(x)**7 - 2 / coth(x)**7) == tanh(x)**7
def Vtophat(rho, params={}): tanh = sy.tanh((rho - params['rhomax']) / params['cushion']) return params['maxscale'] * params['s2'] * (tanh + 1)
def test_tan(): assert tan(nan) == nan assert tan.nargs == FiniteSet(1) assert tan(oo * I) == I assert tan(-oo * I) == -I assert tan(0) == 0 assert tan(atan(x)) == x assert tan(asin(x)) == x / sqrt(1 - x**2) assert tan(acos(x)) == sqrt(1 - x**2) / x assert tan(acot(x)) == 1 / x assert tan(atan2(y, x)) == y / x assert tan(pi * I) == tanh(pi) * I assert tan(-pi * I) == -tanh(pi) * I assert tan(-2 * I) == -tanh(2) * I assert tan(pi) == 0 assert tan(-pi) == 0 assert tan(2 * pi) == 0 assert tan(-2 * pi) == 0 assert tan(-3 * 10**73 * pi) == 0 assert tan(pi / 2) == zoo assert tan(3 * pi / 2) == zoo assert tan(pi / 3) == sqrt(3) assert tan(-2 * pi / 3) == sqrt(3) assert tan(pi / 4) == S.One assert tan(-pi / 4) == -S.One assert tan(17 * pi / 4) == S.One assert tan(-3 * pi / 4) == S.One assert tan(pi / 6) == 1 / sqrt(3) assert tan(-pi / 6) == -1 / sqrt(3) assert tan(7 * pi / 6) == 1 / sqrt(3) assert tan(-5 * pi / 6) == 1 / sqrt(3) assert tan(pi / 8).expand() == -1 + sqrt(2) assert tan(3 * pi / 8).expand() == 1 + sqrt(2) assert tan(5 * pi / 8).expand() == -1 - sqrt(2) assert tan(7 * pi / 8).expand() == 1 - sqrt(2) assert tan(pi / 12) == -sqrt(3) + 2 assert tan(5 * pi / 12) == sqrt(3) + 2 assert tan(7 * pi / 12) == -sqrt(3) - 2 assert tan(11 * pi / 12) == sqrt(3) - 2 assert tan(pi / 24).radsimp() == -2 - sqrt(3) + sqrt(2) + sqrt(6) assert tan(5 * pi / 24).radsimp() == -2 + sqrt(3) - sqrt(2) + sqrt(6) assert tan(7 * pi / 24).radsimp() == 2 - sqrt(3) - sqrt(2) + sqrt(6) assert tan(11 * pi / 24).radsimp() == 2 + sqrt(3) + sqrt(2) + sqrt(6) assert tan(13 * pi / 24).radsimp() == -2 - sqrt(3) - sqrt(2) - sqrt(6) assert tan(17 * pi / 24).radsimp() == -2 + sqrt(3) + sqrt(2) - sqrt(6) assert tan(19 * pi / 24).radsimp() == 2 - sqrt(3) + sqrt(2) - sqrt(6) assert tan(23 * pi / 24).radsimp() == 2 + sqrt(3) - sqrt(2) - sqrt(6) assert 1 == (tan(8 * pi / 15) * cos(8 * pi / 15) / sin(8 * pi / 15)).ratsimp() assert tan(x * I) == tanh(x) * I assert tan(k * pi) == 0 assert tan(17 * k * pi) == 0 assert tan(k * pi * I) == tanh(k * pi) * I assert tan(r).is_real is True assert tan(0, evaluate=False).is_algebraic assert tan(a).is_algebraic is None assert tan(na).is_algebraic is False assert tan(10 * pi / 7) == tan(3 * pi / 7) assert tan(11 * pi / 7) == -tan(3 * pi / 7) assert tan(-11 * pi / 7) == tan(3 * pi / 7) assert tan(15 * pi / 14) == tan(pi / 14) assert tan(-15 * pi / 14) == -tan(pi / 14)
def test_solve_lambert(): assert solveset_real(x * exp(x) - 1, x) == FiniteSet(LambertW(1)) assert solveset_real(x + 2**x, x) == \ FiniteSet(-LambertW(log(2))/log(2)) # issue 4739 assert solveset_real(exp(log(5) * x) - 2**x, x) == FiniteSet(0) ans = solveset_real(3 * x + 5 + 2**(-5 * x + 3), x) assert ans == FiniteSet(-Rational(5, 3) + LambertW(-10240 * 2**(S(1) / 3) * log(2) / 3) / (5 * log(2))) eq = 2 * (3 * x + 4)**5 - 6 * 7**(3 * x + 9) result = solveset_real(eq, x) ans = FiniteSet( (log(2401) + 5 * LambertW(-log(7**(7 * 3**Rational(1, 5) / 5)))) / (3 * log(7)) / -1) assert result == ans assert solveset_real(eq.expand(), x) == result assert solveset_real(5*x - 1 + 3*exp(2 - 7*x), x) == \ FiniteSet(Rational(1, 5) + LambertW(-21*exp(Rational(3, 5))/5)/7) assert solveset_real(2*x + 5 + log(3*x - 2), x) == \ FiniteSet(Rational(2, 3) + LambertW(2*exp(-Rational(19, 3))/3)/2) assert solveset_real(3*x + log(4*x), x) == \ FiniteSet(LambertW(Rational(3, 4))/3) assert solveset_complex(x**z*y**z - 2, z) == \ FiniteSet(log(2)/(log(x) + log(y))) assert solveset_real(x**x - 2) == FiniteSet(exp(LambertW(log(2)))) a = Symbol('a') assert solveset_real(-a * x + 2 * x * log(x), x) == FiniteSet(exp(a / 2)) a = Symbol('a', real=True) assert solveset_real(a/x + exp(x/2), x) == \ FiniteSet(2*LambertW(-a/2)) assert solveset_real((a/x + exp(x/2)).diff(x), x) == \ FiniteSet(4*LambertW(sqrt(2)*sqrt(a)/4)) assert solveset_real(1 / (1 / x - y + exp(y)), x) == EmptySet() # coverage test p = Symbol('p', positive=True) w = Symbol('w') assert solveset_real((1 / p + 1)**(p + 1), p) == EmptySet() assert solveset_real(tanh(x + 3) * tanh(x - 3) - 1, x) == EmptySet() assert solveset_real(2*x**w - 4*y**w, w) == \ solveset_real((x/y)**w - 2, w) assert solveset_real((x**2 - 2*x + 1).subs(x, log(x) + 3*x), x) == \ FiniteSet(LambertW(3*S.Exp1)/3) assert solveset_real((x**2 - 2*x + 1).subs(x, (log(x) + 3*x)**2 - 1), x) == \ FiniteSet(LambertW(3*exp(-sqrt(2)))/3, LambertW(3*exp(sqrt(2)))/3) assert solveset_real((x**2 - 2*x - 2).subs(x, log(x) + 3*x), x) == \ FiniteSet(LambertW(3*exp(1 + sqrt(3)))/3, LambertW(3*exp(-sqrt(3) + 1))/3) assert solveset_real(x*log(x) + 3*x + 1, x) == \ FiniteSet(exp(-3 + LambertW(-exp(3)))) eq = (x * exp(x) - 3).subs(x, x * exp(x)) assert solveset_real(eq, x) == \ FiniteSet(LambertW(3*exp(-LambertW(3)))) assert solveset_real(3*log(a**(3*x + 5)) + a**(3*x + 5), x) == \ FiniteSet(-((log(a**5) + LambertW(S(1)/3))/(3*log(a)))) p = symbols('p', positive=True) assert solveset_real(3*log(p**(3*x + 5)) + p**(3*x + 5), x) == \ FiniteSet( log((-3**(S(1)/3) - 3**(S(5)/6)*I)*LambertW(S(1)/3)**(S(1)/3)/(2*p**(S(5)/3)))/log(p), log((-3**(S(1)/3) + 3**(S(5)/6)*I)*LambertW(S(1)/3)**(S(1)/3)/(2*p**(S(5)/3)))/log(p), log((3*LambertW(S(1)/3)/p**5)**(1/(3*log(p)))),) # checked numerically # check collection b = Symbol('b') eq = 3 * log(a**(3 * x + 5)) + b * log(a**(3 * x + 5)) + a**(3 * x + 5) assert solveset_real( eq, x) == FiniteSet(-((log(a**5) + LambertW(1 / (b + 3))) / (3 * log(a)))) # issue 4271 assert solveset_real((a / x + exp(x / 2)).diff(x, 2), x) == FiniteSet(6 * LambertW( (-1)**(S(1) / 3) * a**(S(1) / 3) / 3)) assert solveset_real(x**3 - 3**x, x) == \ FiniteSet(-3/log(3)*LambertW(-log(3)/3)) assert solveset_real(x**2 - 2**x, x) == FiniteSet(2) assert solveset_real(-x**2 + 2**x, x) == FiniteSet(2) assert solveset_real(3**cos(x) - cos(x)**3) == FiniteSet( acos(-3 * LambertW(-log(3) / 3) / log(3))) assert solveset_real(4**(x / 2) - 2**(x / 3), x) == FiniteSet(0) assert solveset_real(5**(x / 2) - 2**(x / 3), x) == FiniteSet(0) b = sqrt(6) * sqrt(log(2)) / sqrt(log(5)) assert solveset_real(5**(x / 2) - 2**(3 / x), x) == FiniteSet(-b, b)
def test_is_function_class_equation(): from sympy.abc import x, a assert _is_function_class_equation(TrigonometricFunction, tan(x), x) is True assert _is_function_class_equation(TrigonometricFunction, tan(x) - 1, x) is True assert _is_function_class_equation(TrigonometricFunction, tan(x) + sin(x), x) is True assert _is_function_class_equation(TrigonometricFunction, tan(x) + sin(x) - a, x) is True assert _is_function_class_equation(TrigonometricFunction, sin(x) * tan(x) + sin(x), x) is True assert _is_function_class_equation(TrigonometricFunction, sin(x) * tan(x + a) + sin(x), x) is True assert _is_function_class_equation(TrigonometricFunction, sin(x) * tan(x * a) + sin(x), x) is True assert _is_function_class_equation(TrigonometricFunction, a * tan(x) - 1, x) is True assert _is_function_class_equation(TrigonometricFunction, tan(x)**2 + sin(x) - 1, x) is True assert _is_function_class_equation(TrigonometricFunction, tan(x**2), x) is False assert _is_function_class_equation(TrigonometricFunction, tan(x**2) + sin(x), x) is False assert _is_function_class_equation(TrigonometricFunction, tan(x)**sin(x), x) is False assert _is_function_class_equation(TrigonometricFunction, tan(sin(x)) + sin(x), x) is False assert _is_function_class_equation(HyperbolicFunction, tanh(x), x) is True assert _is_function_class_equation(HyperbolicFunction, tanh(x) - 1, x) is True assert _is_function_class_equation(HyperbolicFunction, tanh(x) + sinh(x), x) is True assert _is_function_class_equation(HyperbolicFunction, tanh(x) + sinh(x) - a, x) is True assert _is_function_class_equation(HyperbolicFunction, sinh(x) * tanh(x) + sinh(x), x) is True assert _is_function_class_equation(HyperbolicFunction, sinh(x) * tanh(x + a) + sinh(x), x) is True assert _is_function_class_equation(HyperbolicFunction, sinh(x) * tanh(x * a) + sinh(x), x) is True assert _is_function_class_equation(HyperbolicFunction, a * tanh(x) - 1, x) is True assert _is_function_class_equation(HyperbolicFunction, tanh(x)**2 + sinh(x) - 1, x) is True assert _is_function_class_equation(HyperbolicFunction, tanh(x**2), x) is False assert _is_function_class_equation(HyperbolicFunction, tanh(x**2) + sinh(x), x) is False assert _is_function_class_equation(HyperbolicFunction, tanh(x)**sinh(x), x) is False assert _is_function_class_equation(HyperbolicFunction, tanh(sinh(x)) + sinh(x), x) is False