Python transforms.laplace_transform函数代码示例

def test_issue_7173():
    assert laplace_transform(sinh(a*x)*cosh(a*x), x, s) == \
        (a/(s**2 - 4*a**2), 0,
        And(Or(Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <
        pi/2, Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)) <=
        pi/2), Or(Abs(periodic_argument(a, oo)) < pi/2,
        Abs(periodic_argument(a, oo)) <= pi/2)))

def test_undefined_function():
    from sympy import Function, MellinTransform
    f = Function('f')
    assert mellin_transform(f(x), x, s) == MellinTransform(f(x), x, s)
    assert mellin_transform(f(x) + exp(-x), x, s) == \
        (MellinTransform(f(x), x, s) + gamma(s), (0, oo), True)

    assert laplace_transform(2*f(x), x, s) == 2*LaplaceTransform(f(x), x, s)

def test_expint():
    from sympy import E1, expint, Max, re, lerchphi, Symbol, simplify, Si, Ci, Ei

    aneg = Symbol("a", negative=True)
    u = Symbol("u", polar=True)

    assert mellin_transform(E1(x), x, s) == (gamma(s) / s, (0, oo), True)
    assert inverse_mellin_transform(gamma(s) / s, s, x, (0, oo)).rewrite(expint).expand() == E1(x)
    assert mellin_transform(expint(a, x), x, s) == (gamma(s) / (a + s - 1), (Max(1 - re(a), 0), oo), True)
    # XXX IMT has hickups with complicated strips ...
    assert simplify(
        unpolarify(
            inverse_mellin_transform(gamma(s) / (aneg + s - 1), s, x, (1 - aneg, oo)).rewrite(expint).expand(func=True)
        )
    ) == expint(aneg, x)

    assert mellin_transform(Si(x), x, s) == (
        -2 ** s * sqrt(pi) * gamma(s / 2 + S(1) / 2) / (2 * s * gamma(-s / 2 + 1)),
        (-1, 0),
        True,
    )
    assert inverse_mellin_transform(
        -2 ** s * sqrt(pi) * gamma((s + 1) / 2) / (2 * s * gamma(-s / 2 + 1)), s, x, (-1, 0)
    ) == Si(x)

    assert mellin_transform(Ci(sqrt(x)), x, s) == (
        -2 ** (2 * s - 1) * sqrt(pi) * gamma(s) / (s * gamma(-s + S(1) / 2)),
        (0, 1),
        True,
    )
    assert inverse_mellin_transform(
        -4 ** s * sqrt(pi) * gamma(s) / (2 * s * gamma(-s + S(1) / 2)), s, u, (0, 1)
    ).expand() == Ci(sqrt(u))

    # TODO LT of Si, Shi, Chi is a mess ...
    assert laplace_transform(Ci(x), x, s) == (-log(1 + s ** 2) / 2 / s, 0, True)
    assert laplace_transform(expint(a, x), x, s) == (lerchphi(s * polar_lift(-1), 1, a), 0, S(0) < re(a))
    assert laplace_transform(expint(1, x), x, s) == (log(s + 1) / s, 0, True)
    assert laplace_transform(expint(2, x), x, s) == ((s - log(s + 1)) / s ** 2, 0, True)

    assert inverse_laplace_transform(-log(1 + s ** 2) / 2 / s, s, u).expand() == Heaviside(u) * Ci(u)
    assert inverse_laplace_transform(log(s + 1) / s, s, x).rewrite(expint) == Heaviside(x) * E1(x)
    assert (
        inverse_laplace_transform((s - log(s + 1)) / s ** 2, s, x).rewrite(expint).expand()
        == (expint(2, x) * Heaviside(x)).rewrite(Ei).rewrite(expint).expand()
    )

