Beispiel #1
0
def test_simple():
    # issue sympy/sympy#5223
    assert series(1, x) == 1
    pytest.raises(ValueError, lambda: cos(x + y).series())
    pytest.raises(ValueError, lambda: x.series(dir=''))

    D = Derivative
    assert D(x**2 + x**3*y**2, x, 2, y, 1).series(x).doit().removeO() == 12*x*y

    assert (1 + x).getn() is None

    # issue sympy/sympy#8805
    assert series(1, n=8) == 1

    # issue sympy/sympy#5223
    assert (cos(x).series(x, 1) -
            cos(x + 1).series(x).subs({x: x - 1})).removeO() == 0

    assert abs(x).series(x, oo, n=5, dir='+') == x
    assert abs(x).series(x, -oo, n=5, dir='-') == -x
    assert abs(-x).series(x, oo, n=5, dir='+') == x
    assert abs(-x).series(x, -oo, n=5, dir='-') == -x

    # issue sympy/sympy#7203
    assert series(cos(x), x, pi, 3) == -1 + (x - pi)**2/2 + O((x - pi)**3,
                                                              (x, pi))
Beispiel #2
0
def test_sin():
    e1 = sin(x).series(x, 0)
    e2 = series(sin(x), x, 0)
    assert e1 == e2

    # issue sympy/sympy#5223:
    assert ((1/sin(x))**oo).series() == oo
Beispiel #3
0
def test_airybi():
    z = Symbol('z', extended_real=False)
    t = Symbol('t', negative=True)
    p = Symbol('p', positive=True)

    assert isinstance(airybi(z), airybi)

    assert airybi(0) == 3**Rational(5, 6) / (3 * gamma(Rational(2, 3)))
    assert airybi(oo) == oo
    assert airybi(-oo) == 0

    assert diff(airybi(z), z) == airybiprime(z)

    assert series(airybi(z), z, 0,
                  3) == (cbrt(3) * gamma(Rational(1, 3)) / (2 * pi) +
                         3**Rational(2, 3) * z * gamma(Rational(2, 3)) /
                         (2 * pi) + O(z**3))
    l = Limit(
        airybi(I / x) /
        (exp(Rational(2, 3) *
             (I / x)**Rational(3, 2)) * sqrt(pi * sqrt(I / x))), x, 0)
    assert l.doit() == l

    assert airybi(z).rewrite(hyper) == (root(3, 6) * z * hyper(
        (), (Rational(4, 3), ), z**3 / 9) / gamma(Rational(1, 3)) +
                                        3**Rational(5, 6) * hyper(
                                            (), (Rational(2, 3), ), z**3 / 9) /
                                        (3 * gamma(Rational(2, 3))))

    assert isinstance(airybi(z).rewrite(besselj), airybi)
    assert (airybi(t).rewrite(besselj) == sqrt(3) * sqrt(-t) *
            (besselj(-1 / 3, 2 * (-t)**Rational(3, 2) / 3) -
             besselj(Rational(1, 3), 2 * (-t)**Rational(3, 2) / 3)) / 3)
    assert airybi(z).rewrite(besseli) == (
        sqrt(3) * (z * besseli(Rational(1, 3), 2 * z**Rational(3, 2) / 3) /
                   cbrt(z**Rational(3, 2)) + cbrt(z**Rational(3, 2)) *
                   besseli(-Rational(1, 3), 2 * z**Rational(3, 2) / 3)) / 3)
    assert airybi(p).rewrite(besseli) == (
        sqrt(3) * sqrt(p) *
        (besseli(-Rational(1, 3), 2 * p**Rational(3, 2) / 3) +
         besseli(Rational(1, 3), 2 * p**Rational(3, 2) / 3)) / 3)
    assert airybi(p).rewrite(besselj) == airybi(p)

    assert expand_func(airybi(
        2 *
        cbrt(3 * z**5))) == (sqrt(3) * (1 - cbrt(z**5) / z**Rational(5, 3)) *
                             airyai(2 * cbrt(3) * z**Rational(5, 3)) / 2 +
                             (1 + cbrt(z**5) / z**Rational(5, 3)) *
                             airybi(2 * cbrt(3) * z**Rational(5, 3)) / 2)
    assert expand_func(airybi(x * y)) == airybi(x * y)
    assert expand_func(airybi(log(x))) == airybi(log(x))
    assert expand_func(airybi(2 * root(3 * z**5, 5))) == airybi(
        2 * root(3 * z**5, 5))

    assert airybi(x).taylor_term(-1, x) == 0
