Интеграл в пространстве журнала

Я работаю с функциями, которые, в общем, гораздо более плавные и лучше ведут себя в пространстве журналов регистрации - так что именно здесь я выполняю интерполяцию / экстраполяцию и т. Д., И это работает очень хорошо. Есть ли способ интегрировать эти числовые функции в пространстве журнала?

т.е. я надеюсь использовать какое-то простое трапециевидное правило для выполнения кумулятивного интеграла (например, в python, use scipy.integrate.cumtrapz), чтобы найти некоторый st$F(r)$

$$F(r) = \int_0^r y(x) \, dx$$

Но я надеюсь использовать значения и вместо и (когда это возможно).$log(y)$$log(x)$$y$$x$

Вы можете просто изменить переменные. Установка , . Интеграл становится$a=log(x)$$b(a)=log(y(x))$

$F(r)=\int^{log(r)}_{-\infty} exp(a+b) da$

Вы должны быть немного осторожнее, потому что вы интегрируете из . Что именно вы должны сделать, будет зависеть от того, как выглядит .$-\infty$$y(x)$

Я не использую python, но если я правильно понимаю, то с помощью вы думаете о чем-то вроде где - вектор, в котором выполняется выборка интеграла по сетке .

$$F(r)=\int_0^ry(x)dx$$ $$\mathbf{F}=\mathrm{integrate}(\mathbf{y},\mathbf{x})$$ $\mathbf{F}=[F_1,...,F_n]$$\mathbf{x}$

Однако у вас нет образцов и , а есть образцы и .$x$$y$$\hat{x}=\log(x)$$\hat{y}=\log(y)$

Конечно, самый простой подход будет

$$\mathbf{F}=\mathrm{integrate}(\exp(\mathbf{\hat{y}}),\exp(\mathbf{\hat{x}})) ,$$ но это было бы подвержено ошибкам, потому что $y(x)$ не гладко, хотя $\hat{y}(\hat{x})$ является.

Теперь трапециевидное правило по существу предполагает ваш вклад$y(x)$кусочно-линейный Таким образом, простое обобщение будет для вас предположить, что$\hat{y}(\hat{x})$ кусочно-линейный

В этом случае, определяя $\Delta F_k=F_{k+1}-F_k$, у тебя есть

$$\Delta F_k=\int_{x_k}^{x_{k+1}}y(x)dx =\int_{\hat{x}_k}^{\hat{x}_{k+1}}e^{\hat{y}(\hat{x})}e^\hat{x}d\hat{x} =\int_{\hat{x}_k}^{\hat{x}_{k+1}}\tilde{y}(\hat{x})d\hat{x}$$

Затем, определяя $t=(\hat{x}-\hat{x}_k)/\Delta \hat{x}_k$, у тебя есть

$$\hat{y}_{k+t} \approx \hat{y}_k + t \Delta \hat{y}_k$$ а также $\tilde{y}(t) \approx a e^{bt}$, с $a=e^{\hat{y}_k+\hat{x}_k}$ а также $b=\Delta \hat{y}_k+\Delta \hat{x}_k$,

Таким образом, интеграл становится

$$\Delta F_k \approx a \Delta \hat{x} \int_0^1e^{bt}dt = a \Delta \hat{x} \frac{e^b-1}{b}$$

В Matlab это будет выглядеть примерно так

dlogx=diff(logx); dlogy=diff(logy); k=1:length(logx)-1;  
b=dlogx+dlogy; a=exp(logx+logy);  
dF=a(k).*dlogx.*(exp(b)-1)./b;  
F=cumsum([0,dF]);

Надеюсь это поможет!

