Integral no espaço de log-log

Estou trabalhando com funções que, em geral, são muito mais suaves e se comportam melhor no espaço de log-log - então é aí que eu executo interpolação / extrapolação, etc., e isso funciona muito bem. Existe uma maneira de integrar essas funções numéricas no espaço de log-log?

ou seja, espero usar algum tipo de regra trapezoidal simples para executar uma integral cumulativa (por exemplo, em python, use scipy.integrate.cumtrapz), para encontrar algumas $F(r)$ st

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

Mas espero usar os valores $log(y)$ e $log(x)$ , em vez de $y$ e $x$ (quando possível).

Você pode apenas mudar variáveis. Definindo $a=log(x)$ , $b(a)=log(y(x))$ . A integral se torna

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

Você precisa ter um pouco de cuidado porque está se integrando a partir de $-\infty$ . O que você precisa fazer exatamente dependerá da aparência de $y(x)$ .

Não uso python, mas se eu entendi corretamente, em seguida, por você está pensando algo como F = i n t e g r a t e ( y , x ) , onde F = [ F 1 , . . . , F n ] é um vetor amostrando a integral sobre uma grade

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

No entanto você não tem amostras de e y , mas você tem amostras de x = log ( x ) e y = log ( $x$$y$$\hat{x}=\log(x)$ .$\hat{y}=\log(y)$

Claro que a abordagem mais simples seria mas este seria propensa a erros, porque y ( x ) não é lisa, mesmo embora y ( x ) é.

$$\mathbf{F}=\mathrm{integrate}(\exp(\mathbf{\hat{y}}),\exp(\mathbf{\hat{x}})) ,$$ $y(x)$$\hat{y}(\hat{x})$

Agora, a regra trapezoidal pressupõe essencialmente que sua entrada é linear por partes. Portanto, a generalização simples seria para você assumir que y ( x ) é linear por partes.$y(x)$$\hat{y}(\hat{x})$

Neste caso, definindo , tem Δ F k = ∫ x k + 1 x k y ( x ) d x = ∫ x k + 1 x k e y$\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}$$

Em seguida, definindo , tem y k + t ≈ y k + t Δ y k e ~ y ( t ) ≈ um e b t , com um = e Y K + x k e $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$

Assim, torna-se o integral

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

No Matlab, isso seria algo como

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]);

Espero que isto ajude!

$y(x)$$\hat{y}(\hat{x})$$\mathbf{\hat{x}}$$F(\hat{x}_1)=0$

Se a função parecer suave em um gráfico de log-log, você poderá interpolar usando uma lei de energia em cada intervalo (as leis de energia são, é claro, lineares no log-log). Assim, entre pontos$(x_i, y_i)$ e $(x_{i+1}, y_{i+1})$ sob a suposição de que $y = C_i x^{n_i}$ dentro do intervalo $i$, você obtém $n_i = \ln(y_i/y_{i+1})/\ln(x_i/x_{i+1})$ e $C_i = \ln(y_i) - n_i\ln(x_i)$. A contribuição para a integral do intervalo$i$ é então

$$\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.$$ onde você obviamente precisa de alguma tolerância para identificar o caso especial $n_i=-1$ na sua implementação.

Eu acho que há um pouco de confusão com a mudança de variáveis ​​em algumas das respostas anteriores, bem como em alguns erros. A integral de uma função de log não é o log da integral. Em geral, acho difícil escrever a integral de uma função que conhece a integral de seu log. Se alguém souber como fazer isso, eu estaria interessado.

Enquanto isso, a solução do @ Stefan acima é a maneira de contornar a integração de uma função no espaço de log-log. O ponto de partida é que a função que você está executando é linear no espaço de log-log para segmentos pequenos o suficiente.

Pode-se então escrever a equação da linha nos pontos finais do segmento:

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

Onde $m_1$ é a inclinação da linha e $n_1$ é o seu intercepto-y.

Subtraindo os dois, pode-se encontrar:

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

e de substituição:

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

Se no espaço log-log a equação de um segmento estiver próxima de uma linha, no espaço normal (linear) a equação do segmento estará próxima de um exponencial:

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

Se temos uma formulação analítica para esse segmento, é fácil integrar:

$$\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$$

e

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

Isso parece um pouco de trapaça, mas é uma amostra no espaço de log-log, de modo que podemos aproximar a função no espaço linear a um exponencial com parâmetros derivados do espaço de log-log.

A solução que eu uso é basicamente uma implementação da regra do trapézio e faz uso da scipy.misc.logsumexpfunção para manter a precisão. Se você tem alguma função lnyque retorna o logaritmo de, yentão você pode fazer, por exemplo:

de scipy.misc import logsumexp
importar numpy como np

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

# obtém valores de x espaçados logaritmicamente
xvs = np.logspace (np.log10 (xmin), np.log10 (xmax), 10000)

# avalie sua função em xvs
lys = lny (xvs)

# executar integração de regra de trapézio
deltas = np.log (np.diff (xvs))
logI = -np.log (2.) + logsumexp ([logsumexp (lys [: - 1] + deltas), logsumexp (lys [1:] + deltas)])

O valor logIé o log da integral que você deseja.

Obviamente, isso não funcionará se você precisar definir xmin = 0. Mas, se você tem um limite inferior positivo diferente de zero para a integral, pode apenas brincar com o número de pontos xvspara encontrar um número para o qual a integral converge.