Beispiel #4
0
def test_airyai():
    z = Symbol('z', extended_real=False)
    r = Symbol('r', extended_real=True)
    t = Symbol('t', negative=True)
    p = Symbol('p', positive=True)

    assert isinstance(airyai(z), airyai)

    assert airyai(0) == cbrt(3)/(3*gamma(Rational(2, 3)))
    assert airyai(oo) == 0
    assert airyai(-oo) == 0

    assert diff(airyai(z), z) == airyaiprime(z)

    assert series(airyai(z), z, 0, 3) == (
        3**Rational(5, 6)*gamma(Rational(1, 3))/(6*pi) - root(3, 6)*z*gamma(Rational(2, 3))/(2*pi) + O(z**3))

    l = Limit(airyai(I/x)/(exp(-Rational(2, 3)*(I/x)**Rational(3, 2))*sqrt(pi*sqrt(I/x))/2), x, 0)
    assert l.doit() == l  # cover _airyais._eval_aseries

    assert airyai(z).rewrite(hyper) == (
        -3**Rational(2, 3)*z*hyper((), (Rational(4, 3),), z**3/9)/(3*gamma(Rational(1, 3))) +
        cbrt(3)*hyper((), (Rational(2, 3),), z**3/9)/(3*gamma(Rational(2, 3))))

    assert isinstance(airyai(z).rewrite(besselj), airyai)
    assert airyai(t).rewrite(besselj) == (
        sqrt(-t)*(besselj(-Rational(1, 3), 2*(-t)**Rational(3, 2)/3) +
                  besselj(Rational(1, 3), 2*(-t)**Rational(3, 2)/3))/3)
    assert airyai(z).rewrite(besseli) == (
        -z*besseli(Rational(1, 3), 2*z**Rational(3, 2)/3)/(3*cbrt(z**Rational(3, 2))) +
        cbrt(z**Rational(3, 2))*besseli(-Rational(1, 3), 2*z**Rational(3, 2)/3)/3)
    assert airyai(p).rewrite(besseli) == (
        sqrt(p)*(besseli(-Rational(1, 3), 2*p**Rational(3, 2)/3) -
                 besseli(Rational(1, 3), 2*p**Rational(3, 2)/3))/3)

    assert expand_func(airyai(2*cbrt(3*z**5))) == (
        -sqrt(3)*(-1 + cbrt(z**5)/z**Rational(5, 3))*airybi(2*cbrt(3)*z**Rational(5, 3))/6 +
        (1 + cbrt(z**5)/z**Rational(5, 3))*airyai(2*cbrt(3)*z**Rational(5, 3))/2)
    assert expand_func(airyai(x*y)) == airyai(x*y)
    assert expand_func(airyai(log(x))) == airyai(log(x))
    assert expand_func(airyai(2*root(3*z**5, 5))) == airyai(2*root(3*z**5, 5))

    assert (airyai(r).as_real_imag() ==
            airyai(r).as_real_imag(deep=False) == (airyai(r), 0))
    assert airyai(x).as_real_imag() == airyai(x).as_real_imag(deep=False)
    assert (airyai(x).as_real_imag() ==
            (airyai(re(x) - I*re(x)*abs(im(x))/abs(re(x)))/2 +
             airyai(re(x) + I*re(x)*abs(im(x))/abs(re(x)))/2,
             I*(airyai(re(x) - I*re(x)*abs(im(x))/abs(re(x))) -
                airyai(re(x) + I*re(x)*abs(im(x))/Abs(re(x)))) *
             re(x)*abs(im(x))/(2*im(x)*abs(re(x)))))

    assert airyai(x).taylor_term(-1, x) == 0
Beispiel #5
0
def test_airybiprime():
    z = Symbol('z', extended_real=False)
    t = Symbol('t', negative=True)
    p = Symbol('p', positive=True)

    assert isinstance(airybiprime(z), airybiprime)

    assert airybiprime(0) == root(3, 6) / gamma(Rational(1, 3))
    assert airybiprime(oo) == oo
    assert airybiprime(-oo) == 0

    assert diff(airybiprime(z), z) == z * airybi(z)

    assert series(airybiprime(z), z, 0,
                  3) == (root(3, 6) / gamma(Rational(1, 3)) +
                         3**Rational(5, 6) * z**2 /
                         (6 * gamma(Rational(2, 3))) + O(z**3))

    assert airybiprime(z).rewrite(hyper) == (
        3**Rational(5, 6) * z**2 * hyper((), (Rational(5, 3), ), z**3 / 9) /
        (6 * gamma(Rational(2, 3))) + root(3, 6) * hyper(
            (), (Rational(1, 3), ), z**3 / 9) / gamma(Rational(1, 3)))

    assert isinstance(airybiprime(z).rewrite(besselj), airybiprime)
    assert (airybiprime(t).rewrite(besselj) == -sqrt(3) * t *
            (besselj(-Rational(2, 3), 2 * (-t)**Rational(3, 2) / 3) +
             besselj(Rational(2, 3), 2 * (-t)**Rational(3, 2) / 3)) / 3)
    assert airybiprime(z).rewrite(besseli) == (
        sqrt(3) * (z**2 * besseli(Rational(2, 3), 2 * z**Rational(3, 2) / 3) /
                   (z**Rational(3, 2))**Rational(2, 3) +
                   (z**Rational(3, 2))**Rational(2, 3) *
                   besseli(-Rational(2, 3), 2 * z**Rational(3, 2) / 3)) / 3)
    assert airybiprime(p).rewrite(besseli) == (
        sqrt(3) * p * (besseli(-Rational(2, 3), 2 * p**Rational(3, 2) / 3) +
                       besseli(Rational(2, 3), 2 * p**Rational(3, 2) / 3)) / 3)
    assert airybiprime(p).rewrite(besselj) == airybiprime(p)

    assert expand_func(airybiprime(
        2 *
        cbrt(3 * z**5))) == (sqrt(3) * (z**Rational(5, 3) / cbrt(z**5) - 1) *
                             airyaiprime(2 * cbrt(3) * z**Rational(5, 3)) / 2 +
                             (z**Rational(5, 3) / cbrt(z**5) + 1) *
                             airybiprime(2 * cbrt(3) * z**Rational(5, 3)) / 2)
    assert expand_func(airybiprime(x * y)) == airybiprime(x * y)
    assert expand_func(airybiprime(log(x))) == airybiprime(log(x))
    assert expand_func(airybiprime(2 * root(3 * z**5, 5))) == airybiprime(
        2 * root(3 * z**5, 5))

    assert airybiprime(-2).evalf(50) == Float(
        '0.27879516692116952268509756941098324140300059345163131', dps=50)