def test_laplace_transform():
    LT = laplace_transform
    a, b, c, = symbols('a b c', positive=True)
    t = symbols('t')
    w = Symbol("w")
    f = Function("f")

    # Test unevaluated form
    assert laplace_transform(f(t), t, w) == LaplaceTransform(f(t), t, w)
    assert inverse_laplace_transform(f(w), w, t, plane=0) == InverseLaplaceTransform(f(w), w, t, 0)

    # test a bug
    spos = symbols('s', positive=True)
    assert LT(exp(t), t, spos)[:2] == (1/(spos - 1), True)

    # basic tests from wikipedia

    assert LT((t-a)**b*exp(-c*(t-a))*Heaviside(t-a), t, s) \
           == ((s + c)**(-b - 1)*exp(-a*s)*gamma(b + 1), -c, True)
    assert LT(t**a, t, s) == (s**(-a - 1)*gamma(a + 1), 0, True)
    assert LT(Heaviside(t), t, s) == (1/s, 0, True)
    assert LT(Heaviside(t - a), t, s) == (exp(-a*s)/s, 0, True)
    assert LT(1 - exp(-a*t), t, s) == (a/(s*(a + s)), 0, True)

    assert LT((exp(2*t)-1)*exp(-b - t)*Heaviside(t)/2, t, s, noconds=True) \
           == exp(-b)/(s**2 - 1)

    assert LT(exp(t), t, s)[:2] == (1/(s-1), 1)
    assert LT(exp(2*t), t, s)[:2] == (1/(s-2), 2)
    assert LT(exp(a*t), t, s)[:2] == (1/(s-a), a)

    assert LT(log(t/a), t, s) == ((log(a) + log(s) + EulerGamma)/(-s), 0, True)

    assert LT(erf(t), t, s) == ((-erf(s/2) + 1)*exp(s**2/4)/s, 0, True)

    assert LT(sin(a*t), t, s) == (a/(a**2 + s**2), 0, True)
    assert LT(cos(a*t), t, s) == (s/(a**2 + s**2), 0, True)
    # TODO would be nice to have these come out better
    assert LT(exp(-a*t)*sin(b*t), t, s) == (1/b/(1 + (a + s)**2/b**2), -a, True)
    assert LT(exp(-a*t)*cos(b*t), t, s) == \
           (1/(s + a)/(1 + b**2/(a + s)**2), -a, True)
    # TODO sinh, cosh have delicate cancellation

    assert LT(besselj(0, t), t, s) == (1/sqrt(1 + s**2), 0, True)
    assert LT(besselj(1, t), t, s) == (1 - 1/sqrt(1 + 1/s**2), 0, True)
    # TODO general order works, but is a *mess*
    # TODO besseli also works, but is an even greater mess

    # test a bug in conditions processing
    # TODO the auxiliary condition should be recognised/simplified
    assert LT(exp(t)*cos(t), t, s)[:-1] in [
        ((s - 1)/(s**2 - 2*s + 2), -oo),
        ((s - 1)/((s - 1)**2 + 1), -oo),
        ]

def test_issue_7173():
    from sympy import cse
    x0, x1, x2 = symbols('x:3')
    ans = laplace_transform(sinh(a*x)*cosh(a*x), x, s)
    r, e = cse(ans)
    assert r == [
        (x0, pi/2),
        (x1, Abs(periodic_argument(a, oo))),
        (x2, Abs(periodic_argument(exp_polar(I*pi)*polar_lift(a), oo)))]
    assert e == [
        a/(-4*a**2 + s**2),
        0,
        ((x0 >= x1) | (x1 < x0)) & ((x0 >= x2) | (x2 < x0))]

def test_issue_7173():
    from sympy import cse
    x0, x1, x2, x3 = symbols('x:4')
    ans = laplace_transform(sinh(a*x)*cosh(a*x), x, s)
    r, e = cse(ans)
    assert r == [
        (x0, pi/2),
        (x1, arg(a)),
        (x2, Abs(x1)),
        (x3, Abs(x1 + pi))]
    assert e == [
        a/(-4*a**2 + s**2),
        0,
        ((x0 >= x2) | (x2 < x0)) & ((x0 >= x3) | (x3 < x0))]

def test_as_integral():
    from sympy import Function, Integral
    f = Function('f')
    assert mellin_transform(f(x), x, s).rewrite('Integral') == \
        Integral(x**(s - 1)*f(x), (x, 0, oo))
    assert fourier_transform(f(x), x, s).rewrite('Integral') == \
        Integral(f(x)*exp(-2*I*pi*s*x), (x, -oo, oo))
    assert laplace_transform(f(x), x, s).rewrite('Integral') == \
        Integral(f(x)*exp(-s*x), (x, 0, oo))
    assert str(inverse_mellin_transform(f(s), s, x, (a, b)).rewrite('Integral')) \
        == "Integral(x**(-s)*f(s), (s, _c - oo*I, _c + oo*I))"
    assert str(inverse_laplace_transform(f(s), s, x).rewrite('Integral')) == \
        "Integral(f(s)*exp(s*x), (s, _c - oo*I, _c + oo*I))"
    assert inverse_fourier_transform(f(s), s, x).rewrite('Integral') == \
        Integral(f(s)*exp(2*I*pi*s*x), (s, -oo, oo))

