Verwendung der PI-Konstante in C ++

Ich möchte die PI-Konstante und die trigonometrischen Funktionen in einigen C ++ - Programmen verwenden. Ich bekomme die trigonometrischen Funktionen mit include <math.h>. Es scheint jedoch keine Definition für PI in dieser Header-Datei zu geben.

Wie kann ich PI erhalten, ohne es manuell zu definieren?

Auf einigen (insbesondere älteren) Plattformen (siehe Kommentare unten) müssen Sie dies möglicherweise tun

#define _USE_MATH_DEFINES

und fügen Sie dann die erforderliche Header-Datei hinzu:

#include <math.h>

und auf den Wert von pi kann zugegriffen werden über:

M_PI

In meinem math.h(2014) ist es definiert als:

# define M_PI           3.14159265358979323846  /* pi */

aber überprüfen Sie Ihre math.hfür mehr. Ein Auszug aus dem "Alten" math.h(2009):

/* Define _USE_MATH_DEFINES before including math.h to expose these macro
 * definitions for common math constants.  These are placed under an #ifdef
 * since these commonly-defined names are not part of the C/C++ standards.
 */

Jedoch:

1. Auf neueren Plattformen (zumindest auf meinem 64-Bit-Ubuntu 14.04) muss ich das nicht definieren _USE_MATH_DEFINES

2. Auf (neueren) Linux-Plattformen werden auch long doubleWerte als GNU-Erweiterung bereitgestellt:

   # define M_PIl          3.141592653589793238462643383279502884L /* pi */

Pi kann berechnet werden als atan(1)*4. Sie können den Wert auf diese Weise berechnen und zwischenspeichern.

Sie können auch Boost verwenden, das wichtige mathematische Konstanten mit maximaler Genauigkeit für den angeforderten Typ definiert (dh float vs double).

const double pi = boost::math::constants::pi<double>();

Weitere Beispiele finden Sie in der Boost-Dokumentation .

Holen Sie es sich stattdessen von der FPU-Einheit auf dem Chip:

double get_PI()
{
    double pi;
    __asm
    {
        fldpi
        fstp pi
    }
    return pi;
}

double PI = get_PI();

Ich würde empfehlen, nur pi mit der Genauigkeit einzugeben, die Sie benötigen. Dies würde Ihrer Ausführung keine Berechnungszeit hinzufügen und wäre portabel, ohne Header oder #defines zu verwenden. Die Berechnung von Acos oder Atan ist immer teurer als die Verwendung eines vorberechneten Wertes.

const double PI  =3.141592653589793238463;
const float  PI_F=3.14159265358979f;

Anstatt zu schreiben

#define _USE_MATH_DEFINES

Ich würde empfehlen, -D_USE_MATH_DEFINESoder /D_USE_MATH_DEFINESabhängig von Ihrem Compiler.

