tgamma() lang lang typecasting

Question

Ich schreibe eine Funktion, in der ich faktorielle Zahlen berechnen und Operationen an ihnen ausführen muss. Der Rückgabewert der Funktion sollte lang sein, also denke ich, es wäre besser, alle Operationen auszuführen im langen langen Format. Wenn ich falsch liege, korrigiere mich bitte.

Die Funktion tgamma() liefert selbst den korrekten Wert in wissenschaftlicher Schreibweise. Aber der von tgamma() zurückgegebene Wert ist manchmal 1 weniger als die tatsächliche Antwort, wenn der von der Funktion zurückgegebene Wert in 'lang lang' eingegeben wird.

int main() 
{ 
std::cout<<"11!:"<<tgamma(12)<<std::endl; 
std::cout<<"12!"<<tgamma(13)<<std::endl; 
std::cout<<"13!"<<tgamma(14)<<std::endl; 
std::cout<<"14!"<<tgamma(15)<<std::endl; 
std::cout<<"15!"<<tgamma(16)<<std::endl; 
std::cout<<"16!"<<tgamma(17)<<std::endl; 
std::cout<<"********************************"<<std::endl; 
std::cout<<"11!:"<<(long long)tgamma(12)<<std::endl; 
std::cout<<"12!"<<(long long)tgamma(13)<<std::endl; 
std::cout<<"13!"<<(long long)tgamma(14)<<std::endl; 
std::cout<<"14!"<<(long long)tgamma(15)<<std::endl; 
std::cout<<"15!"<<(long long)tgamma(16)<<std::endl; 
std::cout<<"16!"<<(long long)tgamma(17)<<std::endl; 
return 0; 
} 

ich die folgende Ausgabe bin immer:

11!:3.99168e+07 
12!4.79002e+08 
13!6.22702e+09 
14!8.71783e+10 
15!1.30767e+12 
16!2.09228e+13 
******************************** 
11!:39916800 
12!479001599 
13!6227020799 
14!87178291199 
15!1307674367999 
16!20922789888000 

Der tatsächliche Wert von 15! nach this site ist 1307674368000 aber wenn ich tgamma (16) zu lang lang tippen, bekomme ich nur 1307674367999. Die Sache ist diese Diskrepanz erscheint nur für einige Zahlen. Die eingegebene Antwort für 16! ist korrekt - 20922789888000.

Diese Funktion ist für ein konkurrierendes Programmierproblem, das gerade läuft, so dass ich die Funktion und die Lösung, die ich hier entwickle, nicht einfügen kann.

Ich würde meine eigene faktorielle Funktion rollen, aber ich möchte die Anzahl der Zeichen in meinem Programm reduzieren, um Bonuspunkte zu erhalten.

Gibt es Tipps, wie Sie diese Diskrepanz im eingegebenen Wert erkennen und korrigieren können? Oder vielleicht eine andere Funktion, die ich verwenden kann?

Answer 1

Umwandlung von einem Fließkommatyp in einen Integraltyp wird abgeschnitten. Versuchen Sie (long long) roundl(tgammal(xxx)), um den ganzzahligen Kürzungsfehler loszuwerden. Dies verwendet auch lange Doppel, so dass es Ihnen mehr Ziffern geben kann.

#include <math.h> 
#include <iostream> 
int main(){ 
    std::cout<<"11!:"<<(long long)roundl(tgammal(12))<<std::endl; 
    std::cout<<"12!"<<(long long)roundl(tgammal(13))<<std::endl; 
    std::cout<<"13!"<<(long long)roundl(tgammal(14))<<std::endl; 
    std::cout<<"14!"<<(long long)roundl(tgammal(15))<<std::endl; 
    std::cout<<"15!"<<(long long)roundl(tgammal(16))<<std::endl; 
    std::cout<<"16!"<<(long long)roundl(tgammal(17))<<std::endl; 
    std::cout<<"********************************"<<std::endl; 
    std::cout<<"11!:"<<(long long)roundl(tgammal(12))<<std::endl; 
    std::cout<<"12!"<<(long long)roundl(tgammal(13))<<std::endl; 
    std::cout<<"13!"<<(long long)roundl(tgammal(14))<<std::endl; 
    std::cout<<"14!"<<(long long)roundl(tgammal(15))<<std::endl; 
    std::cout<<"15!"<<(long long)roundl(tgammal(16))<<std::endl; 
    std::cout<<"16!"<<(long long)roundl(tgammal(17))<<std::endl; 
    return 0; 
} 

Gibt:

11!:39916800 
12!479001600 
13!6227020800 
14!87178291200 
15!1307674368000 
16!20922789888000 
******************************** 
11!:39916800 
12!479001600 
13!6227020800 
14!87178291200 
15!1307674368000 
16!20922789888000 

Answer 2

Offensichtlich, es sei denn wir sehr ungewöhnliche Umsetzung haben, nicht alle lange lange Zahlen können genau wie doppelt dargestellt werden. Daher kann tgamma keine doppelten Werte speichern, so dass das Gießen zu lange lange einen genauen Wert ergeben würde. Es gibt einfach mehr lange lange Werte als doppelte Werte innerhalb eines langen langen Intervalls.

Wenn Sie genau lange lange Fakultät wollen, sollten Sie es selbst implementieren.

Obendrein, wenn Sie Präzision wünschen, transformieren Sie doppelt in lang lang nicht als (lang lang) x, sondern als (lang lang) rund (x) oder (lang lang) (x + 0,5), Angenommen, x ist positiv.