Quand utiliser log1p et expm1?

J'ai une question simple qui est vraiment difficile pour Google (à part le canonique que tout informaticien devrait savoir sur le papier arithmétique à virgule flottante ).

Quand faut log1p- expm1il utiliser des fonctions telles que ou au lieu de loget exp? Quand ne devraient-ils pas être utilisés? Comment les différentes implémentations de ces fonctions diffèrent-elles en termes d'utilisation?

floating-point

— Tim
source

Bienvenue sur Scicomp.SE! C'est une question très raisonnable, mais il serait plus facile de répondre si vous expliquiez un peu ce log1p à quoi vous faites référence (en particulier comment il est mis en œuvre, donc nous n'avons pas à deviner).

— Christian Clason

Pour les arguments à valeur réelle, log1p

et expm1

doivent être utilisés lorsque

est petit, par exemple lorsque

en précision à virgule flottante. Voir, par exemple, docs.scipy.org/doc/numpy/reference/generated/numpy.expm1.html et docs.scipy.org/doc/numpy/reference/generated/numpy.log1p.html .

(x)

$(x)$

(x)

$(x)$

x

$x$

1 + x = 1

$1 + x = 1$

— GoHokies

@ChristianClason merci, je me réfère principalement à C ++ std ou R, mais comme vous le demandez, je commence à penser que l'apprentissage des différences dans les implémentations serait également très intéressant.

— Tim

Voici un exemple: scicomp.stackexchange.com/questions/8371/…

— Juan M. Bello-Rivas

@ user2186862 "lorsque

est petit" est correct, mais pas seulement "lorsque

en précision à virgule flottante" (ce qui se produit pour

dans l'arithmétique habituelle à double précision). Les pages de documentation que vous avez liées montrent qu'elles sont déjà utiles pour

, par exemple.

x

$x$

1 + x = 1

$1+x=1$

x \approx 10^{- 16}

$x\approx 10^{-16}$

x \approx 10^{- 10}

$x\approx 10^{-10}$

— Federico Poloni du

Réponses:

Nous savons tous que

\exp (x) = \sum_{n = 0}^{\infty} \frac{x^{n}}{n!} = 1 + x + \frac{1}{2} x^{2} + \dots

$\begin{equation} \exp(x) = \sum_{n=0}^\infty \frac{x^n}{n!} = 1 + x + \frac12 x^2 + \dots \end{equation}$ implique que pour

| x | ≪ 1

$|x| \ll 1$ , on a

\exp (x) \approx 1 + x

$\exp(x) \approx 1 + x$ . Cela signifie que si nous devons évaluer en virgule flottante

\exp (x) - 1

$\exp(x) -1$ , pour

| x | ≪ 1

$|x| \ll 1$ annulation catastrophique peut se produire.

Cela peut être facilement démontré en python:

>>> from math import (exp, expm1)

>>> x = 1e-8
>>> exp(x) - 1
9.99999993922529e-09
>>> expm1(x)
1.0000000050000001e-08

>>> x = 1e-22
>>> exp(x) - 1
0.0
>>> expm1(x)
1e-22

Les valeurs exactes sont

\begin{aligned} \exp (10^{- 8}) - 1 & = 0.000000010000000050000000166666667083333334166666668 \dots \\ \exp (10^{- 22}) - 1 & = 0.000000000000000000000100000000000000000000005000000 \dots \end{aligned}

$\begin{align} \exp(10^{-8}) -1 &= 0.000000010000000050000000166666667083333334166666668 \dots \\ \exp(10^{-22})-1 &= 0.000000000000000000000100000000000000000000005000000 \dots \end{align}$

En général, une mise en œuvre «précise» de expet expm1devrait être correcte à pas plus de 1ULP (c'est-à-dire une unité de la dernière place). Cependant, étant donné que l'atteinte de cette précision entraîne un code "lent", une implémentation rapide et moins précise est parfois disponible. Par exemple, dans CUDA, nous avons expfet expm1f, où fsignifie rapide. Selon le guide de programmation CUDA C, app. D l' expfa une erreur de 2ULP.

Si vous ne vous souciez pas des erreurs de l'ordre de quelques ULPS, généralement différentes implémentations de la fonction exponentielle sont équivalentes, mais attention aux bogues qui peuvent être cachés quelque part ... (Rappelez-vous le bogue Pentium FDIV ?)

Il est donc assez clair que cela expm1devrait être utilisé pour calculer $\exp(x)-1$ pour les petits $x$ . Son utilisation pour le $x$ général n'est pas nocive, car elle expm1devrait être précise sur toute sa plage:

>>> exp(200)-1 == exp(200) == expm1(200)
True

(Dans l'exemple ci-dessus $1$ est bien en dessous de 1ULP de $\exp(200)$ , donc les trois expressions renvoient exactement le même nombre à virgule flottante.)

Une discussion similaire vaut pour les fonctions inverses loget log1ppuisque $\log(1+x) \approx x$ pour $|x| \ll 1$ .

— Stefano M
source

Cette réponse figurait déjà dans les commentaires sur la question du PO. Cependant, je me suis senti utile de donner un compte rendu plus long (bien que basique) juste pour plus de clarté, dans l'espoir qu'il sera utile à certains lecteurs.

— Stefano M

OK, mais alors on peut simplement conclure "donc je peux toujours utiliser expm1 au lieu de exp" ...

— Tim

@tim votre conclusion est fausse: vous pouvez toujours utiliser à la expm1(x)place de exp(x)-1. Bien sûr, exp(x) == exp(x) - 1ne tient pas en général.

— Stefano M

OK, c'est clair. Et existe-t-il des critères clairs pour

x ≪ 1

$x \ll 1$

— Tim

@Tim il n'y a pas de seuil précis et la réponse dépend de la précision de l'implémentation en virgule flottante (et du problème résolu). Alors qu'il expm1(x)devrait être précis à 1ULP sur toute la plage

, il perd progressivement la précision de quelques ULP lorsque

à une panne complète lorsque

, où

est epsilon machine.

0 \leq x \leq 1

$0\leq x \leq 1$ exp(x) - 1

x \approx 1

$x\approx 1$

x < ϵ

$x < \epsilon$

ϵ

$\epsilon$

— Stefano M

Pour développer la différence entre loget log1pil peut être utile de rappeler le graphique si le logarithme:

log $x$ $0$ $\ln(x)$ $- \infty$ $x$ $0$ $\ln(x)$ $\ln(\frac{1}{e}) = -1$ $\ln(\frac{1}{e^{10}}) = -10$

$x$ $0$ $\ln(x+1)$ $0$ $\ln(1+\frac{1}{e}) \sim 0.31$ $\ln(1+\frac{1}{e^{10}}) \sim 0.000045$ log1p

$1$ log $0$ $1$ log1p

— sfmiller940
source