Schnelle Exp-Berechnung: mögliche, um Genauigkeit zu verbessern, ohne zu viel Leistung?

Ich versuche aus dem schnellen Exp(x) Funktion, die vorher beschrieben wurde, diese Antwort auf eine Frage ALSO auf die Verbesserung der Geschwindigkeit der Berechnung, die in C#:

public static double Exp(double x)
{
  var tmp = (long)(1512775 * x + 1072632447);
  return BitConverter.Int64BitsToDouble(tmp << 32);
}

Wird der Ausdruck mit IEEE-floating-point "tricks" und ist hauptsächlich für die Verwendung in neuronalen sets. Die Funktion ist etwa 5-mal schneller als die normalen Math.Exp(x) Funktion.

Leider, ist die numerische Genauigkeit ist nur -4% -- +2% gegenüber dem regulären Math.Exp(x) Funktion, idealerweise würde ich gerne eine Genauigkeit von innerhalb mindestens der sub-Prozent-Bereich.

Habe ich gezeichnet, der quotient zwischen dem ungefähren und dem regulären Exp Funktionen, und wie gesehen werden kann, in der Grafik die relative Differenz scheint wiederholt zu werden, mit praktisch konstanter Frequenz.

Schnelle Exp-Berechnung: mögliche, um Genauigkeit zu verbessern, ohne zu viel Leistung?

Ist es möglich, dies zu nutzen Regelmäßigkeit zur Verbesserung der Genauigkeit der "schnelle exp" - Funktion weiter, ohne erhebliche Verringerung der Geschwindigkeit der Berechnung, oder würde der rechnerische Aufwand eine Genauigkeit Verbesserung überwiegen die rechnerische Verstärkung des ursprünglichen Ausdrucks?

