Преобразование Лапласа неизвестного интеграла (функция времени)

Question

Мне нужно вычислить преобразование Лапласа интегральной функции. Кажется, Симпи еще не в состоянии это понять.

Предполагая следующее:

from sympy import *
s, t = symbols('s t')
I = Function('I')(t)
eq1 = integrate(I, t)
transforms.laplace_transform(eq1, t, s)

Решение должно быть: I(s) / s

Однако Симпи дает: LaplaceTransform(Integral(I(t), t), t, s)

Кажется, это открытый вопрос, выпуск 7219. Есть ли работа вокруг?

Answer 1

Кажется, проблема еще не решена.

Тем не менее, мы можем дать "дерьмовый обходной путь", основанный на "дрянной реализации" Эрика Визера, приведенной для производных. Однако обратите внимание, что исходный фрагмент, похоже, не работает и для производных, поскольку внутреннее представление производных более высокого порядка, похоже, изменилось с момента публикации фрагмента.

Вот мой "дерьмовый" обходной путь, который ловит только самые простые случаи (производные только по отношению к tнеопределенные интегралы только по t, где t переменная, на которую действует преобразование Лапласа):

from sympy import *

def laplace(e, t, s):
    """Hacked-up Laplace transform that handles derivatives and integrals

    Updated generalization of https://github.com/sympy/sympy/issues/7219#issuecomment-154768904
    """

    res = laplace_transform(e, t, s, noconds=True)
    wf = Wild('f')
    lw = LaplaceTransform(wf, t, s)

    for exp in res.find(lw):
        e = exp.match(lw)[wf]
        args = e.args

        if isinstance(e, Derivative):
            # for derivative check that there's only d/dt^n with n>0
            if len(args) == 2 and args[1][0] == t:
                n = args[1][1]
                if n > 0:
                    newexp = s**n * LaplaceTransform(e.args[0], t, s)
                res = res.replace(exp, newexp)

        elif isinstance(e, Integral):
            # for integral check that there's only n consecutive indefinite integrals w.r.t. t
            if all(len(arg) == 1 and arg[0] == t for arg in args[1:]):
                newexp = s**(-len(args[1:])) * LaplaceTransform(args[0], t, s)
                res = res.replace(exp, newexp)

        # otherwise don't do anything

    return res

x = Function('x')
s,t = symbols('s t')
print(laplace(Derivative(x(t), t, 3), t, s))
print(laplace(Integral(Integral(x(t), t), t), t, s))

Вышеуказанные выводы

s**3*LaplaceTransform(x(t), t, s)
LaplaceTransform(x(t), t, s)/s**2

как и ожидалось. Используя ваш конкретный пример:

I = Function('I')(t)
eq1 = integrate(I, t)
LI = laplace(eq1, t, s)
print(LI)

мы получаем

LaplaceTransform(I(t), t, s)/s

что является правильным представлением "I(s)/s"что вы ожидали.

---

Способ обхода, описанный выше, заключается в том, что он соответствует аргументам LaplaceTransform и проверяет, есть ли чистый Derivative или же Integral внутри. За Derivative мы проверяем, что есть только дифференциация в отношении t; это то, что сделал оригинальный обходной путь Эрика, но в то время как его код, кажется, ожидал аргументы вида Derivative(x(t), t, t, t)текущее представление производных Derivative(x(t), (t,3)), Вот почему обработку этого варианта использования пришлось изменить.

Что касается Integrals, представление похоже на исходное: Integral(x(t), t, t) является двойным интегралом. Я все еще должен был настроить оригинал Эрика, потому что args этого выражения содержат кортежи для каждого интеграла, а не скаляр tдля того, чтобы разместить определенные интегралы. Поскольку мы хотим обрабатывать только случай неопределенных интегралов, я убедился, что есть только неопределенные интегралы и только в отношении t,

Если аргумент LaplaceTransform что-нибудь еще, выражение оставлено в покое.