Come usare la costante PI in C ++

Voglio usare la costante PI e le funzioni trigonometriche in alcuni programmi C ++. Ottengo le funzioni trigonometriche con include <math.h>. Tuttavia, non sembra esserci una definizione per PI in questo file di intestazione.

Come posso ottenere PI senza definirlo manualmente?

Su alcune piattaforme (soprattutto vecchie) (vedi i commenti sotto) potresti doverlo fare

#define _USE_MATH_DEFINES

e quindi includere il file di intestazione necessario:

#include <math.h>

e il valore di pi è accessibile tramite:

M_PI

Nel mio math.h(2014) è definito come:

# define M_PI           3.14159265358979323846  /* pi */

ma controlla il tuo math.hper di più. Un estratto dal "vecchio" math.h(nel 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.
 */

Però:

1. su piattaforme più recenti (almeno sul mio Ubuntu 14.04 a 64 bit) non ho bisogno di definire il _USE_MATH_DEFINES

2. Sulle (recenti) piattaforme Linux ci sono long doubleanche valori forniti come estensione GNU:

   # define M_PIl          3.141592653589793238462643383279502884L /* pi */

Pi può essere calcolato come atan(1)*4. È possibile calcolare il valore in questo modo e memorizzarlo nella cache.

È inoltre possibile utilizzare boost, che definisce importanti costanti matematiche con la massima precisione per il tipo richiesto (ovvero float vs double).

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

Consulta la documentazione di boost per ulteriori esempi.

Prendi invece dall'unità FPU su chip:

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

double PI = get_PI();

Consiglierei di digitare pi per la precisione di cui hai bisogno. Ciò non aggiungerebbe alcun tempo di calcolo alla tua esecuzione e sarebbe portatile senza usare intestazioni o #define. Il calcolo di acos o atan è sempre più costoso rispetto all'utilizzo di un valore precalcolato.

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

Piuttosto che scrivere

#define _USE_MATH_DEFINES

Consiglierei di utilizzare -D_USE_MATH_DEFINESo in /D_USE_MATH_DEFINESbase al compilatore.

In questo modo ti viene assicurato che anche nel caso in cui qualcuno includa l'intestazione prima di te (e senza #define) avrai comunque le costanti invece di un oscuro errore del compilatore che impiegherai anni per rintracciare.

Poiché la libreria standard ufficiale non definisce un PI costante, dovresti definirlo tu stesso. Quindi la risposta alla tua domanda "Come posso ottenere PI senza definirlo manualmente?" è "No - o fai affidamento su alcune estensioni specifiche del compilatore.". Se non sei preoccupato per la portabilità, puoi consultare questo manuale del compilatore.

C ++ ti permette di scrivere

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

ma l'inizializzazione di questa costante non è garantita come statica. Il compilatore G ++ tuttavia gestisce quelle funzioni matematiche come intrinseche ed è in grado di calcolare questa espressione costante in fase di compilazione.

Dalla pagina man Posix di 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

Finalmente è arrivato: http://eel.is/c++draft/numbers

Mi aspetto che l'utilizzo sia simile a:

#include <numbers>
#include <iostream>

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

Ci proverò quando il supporto arriva a GCC, GCC 9.1.0 con g++-9 -std=c++2aancora non lo supporta.

La proposta accettata descrive:

5.0. "Headers" [headers] Nella tabella [tab: cpp.library.headers], è <math>necessario aggiungere una nuova intestazione.

[...]

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

C'è std::numbers::eovviamente anche un :-) Come calcolare la costante di Eulero o Eulero alimentato in C ++?

Queste costanti utilizzano la funzione del modello di variabile C ++ 14: Modelli di variabili C ++ 14: qual è il loro scopo? Qualche esempio di utilizzo?

Nelle versioni precedenti del progetto, la costante era sotto std::math::pi: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0631r7.pdf

Il C ++ standard non ha una costante per PI.

Molti compilatori C ++ definiscono M_PIin cmath(o in math.hper C) un'estensione non standard. Potrebbe essere necessario #define _USE_MATH_DEFINESprima di poterlo vedere.

farei

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

o

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

Vorrei non digitando π per la precisione è necessario . Cosa dovrebbe anche significare? La precisione di cui hai bisogno è la precisione di T, ma non sappiamo nulla T.

Potresti dire: di cosa stai parlando? Tsarà float, doubleo long double. Quindi, basta digitare la precisione di long double, ad es

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

Ma sai davvero che in futuro non ci sarà un nuovo tipo a virgola mobile nello standard con una precisione ancora maggiore di long double? Non

Ed è per questo che la prima soluzione è bellissima. Puoi essere certo che lo standard sovraccaricherebbe le funzioni trigonometriche per un nuovo tipo.

E per favore, non dire che la valutazione di una funzione trigonometrica durante l'inizializzazione è una penalità di prestazione.

Uso il seguente in una delle mie intestazioni comuni nel progetto che copre tutte le basi:

#define _USE_MATH_DEFINES
#include <cmath>

#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

#ifndef M_PIl
#define M_PIl (3.14159265358979323846264338327950288)
#endif

Su una nota a margine, tutti i compilatori seguenti definiscono le costanti M_PI e M_PIl se si include <cmath>. Non è necessario aggiungere `#define _USE_MATH_DEFINES che è richiesto solo per VC ++.

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

In genere preferisco definire il mio: const double PI = 2*acos(0.0);perché non tutte le implementazioni te lo forniscono.

La domanda se questa funzione viene chiamata in fase di esecuzione o se è statica disattivata al momento della compilazione non è in genere un problema, perché si verifica comunque solo una volta.

Ho appena trovato questo articolo di Danny Kalev che ha un ottimo consiglio per C ++ 14 e versioni successive.

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

Ho pensato che fosse abbastanza bello (anche se avrei usato il PI di massima precisione possibile), soprattutto perché i modelli possono usarlo in base al tipo.

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>

Valori come M_PI, M_PI_2, M_PI_4, ecc. Non sono C ++ standard, quindi un constexpr sembra una soluzione migliore. Esistono diverse espressioni const che calcolano lo stesso pi e mi preoccupa se (tutti) mi forniscono la massima precisione. Lo standard C ++ non menziona esplicitamente come calcolare pi. Pertanto, tendo a definire pi manualmente. Vorrei condividere la soluzione di seguito che supporta tutti i tipi di frazioni di pi con la massima precisione.

#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;
}

Su windows (cygwin + g ++), ho trovato necessario aggiungere il flag -D_XOPEN_SOURCE=500per il preprocessore per elaborare la definizione di M_PIin math.h.

C ++ 14 ti consente di farlo static constexpr auto pi = acos(-1);

Alcune soluzioni eleganti. Dubito tuttavia che la precisione delle funzioni trigonometriche sia uguale alla precisione dei tipi. Per quelli che preferiscono scrivere un valore costante, questo funziona per g ++: -

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

La precisione di 256 cifre decimali dovrebbe essere sufficiente per qualsiasi tipo doppio futuro lungo lungo lungo. Se sono necessari altri, visitare https://www.piday.org/million/ .

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

Puoi farlo:

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

Se M_PIè già definito in cmath, questo non farà altro che includere cmath. Se M_PInon è definito (come nel caso di Visual Studio), lo definirà. In entrambi i casi, è possibile utilizzare M_PIper ottenere il valore di pi.

Questo valore di pi deriva dal qmath.h di Qt Creator.

Puoi usarlo:

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

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

Le costanti matematiche non sono definite in Standard C / C ++. Per usarli, devi prima definire _USE_MATH_DEFINESe poi includere cmatho math.h.