(Редактировать: мой ответ по сути такой же, как и гораздо более краткий ответ, который Дамаск Сталь дал, когда я печатал. Единственное отличие состоит в том, что я пытался дать конкретное решение для случая, когда «конкретный $y(x)$"кусочно-линейный $\hat{y}(\hat{x})$ дискретизирован по дискретному $\mathbf{\hat{x}}$ сетка, с $F(\hat{x}_1)=0$.)

Если функция выглядит гладко на графике log-log, вы можете интерполировать, используя степенной закон на каждом интервале (степенные законы, конечно, линейны в log-log). Таким образом, между точками$(x_i, y_i)$ а также $(x_{i+1}, y_{i+1})$ при условии, что $y = C_i x^{n_i}$ в пределах интервала $i$, вы получаете $n_i = \ln(y_i/y_{i+1})/\ln(x_i/x_{i+1})$ а также $C_i = \ln(y_i) - n_i\ln(x_i)$, Вклад в интеграл от интервала$i$ затем

$$\Delta F_i = \int_{x_i}^{x_{i+1}} C_i x^{n_i}dx = \left\{ \begin{array}{l@{\quad}l} \frac{C_i}{n_i + 1} (x_{i+1}^{n_i+1} - x_i^{n_i+1}), & n_i \neq -1 \\ C_i(\ln x_{i+1} - \ln x_i), & n_i=-1, \end{array} \right.$$ где вам, очевидно, нужна некоторая терпимость для выявления особого случая $n_i=-1$ в вашей реализации.

Я думаю, что есть некоторая путаница с изменением переменных в некоторых из предыдущих ответов, а также с некоторыми ошибками. Интеграл лог-функции - это не лог интеграла. Я думаю, что в целом сложно выписать интеграл функции, зная интеграл ее логарифма. Если кто-нибудь знает, как это сделать, мне было бы интересно.

Между тем, решение @ Stefan, представленное выше, является способом обойти интеграцию функции в пространстве log-log. Отправной точкой является то, что функция, с которой вы работаете, является линейной в пространстве log-log для достаточно маленьких сегментов.

Затем можно написать уравнение линии в конечных точках сегмента:

$$\log(y_1)=m_1 \log(x_1) + n_1$$ $$\log(y_2)=m_1 \log(x_1) + n_1$$

где $m_1$ это наклон линии и $n_1$ это у-перехват.

Вычитая два, можно найти:

$$m_1=\frac{\log(y_1) -log(y_2)}{\log(x_1)-log(x_2)}$$

and from substitution:

$$n_1=\log(y_1)-m_1 \log(x_1)$$

If in the log-log space the equation of a segment is close to a line then in normal (linear) space the equation of the segment is close to an exponential:

$$y(x)\simeq x^{m} e^{n}$$

If we have a analytical formulation for this segment it is easy to integrate:

$$\int_{x_1}^{x_2}y(x)dx = \frac{e^{n_1}}{m_1+1}(x_2^{m_1+1}-x_1^{m_1+1}), \,\, \text{for } \, m\neq -1$$

and

$$\int_{x_1}^{x_2}y(x)dx = e^{n_1} \log \frac{x_2}{x_1},\, \,\text{for } \, m = -1$$

This feels a bit like cheating, but this is sampling in log-log space such that we can approximate the function in the linear space to an exponential with parameters derived from the log-log space.

Решение, которое я использую, является в основном реализацией правила трапеции и использует scipy.misc.logsumexpфункцию для поддержания точности. Если у вас есть какая-то функция, lnyкоторая возвращает логарифм, yвы можете сделать, например:

из scipy.misc импорт logsumexp
импортировать numpy как np

xmin = 1e-15
xmax = 1e-5

# получить значения х логарифмически
xvs = np.logspace (np.log10 (xmin), np.log10 (xmax), 10000)

# оцените свою функцию на xvs
lys = lny (xvs)

# выполнить интеграцию правила трапеции
deltas = np.log (np.diff (xvs))
logI = -np.log (2.) + logsumexp ([logsumexp (lys [: - 1] + deltas), logsumexp (lys [1:] + deltas)])

Значение logI- это журнал интеграла, который вы хотите.

Очевидно, это не будет работать, если вам нужно установить xmin = 0. Но если у вас есть некоторый ненулевой положительный нижний предел для интеграла, вы можете просто поиграть с количеством точек, xvsчтобы найти число, где интеграл сходится.