Beispiel #6
0
def test_issue_5223():
    assert series(1, x) == 1
    assert next(Integer(0).lseries(x)) == 0
    assert cos(x).series() == cos(x).series(x)
    pytest.raises(ValueError, lambda: cos(x + y).series())
    pytest.raises(ValueError, lambda: x.series(dir=""))

    assert (cos(x).series(x, 1) -
            cos(x + 1).series(x).subs(x, x - 1)).removeO() == 0
    e = cos(x).series(x, 1, n=None)
    assert [next(e) for i in range(2)] == [cos(1), -((x - 1) * sin(1))]
    e = cos(x).series(x, 1, n=None, dir='-')
    assert [next(e) for i in range(2)] == [cos(1), (1 - x) * sin(1)]
    # the following test is exact so no need for x -> x - 1 replacement
    assert abs(x).series(x, 1, dir='-') == x
    assert exp(x).series(x, 1, dir='-', n=3).removeO() == \
        E - E*(-x + 1) + E*(-x + 1)**2/2

    D = Derivative
    assert D(x**2 + x**3 * y**2, x, 2, y,
             1).series(x).doit().removeO() == 12 * x * y
    assert next(D(cos(x), x).lseries()) == D(1, x)
    assert D(exp(x), x).series(n=3) == (D(1, x) + D(x, x) + D(x**2 / 2, x) +
                                        D(x**3 / 6, x) + O(x**3))

    assert Integral(x, (x, 1, 3), (y, 1, x)).series(x) == -4 + 4 * x

    assert (1 + x + O(x**2)).getn() == 2
    assert (1 + x).getn() is None

    assert ((1 / sin(x))**oo).series() == oo
    assert ((sin(x))**y).nseries(x, n=1) == x**y + O(x**(y + 2), x)

    assert sin(1 / x).series(
        x, oo, n=5) == 1 / x - 1 / (6 * x**3) + O(x**(-5), (x, oo))
    assert abs(x).series(x, oo, n=5, dir='+') == x
    assert abs(x).series(x, -oo, n=5, dir='-') == -x
    assert abs(-x).series(x, oo, n=5, dir='+') == x
    assert abs(-x).series(x, -oo, n=5, dir='-') == -x

    assert exp(x*log(x)).series(n=3) == \
        1 + x*log(x) + x**2*log(x)**2/2 + x**3*log(x)**3/6 + O(x**3)

    p = Symbol('p', positive=True)
    assert exp(sqrt(p)**3*log(p)).series(n=3) == \
        1 + p**3*log(p)**2/2 + p**Rational(3, 2)*log(p) + O(p**3)

    assert exp(sin(x)*log(x)).series(n=2) == \
        1 + x*log(x) + x**2*log(x)**2/2 + O(x**2)
Beispiel #7
0
def test_airyaiprime():
    z = Symbol('z', extended_real=False)
    t = Symbol('t', negative=True)
    p = Symbol('p', positive=True)

    assert isinstance(airyaiprime(z), airyaiprime)

    assert airyaiprime(0) == -3**Rational(2, 3) / (3 * gamma(Rational(1, 3)))
    assert airyaiprime(oo) == 0

    assert diff(airyaiprime(z), z) == z * airyai(z)

    assert series(airyaiprime(z), z, 0,
                  3) == (-3**Rational(2, 3) / (3 * gamma(Rational(1, 3))) +
                         cbrt(3) * z**2 / (6 * gamma(Rational(2, 3))) +
                         O(z**3))

    assert airyaiprime(z).rewrite(hyper) == (
        cbrt(3) * z**2 * hyper((), (Rational(5, 3), ), z**3 / 9) /
        (6 * gamma(Rational(2, 3))) - 3**Rational(2, 3) * hyper(
            (), (Rational(1, 3), ), z**3 / 9) / (3 * gamma(Rational(1, 3))))

    assert isinstance(airyaiprime(z).rewrite(besselj), airyaiprime)
    assert (airyaiprime(t).rewrite(besselj) == t *
            (besselj(-Rational(2, 3), 2 * (-t)**Rational(3, 2) / 3) -
             besselj(Rational(2, 3), 2 * (-t)**Rational(3, 2) / 3)) / 3)
    assert airyaiprime(z).rewrite(besseli) == (
        z**2 * besseli(Rational(2, 3), 2 * z**Rational(3, 2) / 3) /
        (3 * (z**Rational(3, 2))**Rational(2, 3)) -
        (z**Rational(3, 2))**Rational(2, 3) *
        besseli(-Rational(1, 3), 2 * z**Rational(3, 2) / 3) / 3)
    assert airyaiprime(p).rewrite(besseli) == (
        p * (-besseli(-Rational(2, 3), 2 * p**Rational(3, 2) / 3) +
             besseli(Rational(2, 3), 2 * p**Rational(3, 2) / 3)) / 3)
    assert airyaiprime(p).rewrite(besselj) == airyaiprime(p)

    assert expand_func(airyaiprime(
        2 *
        cbrt(3 * z**5))) == (sqrt(3) * (z**Rational(5, 3) / cbrt(z**5) - 1) *
                             airybiprime(2 * cbrt(3) * z**Rational(5, 3)) / 6 +
                             (z**Rational(5, 3) / cbrt(z**5) + 1) *
                             airyaiprime(2 * cbrt(3) * z**Rational(5, 3)) / 2)
    assert expand_func(airyaiprime(x * y)) == airyaiprime(x * y)
    assert expand_func(airyaiprime(log(x))) == airyaiprime(log(x))
    assert expand_func(airyaiprime(2 * root(3 * z**5, 5))) == airyaiprime(
        2 * root(3 * z**5, 5))

    assert airyaiprime(-2).evalf(50) == Float(
        '0.61825902074169104140626429133247528291577794512414753', dps=50)
