Integriert in den Log-Log-Bereich

Ich arbeite mit Funktionen, die im Allgemeinen viel flüssiger sind und sich im Log-Log-Bereich besser verhalten - also führe ich dort Interpolation / Extrapolation usw. durch, und das funktioniert sehr gut. Gibt es eine Möglichkeit, diese numerischen Funktionen in den Log-Log-Bereich zu integrieren?

dh ich hoffe, eine einfache Trapezregel zu verwenden, um ein kumulatives Integral (z. B. in Python, use scipy.integrate.cumtrapz) auszuführen und ein st zu finden$F(r)$

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

Ich hoffe jedoch, die Werte und l o g ( x ) anstelle von y und x (wenn möglich) zu verwenden.$log(y)$$log(x)$$y$$x$

Sie können einfach Variablen ändern. Einstellen , b ( a ) = l o g ( y ( x ) ) . Das Integral wird$a=log(x)$$b(a)=log(y(x))$

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

Sie müssen ein wenig vorsichtig sein, weil Sie von . Was Sie genau tun müssen, hängt davon ab, wie y ( x ) aussieht.$-\infty$$y(x)$

Ich benutze kein Python, aber wenn ich es richtig verstehe, dann denken Sie unter so etwas wie F = i n t e g r a t e ( y , x ), wobei F. = [ F 1 , . . . , F n ] ist ein Vektor, der das Integral über ein Gitter x abtastet .

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

Allerdings haben Sie keine Proben von und y , sondern haben Sie Proben von x = log ( x ) und y = log ( y ) .$x$$y$$\hat{x}=\log(x)$$\hat{y}=\log(y)$

Natürlich wäre der einfachste Ansatz aber dies würde fehleranfällig, weil y ( x ) ist nicht glatt, auch wenn y ( x ) ist.

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

Die Trapezregel geht nun im Wesentlichen davon aus, dass Ihre Eingabe stückweise linear ist. So ist die einfache Verallgemeinerung wäre für Sie zu übernehmen y ( x ) stückweise linear.$y(x)$$\hat{y}(\hat{x})$

In diesem Fall definieren , haben Sie Δ F k = ∫ x k + 1 x k y ( x ) d x = ∫ x k + 1 x k e y ( x ) e x d x = ∫ x k $\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}$$

Dann definieren , haben Sie y k + t ≈ y k + t Δ y k und ~ y ( t ) ≈ a e b t , mit einem = e y k + x k und b = $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$

So wird das Integral

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

In Matlab würde das ungefähr so ​​aussehen

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

Hoffe das hilft!

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

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

Ich denke, dass es in einigen der vorherigen Antworten ein wenig Verwirrung mit der Änderung von Variablen gibt sowie mit einigen Fehlern. Das Integral einer Protokollfunktion ist nicht das Protokoll des Integrals. Ich denke, im Allgemeinen ist es schwierig, das Integral einer Funktion zu schreiben, wenn man das Integral ihres Protokolls kennt. Wenn jemand weiß, wie das geht, wäre ich interessiert.

In der Zwischenzeit ist die obige Lösung von @ Stefan der Weg, um die Integration einer Funktion in den Log-Log-Bereich zu umgehen. Der Ausgangspunkt ist, dass die Funktion, die Sie ausführen, im Protokoll-Protokoll-Bereich für ausreichend kleine Segmente linear ist.

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

$m_1$$n_1$

Durch Subtrahieren der beiden kann man finden:

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

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

Wenn im Log-Log-Raum die Gleichung eines Segments nahe an einer Linie liegt, liegt die Gleichung des Segments im normalen (linearen) Raum nahe an einem Exponential:

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

Wenn wir eine analytische Formulierung für dieses Segment haben, ist es einfach zu integrieren:

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

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

Dies fühlt sich ein bisschen wie Betrug an, aber dies ist eine Stichprobe im Log-Log-Raum, so dass wir die Funktion im linearen Raum mit Parametern, die aus dem Log-Log-Raum abgeleitet sind, auf ein Exponential approximieren können.

Die Lösung, die ich verwende, ist im Grunde eine Implementierung der Trapezregel und nutzt die scipy.misc.logsumexpFunktion, um die Präzision aufrechtzuerhalten. Wenn Sie eine Funktion haben lny, die den Logarithmus von zurückgibt y, können Sie Folgendes tun, z.

aus scipy.misc importiere logsumexp
importiere numpy als np

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

# Werte von x logarithmisch beabstandet abrufen
xvs = np.logspace (np.log10 (xmin), np.log10 (xmax), 10000)

# bewerte deine Funktion bei xvs
lys = lny (xvs)

# Trapezregelintegration durchführen
deltas = np.log (np.diff (xvs))
logI = -np.log (2.) + logsumexp ([logsumexp (lys [: - 1] + deltas), logsumexp (lys [1:] + deltas)])

Der Wert logIist das Protokoll des gewünschten Integrals.

Offensichtlich funktioniert dies nicht, wenn Sie einstellen müssen xmin = 0. Wenn Sie jedoch eine positive Untergrenze ungleich Null für das Integral haben, können Sie einfach mit der Anzahl der Punkte spielen xvs, um eine Zahl zu finden, bei der das Integral konvergiert.