Auf diese Weise können Sie sicher sein, dass Sie selbst im Falle einer Person, die den Header vor Ihnen enthält (und ohne #define), die Konstanten anstelle eines obskuren Compilerfehlers haben, dessen Aufspüren Sie ewig brauchen werden.

Da die offizielle Standardbibliothek keinen konstanten PI definiert, müssten Sie ihn selbst definieren. Die Antwort auf Ihre Frage "Wie kann ich PI erhalten, ohne es manuell zu definieren?" lautet "Sie tun es nicht - oder Sie verlassen sich auf einige compilerspezifische Erweiterungen." Wenn Sie sich keine Gedanken über die Portabilität machen, können Sie dies im Handbuch Ihres Compilers nachlesen.

Mit C ++ können Sie schreiben

const double PI = std::atan(1.0)*4;

Es ist jedoch nicht garantiert, dass die Initialisierung dieser Konstante statisch ist. Der G ++ - Compiler behandelt diese mathematischen Funktionen jedoch als intrinsisch und kann diesen konstanten Ausdruck zur Kompilierungszeit berechnen.

Aus der Posix-Manpage von math.h :

   The  <math.h>  header  shall  provide for the following constants.  The
   values are of type double and are accurate within the precision of  the
   double type.

   M_PI   Value of pi

   M_PI_2 Value of pi/2

   M_PI_4 Value of pi/4

   M_1_PI Value of 1/pi

   M_2_PI Value of 2/pi

   M_2_SQRTPI
          Value of 2/ sqrt pi

C ++ 20 std::numbers::pi

Endlich ist es soweit: http://eel.is/c++draft/numbers

Ich erwarte, dass die Verwendung wie folgt ist:

#include <numbers>
#include <iostream>

int main() {
    std::cout << std::numbers::pi << std::endl;
}

Ich werde es versuchen, wenn der Support bei GCC eintrifft. GCC 9.1.0 g++-9 -std=c++2aunterstützt ihn immer noch nicht.

Der akzeptierte Vorschlag beschreibt:

5.0. "Header" [Header] In der Tabelle [tab: cpp.library.headers] muss ein neuer <math>Header hinzugefügt werden.

[...]

namespace std {
namespace math { 
  template<typename T > inline constexpr T pi_v = unspecified;
    inline constexpr double pi = pi_v<double>;

Es gibt std::numbers::enatürlich auch eine :-) Wie berechnet man die Eulerkonstante oder Euler in C ++?

Diese Konstanten verwenden die C ++ 14-Variablenvorlagenfunktion: C ++ 14-Variablenvorlagen: Wozu dienen sie? Irgendein Verwendungsbeispiel?

In früheren Versionen des Entwurfs befand sich die Konstante unter std::math::pi: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0631r7.pdf

Standard C ++ hat keine Konstante für PI.

Viele C ++ - Compiler definieren M_PIin cmath(oder in math.hfür C) eine nicht standardmäßige Erweiterung. Möglicherweise müssen Sie, #define _USE_MATH_DEFINESbevor Sie es sehen können.

Ich würde es tun

template<typename T>
T const pi = std::acos(-T(1));

oder

template<typename T>
T const pi = std::arg(-std::log(T(2)));

Ich würde nicht auf die Genauigkeit in π eingeben Sie benötigen . Was soll das überhaupt bedeuten? Die Präzision, die Sie benötigen, ist die Präzision von T, aber wir wissen nichts darüberT .

Sie könnten sagen: Worüber reden Sie? Twird sein float, doubleoder long double. Geben Sie also einfach die Genauigkeit von ein long double, z

template<typename T>
T const pi = static_cast<T>(/* long double precision π */);

Aber wissen Sie wirklich, dass es in Zukunft keinen neuen Gleitkommatyp im Standard geben wird, der noch präziser ist als long double ? Das tust du nicht.

Und deshalb ist die erste Lösung schön. Sie können ziemlich sicher sein, dass der Standard die trigonometrischen Funktionen für einen neuen Typ überladen würde.

Und bitte sagen Sie nicht, dass die Auswertung einer trigonometrischen Funktion bei der Initialisierung eine Leistungsbeeinträchtigung darstellt.

Ich verwende Folgendes in einem meiner gemeinsamen Header im Projekt, das alle Grundlagen abdeckt:

#define _USE_MATH_DEFINES
#include <cmath>

#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

#ifndef M_PIl
#define M_PIl (3.14159265358979323846264338327950288)
#endif

Nebenbei bemerkt definieren alle unten aufgeführten Compiler die Konstanten M_PI und M_PIl, wenn Sie sie einschließen <cmath>. Es ist nicht erforderlich, `#define _USE_MATH_DEFINES hinzuzufügen, was nur für VC ++ erforderlich ist.

x86 GCC 4.4+
ARM GCC 4.5+
x86 Clang 3.0+

Im Allgemeinen definiere ich lieber meine eigenen: const double PI = 2*acos(0.0);weil nicht alle Implementierungen sie für Sie bereitstellen.

Die Frage, ob diese Funktion zur Laufzeit aufgerufen oder zur Kompilierungszeit statisch ausgegeben wird, ist normalerweise kein Problem, da sie ohnehin nur einmal auftritt.

Ich bin gerade auf diesen Artikel von Danny Kalev gestoßen, der einen großartigen Tipp für C ++ 14 und höher enthält.

template<typename T>
constexpr T pi = T(3.1415926535897932385);

Ich fand das ziemlich cool (obwohl ich dort den PI mit der höchsten Präzision verwenden würde), vor allem, weil Vorlagen ihn basierend auf dem Typ verwenden können.

template<typename T>
T circular_area(T r) {
  return pi<T> * r * r;
}
double darea= circular_area(5.5);//uses pi<double>
float farea= circular_area(5.5f);//uses pi<float>

Werte wie M_PI, M_PI_2, M_PI_4 usw. sind kein Standard-C ++, daher scheint ein constexpr eine bessere Lösung zu sein. Es können verschiedene const-Ausdrücke formuliert werden, die den gleichen pi berechnen, und es geht mich an, ob sie (alle) mir die volle Genauigkeit bieten. Der C ++ - Standard erwähnt nicht explizit, wie pi berechnet wird. Daher neige ich dazu, pi manuell zu definieren. Ich möchte die folgende Lösung teilen, die alle Arten von Brüchen von pi mit voller Genauigkeit unterstützt.

#include <ratio>
#include <iostream>

template<typename RATIO>
constexpr double dpipart()
{
    long double const pi = 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899863;
    return static_cast<double>(pi * RATIO::num / RATIO::den);
}

int main()
{
    std::cout << dpipart<std::ratio<-1, 6>>() << std::endl;
}

Unter Windows (cygwin + g ++) musste das Flag -D_XOPEN_SOURCE=500für den Präprozessor hinzugefügt werden , um die Definition von M_PIin zu verarbeiten math.h.

Mit C ++ 14 können Sie dies tun static constexpr auto pi = acos(-1);

Einige elegante Lösungen. Ich bin mir nicht sicher, ob die Genauigkeit der trigonometrischen Funktionen der Genauigkeit der Typen entspricht. Für diejenigen, die lieber einen konstanten Wert schreiben, funktioniert dies für g ++: -

template<class T>
class X {
public:
            static constexpr T PI = (T) 3.14159265358979323846264338327950288419\
71693993751058209749445923078164062862089986280348253421170679821480865132823066\
47093844609550582231725359408128481117450284102701938521105559644622948954930381\
964428810975665933446128475648233786783165271201909145648566923460;
...
}

Die Genauigkeit von 256 Dezimalstellen sollte für jeden zukünftigen Long Long Long Double-Typ ausreichen. Wenn weitere erforderlich sind, besuchen Sie https://www.piday.org/million/ .

#include <cmath>
const long double pi = acos(-1.L);

Du kannst das:

#include <cmath>
#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

Wenn dies M_PIbereits in definiert ist cmath, wird nichts anderes als Include ausgeführt cmath. Wenn M_PIes nicht definiert ist (was beispielsweise in Visual Studio der Fall ist), wird es definiert. In beiden Fällen können Sie verwendenM_PI den Wert von pi abrufen.

Dieser Wert von pi stammt aus Qmath.h von Qt Creator.

Sie können das verwenden:

#define _USE_MATH_DEFINES // for C++
#include <cmath>

#define _USE_MATH_DEFINES // for C
#include <math.h>

Mathematische Konstanten sind in Standard C / C ++ nicht definiert. Um sie zu verwenden, müssen Sie zuerst definieren _USE_MATH_DEFINESund dann schließen cmathoder math.h.