Beispiel #8
0
def test_sympyissue_5223():
    assert series(1, x) == 1
    assert next(Integer(0).lseries(x)) == 0
    assert cos(x).series() == cos(x).series(x)
    pytest.raises(ValueError, lambda: cos(x + y).series())
    pytest.raises(ValueError, lambda: x.series(dir=""))

    assert (cos(x).series(x, 1) -
            cos(x + 1).series(x).subs({x: x - 1})).removeO() == 0
    e = cos(x).series(x, 1, n=None)
    assert [next(e) for i in range(2)] == [cos(1), -((x - 1)*sin(1))]
    e = cos(x).series(x, 1, n=None, dir='-')
    assert [next(e) for i in range(2)] == [cos(1), (1 - x)*sin(1)]
    # the following test is exact so no need for x -> x - 1 replacement
    assert abs(x).series(x, 1, dir='-') == x
    assert exp(x).series(x, 1, dir='-', n=3).removeO() == \
        E - E*(-x + 1) + E*(-x + 1)**2/2

    D = Derivative
    assert D(x**2 + x**3*y**2, x, 2, y, 1).series(x).doit().removeO() == 12*x*y
    assert next(D(cos(x), x).lseries()) == D(1, x)
    assert D(exp(x), x).series(n=3) == (D(1, x) + D(x, x) + D(x**2/2, x) +
                                        D(x**3/6, x) + O(x**3))

    assert Integral(x, (x, 1, 3), (y, 1, x)).series(x) == -4 + 4*x

    assert (1 + x + O(x**2)).getn() == 2
    assert (1 + x).getn() is None

    assert ((1/sin(x))**oo).series() == oo
    assert ((sin(x))**y).nseries(x, n=1) == x**y + O(x**(y + 2), x)

    assert sin(1/x).series(x, oo, n=5) == 1/x - 1/(6*x**3) + O(x**(-5), (x, oo))
    assert abs(x).series(x, oo, n=5, dir='+') == x
    assert abs(x).series(x, -oo, n=5, dir='-') == -x
    assert abs(-x).series(x, oo, n=5, dir='+') == x
    assert abs(-x).series(x, -oo, n=5, dir='-') == -x

    assert exp(x*log(x)).series(n=3) == \
        1 + x*log(x) + x**2*log(x)**2/2 + x**3*log(x)**3/6 + O(x**3)

    p = Symbol('p', positive=True)
    assert exp(sqrt(p)**3*log(p)).series(n=3) == \
        1 + p**3*log(p)**2/2 + p**Rational(3, 2)*log(p) + O(p**3)

    assert exp(sin(x)*log(x)).series(n=2) == \
        1 + x*log(x) + x**2*log(x)**2/2 + O(x**2)
Beispiel #9
0
def test_airyai():
    z = Symbol('z', extended_real=False)
    t = Symbol('t', negative=True)
    p = Symbol('p', positive=True)

    assert isinstance(airyai(z), airyai)

    assert airyai(0) == 3**Rational(1, 3) / (3 * gamma(Rational(2, 3)))
    assert airyai(oo) == 0
    assert airyai(-oo) == 0

    assert diff(airyai(z), z) == airyaiprime(z)

    assert series(airyai(z), z, 0,
                  3) == (3**Rational(5, 6) * gamma(Rational(1, 3)) / (6 * pi) -
                         3**Rational(1, 6) * z * gamma(Rational(2, 3)) /
                         (2 * pi) + O(z**3))

    assert airyai(z).rewrite(hyper) == (-3**Rational(2, 3) * z * hyper(
        (), (Rational(4, 3), ),
        z**Integer(3) / 9) / (3 * gamma(Rational(1, 3))) +
                                        3**Rational(1, 3) * hyper(
                                            (), (Rational(2, 3), ),
                                            z**Integer(3) / 9) /
                                        (3 * gamma(Rational(2, 3))))

    assert isinstance(airyai(z).rewrite(besselj), airyai)
    assert airyai(t).rewrite(besselj) == (
        sqrt(-t) * (besselj(-Rational(1, 3), 2 * (-t)**Rational(3, 2) / 3) +
                    besselj(Rational(1, 3), 2 * (-t)**Rational(3, 2) / 3)) / 3)
    assert airyai(z).rewrite(besseli) == (
        -z * besseli(Rational(1, 3), 2 * z**Rational(3, 2) / 3) /
        (3 * (z**Rational(3, 2))**Rational(1, 3)) +
        (z**Rational(3, 2))**Rational(1, 3) *
        besseli(-Rational(1, 3), 2 * z**Rational(3, 2) / 3) / 3)
    assert airyai(p).rewrite(besseli) == (
        sqrt(p) * (besseli(-Rational(1, 3), 2 * p**Rational(3, 2) / 3) -
                   besseli(Rational(1, 3), 2 * p**Rational(3, 2) / 3)) / 3)

    assert expand_func(airyai(2 * (3 * z**5)**Rational(1, 3))) == (
        -sqrt(3) * (-1 + (z**5)**Rational(1, 3) / z**Rational(5, 3)) *
        airybi(2 * 3**Rational(1, 3) * z**Rational(5, 3)) / 6 +
        (1 + (z**5)**Rational(1, 3) / z**Rational(5, 3)) *
        airyai(2 * 3**Rational(1, 3) * z**Rational(5, 3)) / 2)
