Comment utiliser la constante PI en C ++

Je veux utiliser la constante PI et les fonctions trigonométriques dans certains programmes C ++. J'obtiens les fonctions trigonométriques avec include <math.h>. Cependant, il ne semble pas y avoir de définition de PI dans ce fichier d'en-tête.

Comment puis-je obtenir PI sans le définir manuellement?

Sur certaines plateformes (en particulier les plus anciennes) (voir les commentaires ci-dessous), vous devrez peut-être

#define _USE_MATH_DEFINES

puis inclure le fichier d'en-tête nécessaire:

#include <math.h>

et la valeur de pi est accessible via:

M_PI

Dans mon math.h(2014), il est défini comme:

# define M_PI           3.14159265358979323846  /* pi */

mais vérifiez votre math.hpour plus. Un extrait de "l'ancien" math.h(en 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.
 */

Toutefois:

1. sur les plates-formes plus récentes (au moins sur mon Ubuntu 64.04 64 bits), je n'ai pas besoin de définir _USE_MATH_DEFINES

2. Sur les plates-formes Linux (récentes), des long doublevaleurs sont également fournies en tant qu'extension GNU:

   # define M_PIl          3.141592653589793238462643383279502884L /* pi */

Pi peut être calculé comme atan(1)*4. Vous pouvez calculer la valeur de cette façon et la mettre en cache.

Vous pouvez également utiliser boost, qui définit des constantes mathématiques importantes avec une précision maximale pour le type demandé (c'est-à-dire float vs double).

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

Consultez la documentation de boost pour plus d'exemples.

Obtenez-le de l'unité FPU sur puce à la place:

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

double PI = get_PI();

Je recommanderais simplement de taper pi avec la précision dont vous avez besoin. Cela n'ajouterait aucun temps de calcul à votre exécution et serait portable sans utiliser d'en-têtes ou #defines. Le calcul d'acos ou d'atan est toujours plus cher que l'utilisation d'une valeur précalculée.

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

Plutôt que d'écrire

#define _USE_MATH_DEFINES

Je recommanderais d'utiliser -D_USE_MATH_DEFINESou en /D_USE_MATH_DEFINESfonction de votre compilateur.

De cette façon, vous êtes assuré que même dans le cas où quelqu'un inclurait l'en-tête avant vous (et sans le #define), vous aurez toujours les constantes au lieu d'une erreur de compilation obscure que vous prendrez beaucoup de temps à rechercher.

Étant donné que la bibliothèque standard officielle ne définit pas un PI constant, vous devez le définir vous-même. Donc, la réponse à votre question "Comment puis-je obtenir PI sans le définir manuellement?" est "Vous ne le faites pas - ou vous comptez sur certaines extensions spécifiques au compilateur.". Si vous n'êtes pas préoccupé par la portabilité, vous pouvez consulter le manuel de votre compilateur pour cela.

C ++ vous permet d'écrire

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

mais l'initialisation de cette constante n'est pas garantie d'être statique. Le compilateur G ++ gère cependant ces fonctions mathématiques comme intrinsèques et est capable de calculer cette expression constante au moment de la compilation.

Depuis la page de manuel Posix de 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

Enfin, il est arrivé: http://eel.is/c++draft/numbers

Je m'attends à ce que l'utilisation soit comme:

#include <numbers>
#include <iostream>

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

Je vais essayer quand le support arrivera à GCC, GCC 9.1.0 g++-9 -std=c++2ane le supporte toujours pas.

La proposition acceptée décrit:

5.0. «En-têtes» [en-têtes] Dans le tableau [tab: cpp.library.headers], un nouvel en- <math>tête doit être ajouté.

[...]

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

Il y a aussi std::numbers::ebien sûr :-) Comment calculer la constante d'Euler ou Euler propulsé en C ++?

Ces constantes utilisent la fonction de modèle de variable C ++ 14: Modèles de variable C ++ 14: quel est leur objectif? Un exemple d'utilisation?

Dans les versions précédentes du projet, la constante était sous std::math::pi: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0631r7.pdf

Le C ++ standard n'a pas de constante pour PI.

De nombreux compilateurs C ++ définissent M_PIdans cmath(ou dans math.hpour C) une extension non standard. Vous devrez peut-être #define _USE_MATH_DEFINESavant de pouvoir le voir.

je ferais

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

ou

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

Je ne taperais pas π avec la précision dont vous avez besoin . Qu'est-ce que cela est même censé signifier? La précision dont vous avez besoin est la précision de T, mais nous ne savons rien T.

Vous pourriez dire: de quoi parlez-vous? Tsera float, doubleou long double. Donc, tapez simplement la précision de long double, c.-à-d.

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

Mais savez-vous vraiment qu'il n'y aura pas de nouveau type à virgule flottante dans la norme à l'avenir avec une précision encore plus élevée que long double? Non.

Et c'est pourquoi la première solution est belle. Vous pouvez être sûr que la norme surchargerait les fonctions trigonométriques pour un nouveau type.

Et s'il vous plaît, ne dites pas que l'évaluation d'une fonction trigonométrique à l'initialisation est une pénalité de performance.

J'utilise le suivi dans l'un de mes en-têtes communs dans le projet qui couvre toutes les bases:

#define _USE_MATH_DEFINES
#include <cmath>

#ifndef M_PI
#define M_PI (3.14159265358979323846)
#endif

#ifndef M_PIl
#define M_PIl (3.14159265358979323846264338327950288)
#endif

En passant, tous les compilateurs ci-dessous définissent les constantes M_PI et M_PIl si vous les incluez <cmath>. Il n'est pas nécessaire d'ajouter `#define _USE_MATH_DEFINES qui n'est requis que pour VC ++.

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

Je préfère généralement définir la mienne: const double PI = 2*acos(0.0);car toutes les implémentations ne vous la fournissent pas.

La question de savoir si cette fonction est appelée au moment de l'exécution ou est statique au moment de la compilation n'est généralement pas un problème, car elle ne se produit qu'une seule fois de toute façon.

Je viens de tomber sur cet article de Danny Kalev qui a une excellente astuce pour C ++ 14 et plus.

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

Je pensais que c'était assez cool (même si j'utiliserais le PI le plus précis possible), surtout parce que les modèles peuvent l'utiliser en fonction du type.

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>

Des valeurs comme M_PI, M_PI_2, M_PI_4, etc. ne sont pas du C ++ standard, donc un constexpr semble une meilleure solution. Différentes expressions const peuvent être formulées qui calculent le même pi et je me demande si elles (toutes) me fournissent la précision totale. Le standard C ++ ne mentionne pas explicitement comment calculer pi. Par conséquent, j'ai tendance à revenir à la définition de pi manuellement. Je voudrais partager la solution ci-dessous qui prend en charge toutes sortes de fractions de pi en toute précision.

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

Sur Windows (cygwin + g ++), j'ai trouvé nécessaire d'ajouter le drapeau -D_XOPEN_SOURCE=500du préprocesseur pour traiter la définition de M_PIin math.h.

C ++ 14 vous permet de faire static constexpr auto pi = acos(-1);

Quelques solutions élégantes. Je doute cependant que la précision des fonctions trigonométriques soit égale à la précision des types. Pour ceux qui préfèrent écrire une valeur constante, cela fonctionne pour g ++: -

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

La précision de 256 chiffres décimaux devrait suffire pour tout type double long long long long. Si d'autres sont nécessaires, visitez https://www.piday.org/million/ .

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

Tu peux le faire:

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

Si M_PIest déjà défini dans cmath, cela ne fera rien d'autre que d'inclure cmath. S'il M_PIn'est pas défini (ce qui est le cas par exemple dans Visual Studio), il le définira. Dans les deux cas, vous pouvez utiliser M_PIpour obtenir la valeur de pi.

Cette valeur de pi provient du qmath.h de Qt Creator.

Vous pouvez utiliser cela:

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

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

Les constantes mathématiques ne sont pas définies dans le standard C / C ++. Pour les utiliser, vous devez d'abord définir _USE_MATH_DEFINESpuis inclure cmathou math.h.