(Wie sehen a side note, ich habe auch versucht, eine alternative Ansätzen, die in der gleichen Frage ALSO, aber mit diesem Ansatz nicht zu sein scheinen sehr effizient in C#, zumindest nicht für den Allgemeinen Fall.)

UPDATE MAI 14

Auf Wunsch von @Adriano, ich habe mir nun vorgenommen einen sehr einfachen Maßstab. Habe ich durchgeführt 10 Millionen Berechnungen unter Verwendung jeder der alternativen exp Funktionen für Gleitkomma-Werte im Bereich [-100, 100]. Da der Bereich der Werte, die ich bin daran interessiert, es erstreckt sich von -20 bis 0 habe ich auch explizit aufgeführt ist der Wert für die Funktion an der Stelle x = -5. Hier sind die Ergebnisse:

      Math.Exp: 62.525 ms, exp(-5) = 0.00673794699908547
Empty function: 13.769 ms
     ExpNeural: 14.867 ms, exp(-5) = 0.00675211846828461
    ExpSeries8: 15.121 ms, exp(-5) = 0.00641270968867667
   ExpSeries16: 32.046 ms, exp(-5) = 0.00673666189488182
          exp1: 15.062 ms, exp(-5) = -12.3333325982094
          exp2: 15.090 ms, exp(-5) = 13.708332516253
          exp3: 16.251 ms, exp(-5) = -12.3333325982094
          exp4: 17.924 ms, exp(-5) = 728.368055056781
          exp5: 20.972 ms, exp(-5) = -6.13293614238501
          exp6: 24.212 ms, exp(-5) = 3.55518353166184
          exp7: 29.092 ms, exp(-5) = -1.8271053775984
      exp7 +/-: 38.482 ms, exp(-5) = 0.00695945286970704

ExpNeural entspricht der Exp Funktion angegeben, die am Anfang dieses Textes. ExpSeries8 wird die Formulierung, dass ich ursprünglich behauptete, war nicht sehr effizient auf .NETTO; bei der Umsetzung ist es genau so wie Neil es war tatsächlich sehr schnell. ExpSeries16 wird die analoge Formel, aber mit 16 Multiplikationen statt 8. exp1 durch exp7 sind die verschiedenen Funktionen von Adriano ' s Antwort weiter unten. Die endgültige Variante des exp7 ist eine Variante, wo die Zeichen der x wird überprüft; wenn negativ, liefert die Funktion 1/exp(-x) statt.

Leider weder von der expN Funktionen aufgeführt, die durch Adriano sind ausreichend in der breiteren negativen Wertebereich überlege ich. Die Serie Erweiterung Ansatz von Neil Coffey scheint zu sein, mehr geeignet, "meine" Wert-Bereich, obwohl es zu stark erweiternde, mit größeren negativen x, vor allem, wenn Sie mit "nur" 8 Multiplikationen.

ich bin neugierig auf Ihre Referenz zu "neural-Sätzen". derzeit bin ich die Simulation eines neuronalen Netzes mit C++ und vor dem gleichen exp performance-Engpass, die Sie haben, konfrontiert. gibt es papers in computational neuroscience, die haben vorgeschlagen Ungefähre exp Funktionen, die sind sehr schnell?

InformationsquelleAutor Anders Gustafsson | 2012-05-11

c#exp floating-accuracy performance

Im Falle jemand will, um zu replizieren, die den relativen Fehler der Funktion angezeigt, in der Frage, hier ist ein Weg, mit Hilfe von Matlab (das "fast" exponent ist nicht sehr schnell in Matlab, aber es ist zutreffend):

t = 1072632447+[0:ceil(1512775*pi)];
x = (t - 1072632447)/1512775;
ex = exp(x);
t = uint64(t);
import java.lang.Double;
et = arrayfun( @(n) java.lang.Double.longBitsToDouble(bitshift(n,32)), t );
plot(x, et./ex);

Nun, die Zeit der Fehler genau mit dem übereinstimmt, wenn der binäre Wert des tmp überläufe aus der Mantisse in den Exponenten. Wir brechen unsere Daten in den Behältern durch das verwerfen der bits, werden die Exponenten (und damit periodische), und hält nur die hohen verbleibenden acht bits (um unsere lookup-Tabelle in einer vernünftigen Größe):

index = bitshift(bitand(t,uint64(2^20-2^12)),-12) + 1;

Nun berechnen wir die mittlere erforderliche Anpassung:

relerrfix = ex./et;
adjust = NaN(1,256);
for i=1:256; adjust(i) = mean(relerrfix(index == i)); end;
et2 = et .* adjust(index);

Der relative Fehler verringert sich auf +/- .0006. Natürlich, anderen Größen Tabellen möglich (zum Beispiel 6-bit-Tabelle mit 64 Einträgen gibt +/- .0025) und der Fehler ist fast linear in der Tabelle size. Lineare interpolation zwischen die Einträge der Tabelle verbessern würde die Fehler noch weiter, aber auf Kosten der performance. Da wir bereits begegnet der Genauigkeit Ziel, lassen Sie uns vermeiden Sie jegliche weitere Leistung trifft.

Zu diesem Zeitpunkt ist es einigen trivial-editor-Fähigkeiten, um die berechneten Werte von MatLab und erstellen Sie eine lookup-Tabelle in C#. Für jede Berechnung, fügen wir eine Bitmaske, lookup-Tabelle, und mit doppelter Genauigkeit multipliziert.

static double FastExp(double x)
{
    var tmp = (long)(1512775 * x + 1072632447);
    int index = (int)(tmp >> 12) & 0xFF;
    return BitConverter.Int64BitsToDouble(tmp << 32) * ExpAdjustment[index];
}

Den speedup ist sehr ähnlich wie das original-code -- für meinen computer, das ist etwa 30% schneller als x86 kompiliert und etwa 3x so schnell für x64. Mit mono auf ideone, es ist eine erhebliche Netto-Verlust (aber so ist das original).

Kompletten source-code-und Testfall: http://ideone.com/UwNgx

using System;
using System.Diagnostics;

namespace fastexponent
{
    class Program
    {
        static double[] ExpAdjustment = new double[256] {
            1.040389835,
            1.039159306,
            1.037945888,
            1.036749401,
            1.035569671,
            1.034406528,
            1.033259801,
            1.032129324,
            1.031014933,
            1.029916467,
            1.028833767,
            1.027766676,
            1.02671504,
            1.025678708,
            1.02465753,
            1.023651359,
            1.022660049,
            1.021683458,
            1.020721446,
            1.019773873,
            1.018840604,
            1.017921503,
            1.017016438,
            1.016125279,
            1.015247897,
            1.014384165,
            1.013533958,
            1.012697153,
            1.011873629,
            1.011063266,
            1.010265947,
            1.009481555,
            1.008709975,
            1.007951096,
            1.007204805,
            1.006470993,
            1.005749552,
            1.005040376,
            1.004343358,
            1.003658397,
            1.002985389,
            1.002324233,
            1.001674831,
            1.001037085,
            1.000410897,
            0.999796173,
            0.999192819,
            0.998600742,
            0.998019851,
            0.997450055,
            0.996891266,
            0.996343396,
            0.995806358,
            0.995280068,
            0.99476444,
            0.994259393,
            0.993764844,
            0.993280711,
            0.992806917,
            0.992343381,
            0.991890026,
            0.991446776,
            0.991013555,
            0.990590289,
            0.990176903,
            0.989773325,
            0.989379484,
            0.988995309,
            0.988620729,
            0.988255677,
            0.987900083,
            0.987553882,
            0.987217006,
            0.98688939,
            0.98657097,
            0.986261682,
            0.985961463,
            0.985670251,
            0.985387985,
            0.985114604,
            0.984850048,
            0.984594259,
            0.984347178,
            0.984108748,
            0.983878911,
            0.983657613,
            0.983444797,
            0.983240409,
            0.983044394,
            0.982856701,
            0.982677276,
            0.982506066,
            0.982343022,
            0.982188091,
            0.982041225,
            0.981902373,
            0.981771487,
            0.981648519,
            0.981533421,
            0.981426146,
            0.981326648,
            0.98123488,
            0.981150798,
            0.981074356,
            0.981005511,
            0.980944219,
            0.980890437,
            0.980844122,
            0.980805232,
            0.980773726,
            0.980749562,
            0.9807327,
            0.9807231,
            0.980720722,
            0.980725528,
            0.980737478,
            0.980756534,
            0.98078266,
            0.980815817,
            0.980855968,
            0.980903079,
            0.980955475,
            0.981017942,
            0.981085714,
            0.981160303,
            0.981241675,
            0.981329796,
            0.981424634,
            0.981526154,
            0.981634325,
            0.981749114,
            0.981870489,
            0.981998419,
            0.982132873,
            0.98227382,
            0.982421229,
            0.982575072,
            0.982735318,
            0.982901937,
            0.983074902,
            0.983254183,
            0.983439752,
            0.983631582,
            0.983829644,
            0.984033912,
            0.984244358,
            0.984460956,
            0.984683681,
            0.984912505,
            0.985147403,
            0.985388349,
            0.98563532,
            0.98588829,
            0.986147234,
            0.986412128,
            0.986682949,
            0.986959673,
            0.987242277,
            0.987530737,
            0.987825031,
            0.988125136,
            0.98843103,
            0.988742691,
            0.989060098,
            0.989383229,
            0.989712063,
            0.990046579,
            0.990386756,
            0.990732574,
            0.991084012,
            0.991441052,
            0.991803672,
            0.992171854,
            0.992545578,
            0.992924825,
            0.993309578,
            0.993699816,
            0.994095522,
            0.994496677,
            0.994903265,
            0.995315266,
            0.995732665,
            0.996155442,
            0.996583582,
            0.997017068,
            0.997455883,
            0.99790001,
            0.998349434,
            0.998804138,
            0.999264107,
            0.999729325,
            1.000199776,
            1.000675446,
            1.001156319,
            1.001642381,
            1.002133617,
            1.002630011,
            1.003131551,
            1.003638222,
            1.00415001,
            1.004666901,
            1.005188881,
            1.005715938,
            1.006248058,
            1.006785227,
            1.007327434,
            1.007874665,
            1.008426907,
            1.008984149,
            1.009546377,
            1.010113581,
            1.010685747,
            1.011262865,
            1.011844922,
            1.012431907,
            1.013023808,
            1.013620615,
            1.014222317,
            1.014828902,
            1.01544036,
            1.016056681,
            1.016677853,
            1.017303866,
            1.017934711,
            1.018570378,
            1.019210855,
            1.019856135,
            1.020506206,
            1.02116106,
            1.021820687,
            1.022485078,
            1.023154224,
            1.023828116,
            1.024506745,
            1.025190103,
            1.02587818,
            1.026570969,
            1.027268461,
            1.027970647,
            1.02867752,
            1.029389072,
            1.030114973,
            1.030826088,
            1.03155163,
            1.032281819,
            1.03301665,
            1.033756114,
            1.034500204,
            1.035248913,
            1.036002235,
            1.036760162,
            1.037522688,
            1.038289806,
            1.039061509,
            1.039837792,
            1.040618648
        };

        static double FastExp(double x)
        {
            var tmp = (long)(1512775 * x + 1072632447);
            int index = (int)(tmp >> 12) & 0xFF;
            return BitConverter.Int64BitsToDouble(tmp << 32) * ExpAdjustment[index];
        }

        static void Main(string[] args)
        {
            double[] x = new double[1000000];
            double[] ex = new double[x.Length];
            double[] fx = new double[x.Length];
            Random r = new Random();
            for (int i = 0; i < x.Length; ++i)
                x[i] = r.NextDouble() * 40;

            Stopwatch sw = new Stopwatch();
            sw.Start();
            for (int j = 0; j < x.Length; ++j)
                ex[j] = Math.Exp(x[j]);
            sw.Stop();
            double builtin = sw.Elapsed.TotalMilliseconds;
            sw.Reset();
            sw.Start();
            for (int k = 0; k < x.Length; ++k)
                fx[k] = FastExp(x[k]);
            sw.Stop();
            double custom = sw.Elapsed.TotalMilliseconds;

            double min = 1, max = 1;
            for (int m = 0; m < x.Length; ++m) {
                double ratio = fx[m] / ex[m];
                if (min > ratio) min = ratio;
                if (max < ratio) max = ratio;
            }

            Console.WriteLine("minimum ratio = " + min.ToString() + ", maximum ratio = " + max.ToString() + ", speedup = " + (builtin / custom).ToString());
         }
    }
}

Fantastische Arbeit, und eine tolle Erklärung! Vielen Dank für die Antwort, das war genau die Art von Fortschritt, die ich mir erhofft hatte. Hatten Sie entwickelte diese früher, oder implementieren Sie es als ein Ergebnis dieser Frage?
Ich bin völlig Stahlen die Vorgehensweise, die Sie vorgeschlagen, in Frage.
Nach Tests im android-NDK, es ist langsamer als system std::exp(). Aber es ist schneller im PC. (gist.github.com/maxint/0172c1dcd075d3589eeb)
Code Undefiniertes Verhalten über alles geschrieben. Verwenden memcpy für Ihre Art-Zweideutigkeiten. Sowieso, je nachdem, ob Ihr Ziel hat sich floating-point-hardware, möchten Sie vielleicht, um die Verwendung von single-precision für die lookup-Tabelle. Wir reden hier von einem relativen Fehler von .0006, also mit doppelter Genauigkeit ist nicht zu helfen.
Sie haben eine C-Implementierung dieser?
Ersetzen Sie einfach BitConverter Funktionen durch eine memcpy, und bewegen Sie den [] in der array-definition. Der rest der C# - code ist gültig C bereits.

InformationsquelleAutor Ben Voigt

10

Versuchen Sie folgenden alternativen (exp1 ist schneller, exp7 mehr genau).

Code
```
public static double exp1(double x) { 
    return (6+x*(6+x*(3+x)))*0.16666666f; 
}

public static double exp2(double x) {
    return (24+x*(24+x*(12+x*(4+x))))*0.041666666f;
}

public static double exp3(double x) {
    return (120+x*(120+x*(60+x*(20+x*(5+x)))))*0.0083333333f;
}

public static double exp4(double x) {
    return 720+x*(720+x*(360+x*(120+x*(30+x*(6+x))))))*0.0013888888f;
}

public static double exp5(double x) {
    return (5040+x*(5040+x*(2520+x*(840+x*(210+x*(42+x*(7+x)))))))*0.00019841269f;
}

public static double exp6(double x) {
    return (40320+x*(40320+x*(20160+x*(6720+x*(1680+x*(336+x*(56+x*(8+x))))))))*2.4801587301e-5;
}

public static double exp7(double x) {
  return (362880+x*(362880+x*(181440+x*(60480+x*(15120+x*(3024+x*(504+x*(72+x*(9+x)))))))))*2.75573192e-6;
}
```
Präzision
```
Funktion Fehler in [-1...1] Fehler in [3.14 3.14...] 

exp1 0.05 1.8% 8.8742 38.40% 
bsp2 0.01 0.36% 4.8237 20.80% 
exp3 0.0016152 0.59% 2.28 9.80% 
exp4 0.0002263 0.0083% 0.9488 4.10% 
exp5 0.0000279 0.001% 0.3516 1.50% 
exp6 0.0000031 0.00011% 0.1172 0.50% 
exp7 0.0000003 0.000011% 0.0355 0.15% 
```
Credits

Diese Implementierungen exp() wurden berechnet, indem die "scoofy" mit Taylor-Reihe von einem tanh() Umsetzung von "fuzzpilz" (wer auch immer Sie sind, ich hatte nur diese Verweise auf meinen code).
- "fuzzpilz" LOL. Manche Leute haben einen seltsamen Sinn für nick-Namen.
- Original Taylor series approximation durch [email protected] hier: musicdsp.org/showone.php?id=222 - von Ihnen positiv bewertet werden, da es eine einfache Lösung über die Taylor-Reihe, überrascht, es wurde noch nicht gepostet vor.
- danke für den Hinweis, es ist gegangen vor langer Zeit verloren!
- Vielen Dank, Adriano, für die Bereitstellung dieser Methoden, und Dank Mahmoud für die Bereitstellung des link zu der original-text. Ich hatte nicht ganz diese Implementierungen vor. Ich habe versucht, exp7, und es ist etwa drei mal schneller als Mathe.Exp. Für negative x-es unterscheidet sich ziemlich schnell, aber das könnte vielleicht auch entfallen durch die Berechnung 1/exp (- abs(x))? Ich wiederhole meinen eigenen code, um zu sehen, wenn das Intervall der x-Werte ist ausreichend für die Verwendung exp7, und wenn es ist, ich bin mehr als bereit zu akzeptieren, Ihre Antwort, Adriano.
- bitte aktualisieren Sie Ihre Frage (oder post eine Antwort) mit Ihrem test-Ergebnisse, diese Funktion nutze ich (eigentlich exp5) in einem C++ - Programm, so ich habe nie versucht, seine Leistung .NET. Ich weiß nicht, wie die Leistung des 1/exp (- abs(x)) sein wird, vielleicht nicht so weit Weg von der Mathematik.Exp. Wenn Sie haben, es zu benutzen in a (pro Schicht) - Schleife können Sie prüfen, zu implementieren Sie diese Funktion in einem C++/CLI-Bibliothek, dort werden Sie in der Lage sein, für inline-Montage mit SIMD-Anweisungen über die Schleife (wenn diese nicht zwingen, Sie zu umgestalten von code zu viel).
- sorry für die nicht mehr reagiert früher. Ich werde zu aktualisieren, die Frage mit meinem test-Ergebnisse so bald wie möglich, und testen werde ich C/C++ exp für den Vergleich bei der gleichen Zeit. Ich habe mit dem Parallel-Funktionalität .NET 4, obwohl in diesem speziellen Fall hab ich noch nicht bereit den code für die Parallelisierung. Werde in diesem als gut.
- Danke, ich bin ziemlich interessiert. Ich wusste nicht, dass die .NET Parallel Library (ich denke, um es parallel wird dazu führen, dass einige refactoring), aber so etwas (falls es überhaupt möglich ist): stackoverflow.com/a/412831/1207195
- Ich aktualisiert meine Frage mit ein paar benchmark timings jetzt. Ich habe auch ein näherer Prüfung des Wertebereichs, der für meine Anwendung, und die Werte typischerweise im Bereich von 0 bis negative Hunderte. Werte von -10 -- -15 haben einen erheblichen Einfluss auf das Endergebnis, also die Genauigkeit, die mindestens bis in diese Werte ist relevant. BTW, vielen Dank für den Hinweis auf die Berechnung in C++, ich sehe jetzt was du meinst. Es erfordert erhebliche Umgestaltung in meinem Fall, aber vielleicht es lohnt sich; ich werde darüber nachdenken.
- ja, es funktioniert auch nur in den +/- 3.14-Bereich, aber vielen Dank für den benchmark!!!
- href="http://stackoverflow.com/a/14143184/1339280">Der Technik, beschrieben in meiner Antwort wird erheblich verbessern die Genauigkeit über eine Vielzahl von Eingängen.
InformationsquelleAutor Adriano Repetti
9

Taylor series approximation (wie die expX() Funktionen in Adriano ' s Antwort) die am genauesten sind nahe null und können erhebliche Fehler bei -20 oder sogar -5. Wenn die Eingabe einer bekannten Produktpalette, wie z.B. -20 0 wie die ursprüngliche Frage, die Sie verwenden können, eine kleine look-up-Tabelle und eine zusätzliche multiplizieren, um die Genauigkeit erheblich verbessern.

Der trick ist zu erkennen, dass exp() getrennt werden kann, in integer und Bruch-Teile. Zum Beispiel:
```
exp(-2.345) = exp(-2.0) * exp(-0.345)
```
Den Bruchteil wird immer zwischen -1 und 1, also a Taylor series approximation wird ziemlich genau. Der ganzzahlige Teil hat nur 21 mögliche Werte für exp(-20) exp(0), so können diese gespeichert werden, in einer kleinen look-up-Tabelle.

InformationsquelleAutor shoelzer
4

Sollte der folgende code-Adresse der Anforderungen an die Genauigkeit, wie für die Eingänge in [-87,88] die Ergebnisse sind als relative Fehler <= 1.73 e-3. Ich weiß nicht, C#, also das ist C-code, aber die Konvertierung sollte failry einfach.

Ich gehe davon aus, dass da die Genauigkeit niedrig ist, die Verwendung von single-precision-Berechnung in Ordnung ist. Ein klassischer Algorithmus verwendet wird, in dem die Berechnung von exp() zugeordnet ist Berechnung der bsp2(). Nach dem argument-Konvertierung per Multiplikation von log2(e), exponentation, indem Sie die Nachkommastellen werden durch einen minimax-Polynom von Grad 2, während die exponentation von den ganzzahligen Teil des Arguments erfolgt durch direkte manipulation der exponent Teil des IEEE-754-single-precision-Zahl.

Den flüchtigen union ermöglicht die re-interpretation eines bit-Muster wird entweder eine ganze Zahl oder eine single-precision-floating-point-Zahl, die benötigt werden für den Exponenten manipulation. Es sieht aus wie C# bietet decidated re-interpretation von Funktionen für diese, die ist viel sauberer.

Den zwei potentielle performance-Probleme sind die floor () - Funktion und float->int Umwandlung. Traditionell wurden beide langsam auf x86-aufgrund der Notwendigkeit der Bearbeitung dynamischer Prozessor Staat. Aber SSE (insbesondere SSE 4.1) enthält Anweisungen, die es ermöglichen, diese Vorgänge schnell sein. Ich weiß nicht ob die C# können machen, verwenden Sie diese Anweisungen.
```
 /* max. rel. error <= 1.73e-3 on [-87,88] */
 float fast_exp (float x)
 {
   volatile union {
     float f;
     unsigned int i;
   } cvt;

   /* exp(x) = 2^i * 2^f; i = floor (log2(e) * x), 0 <= f <= 1 */
   float t = x * 1.442695041f;
   float fi = floorf (t);
   float f = t - fi;
   int i = (int)fi;
   cvt.f = (0.3371894346f * f + 0.657636276f) * f + 1.00172476f; /* compute 2^f */
   cvt.i += (i << 23);                                          /* scale by 2^i */
   return cvt.f;
 }
```
- Vielen Dank für ein gutes Beispiel und eine gute Erklärung. Ich werde versuchen, konvertieren Sie Ihre Implementierung in C# zu sehen, wie gut es führt, verglichen mit dem regulären Exp - Funktion. Ich kann mich nicht erinnern, gesehen zu haben, diese Lösung nirgendwo sonst, haben Sie mit diesem Ergebnis die Frage ALSO?
- Ich habe entworfen / implementiert algorithmen für die verschiedenen transzendenten Funktionen mehrere Male in der Vergangenheit. Der Ansatz, den ich oben ausgewählt haben ist sehr viel ein Garten-Vielfalt-Algorithmus. Ich Tat, erstellen Sie eine benutzerdefinierte minimax-approximation für das Polynom insbesondere in der Antwort auf diese Frage. Stehen Werkzeuge wie Mathematica, Maple, und andere; im Allgemeinen sind Sie basiert auf der Variante (N) der Remez-Algorithmus.
- Bitte beachten Sie, dass diese nicht korrekt in C++ verwenden Sie die union. Aber Sie können memcpy in C und C++, und der Optimierer sollte tun, etwas sinnvolles, ohne daß es bricht mit Optimierungen basierend auf strengen aliasing.
- Haben Sie die SSE-version (Betriebssystem auf __m128)? Danke.
- Ich habe keine SSE-code bereit, die post, und noch nicht programmiert mit SSE-Interna seit ich umgestiegen auf GPUs von vor zehn Jahren.
- Ich habe eine SSE version von diesem code jetzt. Ich würde vorschlagen, eine Frage, für die eine niedrige Präzision expf() SIMD-Implementierung und ich könnte dann auch beantwortet.
- Dort gehen Sie - stackoverflow.com/questions/47025373.
InformationsquelleAutor njuffa
4

Ich studiert haben, die Papier von Nicol Schraudolph, wo die originalen C-Implementierung der obigen Funktion definiert wurde, näher jetzt. Es scheint, dass es wahrscheinlich nicht möglich deutlich zu genehmigen, die Genauigkeit der exp Berechnung ohne erheblich beeinträchtigen die Leistung. Auf der anderen Seite, die Näherung ist gültig, auch für große Größen von x, bis zu +/- 700, die ist natürlich von Vorteil.

Die Implementierung der Funktion oben eingestellt ist, erhalten mindestens die Wurzel aus dem mittleren quadratischen Fehler. Schraudolph beschreibt, wie sich der additive term in der tmp Ausdruck kann verändert werden, um zu erreichen, alternative approximation Eigenschaften.
```
"exp" >= exp for all x                      1072693248 -  (-1) = 1072693249
"exp" <= exp for all x                                 - 90253 = 1072602995
"exp" symmetric around exp                             - 45799 = 1072647449
Mimimum possible mean deviation                        - 68243 = 1072625005
Minimum possible root-mean-square deviation            - 60801 = 1072632447
```
Er weist auch darauf hin, dass bei einer "mikroskopischen" Ebene der Ungefähre "exp" - Funktion weist stair-case-Verhalten seit 32 bits werden verworfen, bei der Umwandlung von lange zu Doppel -. Dies bedeutet, dass die Funktion ist stückweise konstant auf einem sehr kleinen Maßstab, aber die Funktion ist zumindest nie sinkt mit zunehmendem x.

InformationsquelleAutor Anders Gustafsson

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.