Beispiel #10
0
def test_airybi():
    z = Symbol('z', extended_real=False)
    t = Symbol('t', negative=True)
    p = Symbol('p', positive=True)

    assert isinstance(airybi(z), airybi)

    assert airybi(0) == 3**Rational(5, 6)/(3*gamma(Rational(2, 3)))
    assert airybi(oo) == oo
    assert airybi(-oo) == 0

    assert diff(airybi(z), z) == airybiprime(z)

    assert series(airybi(z), z, 0, 3) == (
        cbrt(3)*gamma(Rational(1, 3))/(2*pi) + 3**Rational(2, 3)*z*gamma(Rational(2, 3))/(2*pi) + O(z**3))
    l = Limit(airybi(I/x)/(exp(Rational(2, 3)*(I/x)**Rational(3, 2))*sqrt(pi*sqrt(I/x))), x, 0)
    assert l.doit() == l

    assert airybi(z).rewrite(hyper) == (
        root(3, 6)*z*hyper((), (Rational(4, 3),), z**3/9)/gamma(Rational(1, 3)) +
        3**Rational(5, 6)*hyper((), (Rational(2, 3),), z**3/9)/(3*gamma(Rational(2, 3))))

    assert isinstance(airybi(z).rewrite(besselj), airybi)
    assert (airybi(t).rewrite(besselj) ==
            sqrt(3)*sqrt(-t)*(besselj(-1/3, 2*(-t)**Rational(3, 2)/3) -
                              besselj(Rational(1, 3),
                                      2*(-t)**Rational(3, 2)/3))/3)
    assert airybi(z).rewrite(besseli) == (
        sqrt(3)*(z*besseli(Rational(1, 3), 2*z**Rational(3, 2)/3)/cbrt(z**Rational(3, 2)) +
                 cbrt(z**Rational(3, 2))*besseli(-Rational(1, 3), 2*z**Rational(3, 2)/3))/3)
    assert airybi(p).rewrite(besseli) == (
        sqrt(3)*sqrt(p)*(besseli(-Rational(1, 3), 2*p**Rational(3, 2)/3) +
                         besseli(Rational(1, 3), 2*p**Rational(3, 2)/3))/3)
    assert airybi(p).rewrite(besselj) == airybi(p)

    assert expand_func(airybi(2*cbrt(3*z**5))) == (
        sqrt(3)*(1 - cbrt(z**5)/z**Rational(5, 3))*airyai(2*cbrt(3)*z**Rational(5, 3))/2 +
        (1 + cbrt(z**5)/z**Rational(5, 3))*airybi(2*cbrt(3)*z**Rational(5, 3))/2)
    assert expand_func(airybi(x*y)) == airybi(x*y)
    assert expand_func(airybi(log(x))) == airybi(log(x))
    assert expand_func(airybi(2*root(3*z**5, 5))) == airybi(2*root(3*z**5, 5))

    assert airybi(x).taylor_term(-1, x) == 0
Beispiel #11
0
def test_airybiprime():
    z = Symbol('z', extended_real=False)
    t = Symbol('t', negative=True)
    p = Symbol('p', positive=True)

    assert isinstance(airybiprime(z), airybiprime)

    assert airybiprime(0) == root(3, 6)/gamma(Rational(1, 3))
    assert airybiprime(oo) == oo
    assert airybiprime(-oo) == 0

    assert diff(airybiprime(z), z) == z*airybi(z)

    assert series(airybiprime(z), z, 0, 3) == (
        root(3, 6)/gamma(Rational(1, 3)) + 3**Rational(5, 6)*z**2/(6*gamma(Rational(2, 3))) + O(z**3))

    assert airybiprime(z).rewrite(hyper) == (
        3**Rational(5, 6)*z**2*hyper((), (Rational(5, 3),), z**3/9)/(6*gamma(Rational(2, 3))) +
        root(3, 6)*hyper((), (Rational(1, 3),), z**3/9)/gamma(Rational(1, 3)))

    assert isinstance(airybiprime(z).rewrite(besselj), airybiprime)
    assert (airybiprime(t).rewrite(besselj) ==
            -sqrt(3)*t*(besselj(-Rational(2, 3), 2*(-t)**Rational(3, 2)/3) +
                        besselj(Rational(2, 3), 2*(-t)**Rational(3, 2)/3))/3)
    assert airybiprime(z).rewrite(besseli) == (
        sqrt(3)*(z**2*besseli(Rational(2, 3), 2*z**Rational(3, 2)/3)/(z**Rational(3, 2))**Rational(2, 3) +
                 (z**Rational(3, 2))**Rational(2, 3)*besseli(-Rational(2, 3), 2*z**Rational(3, 2)/3))/3)
    assert airybiprime(p).rewrite(besseli) == (
        sqrt(3)*p*(besseli(-Rational(2, 3), 2*p**Rational(3, 2)/3) + besseli(Rational(2, 3), 2*p**Rational(3, 2)/3))/3)
    assert airybiprime(p).rewrite(besselj) == airybiprime(p)

    assert expand_func(airybiprime(2*cbrt(3*z**5))) == (
        sqrt(3)*(z**Rational(5, 3)/cbrt(z**5) - 1)*airyaiprime(2*cbrt(3)*z**Rational(5, 3))/2 +
        (z**Rational(5, 3)/cbrt(z**5) + 1)*airybiprime(2*cbrt(3)*z**Rational(5, 3))/2)
    assert expand_func(airybiprime(x*y)) == airybiprime(x*y)
    assert expand_func(airybiprime(log(x))) == airybiprime(log(x))
    assert expand_func(airybiprime(2*root(3*z**5, 5))) == airybiprime(2*root(3*z**5, 5))

    assert airybiprime(-2).evalf(50) == Float('0.27879516692116952268509756941098324140300059345163131', dps=50)
