Cómo usar la constante PI en C ++

Quiero usar la constante PI y las funciones trigonométricas en algún programa de C ++. Obtengo las funciones trigonométricas con include <math.h>. Sin embargo, no parece haber una definición para PI en este archivo de encabezado.

¿Cómo puedo obtener PI sin definirlo manualmente?

En algunas plataformas (especialmente las más antiguas) (vea los comentarios a continuación) es posible que necesite

#define _USE_MATH_DEFINES

y luego incluya el archivo de encabezado necesario:

#include <math.h>

y se puede acceder al valor de pi a través de:

M_PI

En mi math.h(2014) se define como:

# define M_PI           3.14159265358979323846  /* pi */

pero revisa tu math.hpara más. Un extracto de lo "viejo" 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.
 */

Sin embargo:

1. en plataformas más nuevas (al menos en mi Ubuntu 14.04 de 64 bits) no necesito definir el _USE_MATH_DEFINES

2. En plataformas Linux (recientes) también hay long doublevalores proporcionados como una extensión GNU:

   # define M_PIl          3.141592653589793238462643383279502884L /* pi */

Pi se puede calcular como atan(1)*4. Puede calcular el valor de esta manera y almacenarlo en caché.

También puede usar boost, que define constantes matemáticas importantes con la máxima precisión para el tipo solicitado (es decir, float vs double).

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

Consulte la documentación de impulso para obtener más ejemplos.

Obténgalo de la unidad FPU en chip en su lugar:

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

double PI = get_PI();

Recomendaría simplemente escribir pi con la precisión que necesita. Esto no agregaría tiempo de cálculo a su ejecución, y sería portátil sin usar encabezados o #defines. Calcular acos o atan siempre es más costoso que usar un valor precalculado.

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

En lugar de escribir

#define _USE_MATH_DEFINES

Recomendaría usar -D_USE_MATH_DEFINESo /D_USE_MATH_DEFINESdependiendo de su compilador.

De esta manera, tiene la seguridad de que incluso en el caso de que alguien incluya el encabezado antes de hacerlo (y sin el #define), seguirá teniendo las constantes en lugar de un oscuro error del compilador que tardará años en rastrear.

Dado que la biblioteca estándar oficial no define un PI constante, tendría que definirlo usted mismo. Entonces, la respuesta a su pregunta "¿Cómo puedo obtener PI sin definirlo manualmente?" es "No lo haces, o confías en algunas extensiones específicas del compilador". Si no le preocupa la portabilidad, puede consultar el manual de su compilador para esto.

C ++ te permite escribir

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

pero no se garantiza que la inicialización de esta constante sea estática. Sin embargo, el compilador de G ++ maneja esas funciones matemáticas como intrínsecas y puede calcular esta expresión constante en tiempo de compilación.

Desde la página de manual de 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

Por fin, ha llegado: http://eel.is/c++draft/numbers

Espero que el uso sea así:

#include <numbers>
#include <iostream>

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

Lo intentaré cuando llegue el soporte a GCC, GCC 9.1.0 con g++-9 -std=c++2atodavía no lo admite.

La propuesta aceptada describe:

5.0. “Encabezados” [encabezados] En la tabla [pestaña: cpp.library.headers], se <math>debe agregar un nuevo encabezado.

[...]

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

También hay, std::numbers::epor supuesto :-) ¿Cómo calcular la constante de Euler o Euler con C ++?

Estas constantes utilizan la función de plantilla variable C ++ 14: Plantillas variables C ++ 14: ¿cuál es su propósito? ¿Algún ejemplo de uso?

En versiones anteriores del borrador, la constante estaba en std::math::pi: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p0631r7.pdf

El estándar C ++ no tiene una constante para PI.

Muchos compiladores de C ++ se definen M_PIen cmath(o en math.hC) como una extensión no estándar. Puede que tenga que hacerlo #define _USE_MATH_DEFINESantes de poder verlo.

yo lo haría

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

o

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

Yo no escribir en π a la precisión que necesita . ¿Qué se supone que significa eso? La precisión que necesita es la precisión de T, pero no sabemos nada al respecto T.

Podrías decir: ¿De qué estás hablando? Tserá float, doubleo long double. Entonces, solo escriba la precisión de long double, es decir

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

Pero, ¿sabe realmente que no habrá un nuevo tipo de coma flotante en el estándar en el futuro con una precisión aún mayor que long double? Usted no

Y es por eso que la primera solución es hermosa. Puede estar bastante seguro de que el estándar sobrecargaría las funciones trigonométricas para un nuevo tipo.

Y, por favor, no diga que la evaluación de una función trigonométrica en la inicialización es una penalización de rendimiento.

Uso siguiente en uno de mis encabezados comunes en el proyecto que cubre todas las 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 una nota al margen, todos los compiladores a continuación definen las constantes M_PI y M_PIl si las incluye <cmath>. No es necesario agregar `#define _USE_MATH_DEFINES, que solo es necesario para VC ++.

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

Generalmente prefiero definir el mío: const double PI = 2*acos(0.0);porque no todas las implementaciones se lo proporcionan.

La cuestión de si esta función se llama en tiempo de ejecución o está estática en tiempo de compilación generalmente no es un problema, porque solo ocurre una vez de todos modos.

Acabo de encontrar este artículo de Danny Kalev que tiene un gran consejo para C ++ 14 y versiones posteriores.

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

Pensé que esto era bastante bueno (aunque usaría el PI de mayor precisión que pudiera), especialmente porque las plantillas pueden usarlo según el 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>

Los valores como M_PI, M_PI_2, M_PI_4, etc. no son C ++ estándar, por lo que un constexpr parece una mejor solución. Se pueden formular diferentes expresiones constantes que calculen el mismo pi y me preocupa si (todas) me proporcionan la precisión completa. El estándar C ++ no menciona explícitamente cómo calcular pi. Por lo tanto, tiendo a recurrir a definir pi manualmente. Me gustaría compartir la solución a continuación que admite todo tipo de fracciones de pi con total precisión.

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

En windows (cygwin + g ++), he encontrado necesario agregar el indicador -D_XOPEN_SOURCE=500para que el preprocesador procese la definición de M_PIin math.h.

C ++ 14 te permite hacer static constexpr auto pi = acos(-1);

Algunas soluciones elegantes. Sin embargo, dudo que la precisión de las funciones trigonométricas sea igual a la precisión de los tipos. Para aquellos que prefieren escribir un valor constante, esto funciona para g ++: -

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

La precisión de 256 dígitos decimales debería ser suficiente para cualquier tipo doble futuro largo largo largo. Si se requieren más, visite https://www.piday.org/million/ .

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

Puedes hacerlo:

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

Si M_PIya está definido en cmath, esto no hará nada más que incluir cmath. Si M_PIno está definido (como es el caso, por ejemplo, en Visual Studio), lo definirá. En ambos casos, puedes usarM_PI para obtener el valor de pi.

Este valor de pi proviene del qmath.h de Qt Creator.

Puedes usar eso:

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

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

Las constantes matemáticas no están definidas en el estándar C / C ++. Para usarlos, primero debe definir _USE_MATH_DEFINESy luego incluir cmatho math.h.