def test_laplace_transform():
    from sympy import fresnels, fresnelc

    LT = laplace_transform
    a, b, c, = symbols("a b c", positive=True)
    t = symbols("t")
    w = Symbol("w")
    f = Function("f")

    # Test unevaluated form
    assert laplace_transform(f(t), t, w) == LaplaceTransform(f(t), t, w)
    assert inverse_laplace_transform(f(w), w, t, plane=0) == InverseLaplaceTransform(f(w), w, t, 0)

    # test a bug
    spos = symbols("s", positive=True)
    assert LT(exp(t), t, spos)[:2] == (1 / (spos - 1), True)

    # basic tests from wikipedia

    assert LT((t - a) ** b * exp(-c * (t - a)) * Heaviside(t - a), t, s) == (
        (s + c) ** (-b - 1) * exp(-a * s) * gamma(b + 1),
        -c,
        True,
    )
    assert LT(t ** a, t, s) == (s ** (-a - 1) * gamma(a + 1), 0, True)
    assert LT(Heaviside(t), t, s) == (1 / s, 0, True)
    assert LT(Heaviside(t - a), t, s) == (exp(-a * s) / s, 0, True)
    assert LT(1 - exp(-a * t), t, s) == (a / (s * (a + s)), 0, True)

    assert LT((exp(2 * t) - 1) * exp(-b - t) * Heaviside(t) / 2, t, s, noconds=True) == exp(-b) / (s ** 2 - 1)

    assert LT(exp(t), t, s)[:2] == (1 / (s - 1), 1)
    assert LT(exp(2 * t), t, s)[:2] == (1 / (s - 2), 2)
    assert LT(exp(a * t), t, s)[:2] == (1 / (s - a), a)

    assert LT(log(t / a), t, s) == ((log(a * s) + EulerGamma) / s / -1, 0, True)

    assert LT(erf(t), t, s) == ((erfc(s / 2)) * exp(s ** 2 / 4) / s, 0, True)

    assert LT(sin(a * t), t, s) == (a / (a ** 2 + s ** 2), 0, True)
    assert LT(cos(a * t), t, s) == (s / (a ** 2 + s ** 2), 0, True)
    # TODO would be nice to have these come out better
    assert LT(exp(-a * t) * sin(b * t), t, s) == (b / (b ** 2 + (a + s) ** 2), -a, True)
    assert LT(exp(-a * t) * cos(b * t), t, s) == ((a + s) / (b ** 2 + (a + s) ** 2), -a, True)

    assert LT(besselj(0, t), t, s) == (1 / sqrt(1 + s ** 2), 0, True)
    assert LT(besselj(1, t), t, s) == (1 - 1 / sqrt(1 + 1 / s ** 2), 0, True)
    # TODO general order works, but is a *mess*
    # TODO besseli also works, but is an even greater mess

    # test a bug in conditions processing
    # TODO the auxiliary condition should be recognised/simplified
    assert LT(exp(t) * cos(t), t, s)[:-1] in [
        ((s - 1) / (s ** 2 - 2 * s + 2), -oo),
        ((s - 1) / ((s - 1) ** 2 + 1), -oo),
    ]

    # Fresnel functions
    assert laplace_transform(fresnels(t), t, s) == (
        (
            -sin(s ** 2 / (2 * pi)) * fresnels(s / pi)
            + sin(s ** 2 / (2 * pi)) / 2
            - cos(s ** 2 / (2 * pi)) * fresnelc(s / pi)
            + cos(s ** 2 / (2 * pi)) / 2
        )
        / s,
        0,
        True,
    )
    assert laplace_transform(fresnelc(t), t, s) == (
        (
            sin(s ** 2 / (2 * pi)) * fresnelc(s / pi) / s
            - cos(s ** 2 / (2 * pi)) * fresnels(s / pi) / s
            + sqrt(2) * cos(s ** 2 / (2 * pi) + pi / 4) / (2 * s),
            0,
            True,
        )
    )

    assert LT(Matrix([[exp(t), t * exp(-t)], [t * exp(-t), exp(t)]]), t, s) == Matrix(
        [[(1 / (s - 1), 1, True), ((s + 1) ** (-2), 0, True)], [((s + 1) ** (-2), 0, True), (1 / (s - 1), 1, True)]]
    )

def test_issue_14692():
    b = Symbol('b', negative=True)
    assert laplace_transform(1/(I*x - b), x, s) == \
        (-I*exp(I*b*s)*expint(1, b*s*exp_polar(I*pi/2)), 0, True)

# coding: utf-8
# 참고문헌: http://docs.sympy.org/dev/modules/integrals/integrals.html#sympy.integrals.transforms.laplace_transform
#   http://www.mathalino.com/reviewer/advance-engineering-mathematics/table-laplace-transforms-elementary-functions

import sympy as sp
from sympy.integrals.transforms import inverse_laplace_transform
from sympy.integrals.transforms import laplace_transform

t, s = sp.symbols('t s')
w = sp.Symbol('w', real=True)
a = sp.Symbol('a', real=True)
p = sp.Symbol('p', real=True)

y = a * sp.sin(w * t + p)
print("y = %s" % y)

Y = laplace_transform(y, t, s)
print("Y = %s" % str(Y))

yi = inverse_laplace_transform(Y[0], s, t)
print("yi = %s" % str(yi))