Beispiel #12
0
def test_airyaiprime():
    z = Symbol('z', extended_real=False)
    t = Symbol('t', negative=True)
    p = Symbol('p', positive=True)

    assert isinstance(airyaiprime(z), airyaiprime)

    assert airyaiprime(0) == -3**Rational(2, 3)/(3*gamma(Rational(1, 3)))
    assert airyaiprime(oo) == 0

    assert diff(airyaiprime(z), z) == z*airyai(z)

    assert series(airyaiprime(z), z, 0, 3) == (
        -3**Rational(2, 3)/(3*gamma(Rational(1, 3))) + cbrt(3)*z**2/(6*gamma(Rational(2, 3))) + O(z**3))

    assert airyaiprime(z).rewrite(hyper) == (
        cbrt(3)*z**2*hyper((), (Rational(5, 3),), z**3/9)/(6*gamma(Rational(2, 3))) -
        3**Rational(2, 3)*hyper((), (Rational(1, 3),), z**3/9)/(3*gamma(Rational(1, 3))))

    assert isinstance(airyaiprime(z).rewrite(besselj), airyaiprime)
    assert (airyaiprime(t).rewrite(besselj) ==
            t*(besselj(-Rational(2, 3), 2*(-t)**Rational(3, 2)/3) -
               besselj(Rational(2, 3), 2*(-t)**Rational(3, 2)/3))/3)
    assert airyaiprime(z).rewrite(besseli) == (
        z**2*besseli(Rational(2, 3), 2*z**Rational(3, 2)/3)/(3*(z**Rational(3, 2))**Rational(2, 3)) -
        (z**Rational(3, 2))**Rational(2, 3)*besseli(-Rational(1, 3), 2*z**Rational(3, 2)/3)/3)
    assert airyaiprime(p).rewrite(besseli) == (
        p*(-besseli(-Rational(2, 3), 2*p**Rational(3, 2)/3) + besseli(Rational(2, 3), 2*p**Rational(3, 2)/3))/3)
    assert airyaiprime(p).rewrite(besselj) == airyaiprime(p)

    assert expand_func(airyaiprime(2*cbrt(3*z**5))) == (
        sqrt(3)*(z**Rational(5, 3)/cbrt(z**5) - 1)*airybiprime(2*cbrt(3)*z**Rational(5, 3))/6 +
        (z**Rational(5, 3)/cbrt(z**5) + 1)*airyaiprime(2*cbrt(3)*z**Rational(5, 3))/2)
    assert expand_func(airyaiprime(x*y)) == airyaiprime(x*y)
    assert expand_func(airyaiprime(log(x))) == airyaiprime(log(x))
    assert expand_func(airyaiprime(2*root(3*z**5, 5))) == airyaiprime(2*root(3*z**5, 5))

    assert airyaiprime(-2).evalf(50) == Float('0.61825902074169104140626429133247528291577794512414753', dps=50)
Beispiel #13
0
def test_issue_7203():
    assert series(cos(x), x, pi, 3) == \
        -1 + (x - pi)**2/2 + O((x - pi)**3, (x, pi))
Beispiel #14
0
def test_airyai():
    z = Symbol('z', extended_real=False)
    r = Symbol('r', extended_real=True)
    t = Symbol('t', negative=True)
    p = Symbol('p', positive=True)

    assert isinstance(airyai(z), airyai)

    assert airyai(0) == cbrt(3) / (3 * gamma(Rational(2, 3)))
    assert airyai(oo) == 0
    assert airyai(-oo) == 0

    assert diff(airyai(z), z) == airyaiprime(z)

    assert series(airyai(z), z, 0,
                  3) == (3**Rational(5, 6) * gamma(Rational(1, 3)) / (6 * pi) -
                         root(3, 6) * z * gamma(Rational(2, 3)) / (2 * pi) +
                         O(z**3))

    l = Limit(
        airyai(I / x) /
        (exp(-Rational(2, 3) *
             (I / x)**Rational(3, 2)) * sqrt(pi * sqrt(I / x)) / 2), x, 0)
    assert l.doit() == l  # cover _airyais._eval_aseries

    assert airyai(z).rewrite(hyper) == (-3**Rational(2, 3) * z * hyper(
        (), (Rational(4, 3), ), z**3 / 9) / (3 * gamma(Rational(1, 3))) +
                                        cbrt(3) * hyper(
                                            (), (Rational(2, 3), ), z**3 / 9) /
                                        (3 * gamma(Rational(2, 3))))

    assert isinstance(airyai(z).rewrite(besselj), airyai)
    assert airyai(t).rewrite(besselj) == (
        sqrt(-t) * (besselj(-Rational(1, 3), 2 * (-t)**Rational(3, 2) / 3) +
                    besselj(Rational(1, 3), 2 * (-t)**Rational(3, 2) / 3)) / 3)
    assert airyai(z).rewrite(besseli) == (
        -z * besseli(Rational(1, 3), 2 * z**Rational(3, 2) / 3) /
        (3 * cbrt(z**Rational(3, 2))) + cbrt(z**Rational(3, 2)) *
        besseli(-Rational(1, 3), 2 * z**Rational(3, 2) / 3) / 3)
    assert airyai(p).rewrite(besseli) == (
        sqrt(p) * (besseli(-Rational(1, 3), 2 * p**Rational(3, 2) / 3) -
                   besseli(Rational(1, 3), 2 * p**Rational(3, 2) / 3)) / 3)

    assert expand_func(airyai(
        2 *
        cbrt(3 * z**5))) == (-sqrt(3) * (-1 + cbrt(z**5) / z**Rational(5, 3)) *
                             airybi(2 * cbrt(3) * z**Rational(5, 3)) / 6 +
                             (1 + cbrt(z**5) / z**Rational(5, 3)) *
                             airyai(2 * cbrt(3) * z**Rational(5, 3)) / 2)
    assert expand_func(airyai(x * y)) == airyai(x * y)
    assert expand_func(airyai(log(x))) == airyai(log(x))
    assert expand_func(airyai(2 * root(3 * z**5, 5))) == airyai(
        2 * root(3 * z**5, 5))

    assert (airyai(r).as_real_imag() == airyai(r).as_real_imag(deep=False) ==
            (airyai(r), 0))
    assert airyai(x).as_real_imag() == airyai(x).as_real_imag(deep=False)
    assert (airyai(x).as_real_imag() == (
        airyai(re(x) - I * re(x) * abs(im(x)) / abs(re(x))) / 2 +
        airyai(re(x) + I * re(x) * abs(im(x)) / abs(re(x))) / 2,
        I * (airyai(re(x) - I * re(x) * abs(im(x)) / abs(re(x))) -
             airyai(re(x) + I * re(x) * abs(im(x)) / Abs(re(x)))) * re(x) *
        abs(im(x)) / (2 * im(x) * abs(re(x)))))

    assert airyai(x).taylor_term(-1, x) == 0
Beispiel #15
0
def test_sin():
    e1 = sin(x).series(x, 0)
    e2 = series(sin(x), x, 0)
    assert e1 == e2
Beispiel #16
0
def test_csc():
    x = symbols('x', extended_real=True)
    z = symbols('z')

    # https://github.com/sympy/sympy/issues/6707
    cosecant = csc('x')
    alternate = 1/sin('x')
    assert cosecant.equals(alternate)
    assert alternate.equals(cosecant)

    assert csc.nargs == FiniteSet(1)

    assert csc(0) == zoo
    assert csc(pi) == zoo

    assert csc(pi/2) == 1
    assert csc(-pi/2) == -1
    assert csc(pi/6) == 2
    assert csc(pi/3) == 2*sqrt(3)/3
    assert csc(5*pi/2) == 1
    assert csc(9*pi/7) == -csc(2*pi/7)
    assert csc(3*pi/4) == sqrt(2)  # issue sympy/sympy#8421
    assert csc(I) == -I*csch(1)
    assert csc(x*I) == -I*csch(x)
    assert csc(-x) == -csc(x)

    assert csc(acsc(x)) == x

    assert csc(x).rewrite(exp) == 2*I/(exp(I*x) - exp(-I*x))
    assert csc(x).rewrite(sin) == 1/sin(x)
    assert csc(x).rewrite(cos) == csc(x)
    assert csc(x).rewrite(tan) == (tan(x/2)**2 + 1)/(2*tan(x/2))
    assert csc(x).rewrite(cot) == (cot(x/2)**2 + 1)/(2*cot(x/2))

    assert csc(z).conjugate() == csc(conjugate(z))

    assert (csc(z).as_real_imag() ==
            (sin(re(z))*cosh(im(z))/(sin(re(z))**2*cosh(im(z))**2 +
                                     cos(re(z))**2*sinh(im(z))**2),
             -cos(re(z))*sinh(im(z))/(sin(re(z))**2*cosh(im(z))**2 +
                                      cos(re(z))**2*sinh(im(z))**2)))

    assert csc(x).expand(trig=True) == 1/sin(x)
    assert csc(2*x).expand(trig=True) == 1/(2*sin(x)*cos(x))

    assert csc(a).is_algebraic is None
    assert csc(na).is_algebraic is False

    assert csc(x).as_leading_term() == csc(x)

    assert csc(0).is_finite is False
    assert csc(x).is_finite is None
    assert csc(pi/2).is_finite

    assert series(csc(x), x, x0=pi/2, n=6) == \
        1 + (x - pi/2)**2/2 + 5*(x - pi/2)**4/24 + O((x - pi/2)**6, (x, pi/2))
    assert series(csc(x), x, x0=0, n=6) == \
        1/x + x/6 + 7*x**3/360 + 31*x**5/15120 + O(x**6)

    assert csc(x).diff(x) == -cot(x)*csc(x)

    assert csc(x).taylor_term(0, x) == 1/x
    assert csc(x).taylor_term(2, x) == 0
    assert csc(x).taylor_term(3, x) == 7*x**3/360
    assert csc(x).taylor_term(5, x) == 31*x**5/15120

    pytest.raises(ArgumentIndexError, lambda: csc(x).fdiff(2))
Beispiel #17
0
def test_exp2():
    e1 = exp(cos(x)).series(x, 0)
    e2 = series(exp(cos(x)), x, 0)
    assert e1 == e2
Beispiel #18
0
def test_sympyissue_15539():
    assert series(exp(x), x, x0=-oo) == exp(-x)
Beispiel #19
0
def test_sympyissue_8805():
    assert series(1, n=8) == 1
Beispiel #20
0
def test_sympyissue_7203():
    assert series(cos(x), x, pi, 3) == \
        -1 + (x - pi)**2/2 + O((x - pi)**3, (x, pi))
Beispiel #21
0
def test_sympyissue_5852():
    assert series(1/cos(x/log(x)), x, 0) == 1 + x**2/(2*log(x)**2) + \
        5*x**4/(24*log(x)**4) + O(x**6)
Beispiel #22
0
def test_issue_5852():
    assert series(1/cos(x/log(x)), x, 0) == 1 + x**2/(2*log(x)**2) + \
        5*x**4/(24*log(x)**4) + O(x**6)
Beispiel #23
0
def test_sympyissue_15539():
    assert series(exp(x), x, x0=-oo) == exp(-x)
Beispiel #24
0
def test_exp_product_positive_factors():
    a, b = symbols('a, b', positive=True)
    x = a * b
    series(exp(x), x, n=8)
Beispiel #25
0
def test_sin():
    e1 = sin(x).series(x, 0)
    e2 = series(sin(x), x, 0)
    assert e1 == e2
Beispiel #26
0
def test_exp_product_positive_factors():
    a, b = symbols('a, b', positive=True)
    x = a * b
    assert series(exp(x), x, n=8) == 1 + a*b + a**2*b**2/2 + \
        a**3*b**3/6 + a**4*b**4/24 + a**5*b**5/120 + a**6*b**6/720 + \
        a**7*b**7/5040 + O(a**8*b**8)
Beispiel #27
0
def test_exp_product_positive_factors():
    a, b = symbols('a, b', positive=True)
    x = a * b
    series(exp(x), x, n=8)
Beispiel #28
0
def test_issue_8805():
    assert series(1, n=8) == 1
Beispiel #29
0
def test_cos():
    e1 = cos(x).series(x, 0)
    e2 = series(cos(x), x, 0)
    assert e1 == e2
Beispiel #30
0
def test_cos():
    e1 = cos(x).series(x, 0)
    e2 = series(cos(x), x, 0)
    assert e1 == e2
Beispiel #31
0
def test_exp():
    e1 = exp(x).series(x, 0)
    e2 = series(exp(x), x, 0)
    assert e1 == e2
Beispiel #32
0
def test_exp():
    e1 = exp(x).series(x, 0)
    e2 = series(exp(x), x, 0)
    assert e1 == e2
Beispiel #33
0
def test_exp2():
    e1 = exp(cos(x)).series(x, 0)
    e2 = series(exp(cos(x)), x, 0)
    assert e1 == e2
Beispiel #34
0
def test_sec():
    x = symbols('x', extended_real=True)
    z = symbols('z')

    assert sec.nargs == FiniteSet(1)

    assert sec(0) == 1
    assert sec(pi) == -1
    assert sec(pi/2) == zoo
    assert sec(-pi/2) == zoo
    assert sec(pi/6) == 2*sqrt(3)/3
    assert sec(pi/3) == 2
    assert sec(5*pi/2) == zoo
    assert sec(9*pi/7) == -sec(2*pi/7)
    assert sec(3*pi/4) == -sqrt(2)  # issue sympy/sympy#8421
    assert sec(I) == sech(1)
    assert sec(x*I) == sech(x)
    assert sec(-x) == sec(x)

    assert sec(asec(x)) == x

    assert sec(x).rewrite(exp) == 1/(exp(I*x)/2 + exp(-I*x)/2)
    assert sec(x).rewrite(sin) == sec(x)
    assert sec(x).rewrite(cos) == 1/cos(x)
    assert sec(x).rewrite(tan) == (tan(x/2)**2 + 1)/(-tan(x/2)**2 + 1)
    assert sec(x).rewrite(sqrt) == sec(x)
    assert sec(z).rewrite(cot) == (cot(z/2)**2 + 1)/(cot(z/2)**2 - 1)

    assert sec(z).conjugate() == sec(conjugate(z))

    assert (sec(z).as_real_imag() ==
            (cos(re(z))*cosh(im(z))/(sin(re(z))**2*sinh(im(z))**2 +
                                     cos(re(z))**2*cosh(im(z))**2),
             sin(re(z))*sinh(im(z))/(sin(re(z))**2*sinh(im(z))**2 +
                                     cos(re(z))**2*cosh(im(z))**2)))

    assert sec(x).expand(trig=True) == 1/cos(x)
    assert sec(2*x).expand(trig=True) == 1/(2*cos(x)**2 - 1)

    assert sec(a).is_algebraic is None
    assert sec(na).is_algebraic is False

    assert sec(x).as_leading_term() == sec(x)

    assert sec(0).is_finite
    assert sec(x).is_finite is None
    assert sec(pi/2).is_finite is False

    assert series(sec(x), x, x0=0, n=6) == 1 + x**2/2 + 5*x**4/24 + O(x**6)

    # https://github.com/sympy/sympy/issues/7166
    assert series(sqrt(sec(x))) == 1 + x**2/4 + 7*x**4/96 + O(x**6)

    # https://github.com/sympy/sympy/issues/7167
    assert (series(sqrt(sec(x)), x, x0=pi*3/2, n=4) ==
            1/sqrt(x - 3*pi/2) + (x - 3*pi/2)**Rational(3, 2)/12 +
            (x - 3*pi/2)**Rational(7, 2)/160 + O((x - 3*pi/2)**4, (x, 3*pi/2)))

    assert sec(x).diff(x) == tan(x)*sec(x)

    # Taylor Term checks
    assert sec(z).taylor_term(4, z) == 5*z**4/24
    assert sec(z).taylor_term(6, z) == 61*z**6/720
    assert sec(z).taylor_term(5, z) == 0

    pytest.raises(ArgumentIndexError, lambda: sec(x).fdiff(2))