Constantes matemáticas - cppreference.com

De cppreference.com

Constantes (desde C++20)

Definido en el archivo de encabezado `<numbers>`
Definido en el espacio de nombres `std::numbers`
	La constante matemática e (plantilla de variables)
	log 2e (plantilla de variables)
	log 10e (plantilla de variables)
	π (plantilla de variables)
	(plantilla de variables)
	(plantilla de variables)
	ln 2 (plantilla de variables)
	ln 10 (plantilla de variables)
	√2 (plantilla de variables)
	√3 (plantilla de variables)
	(plantilla de variables)
	La constante Euler–Mascheroni (plantilla de variables)
	La constante del número aúreo Φ () (plantilla de variables)
inline constexpr double e	`e_v<double>` (constante)
inline constexpr double log2e	`log2e_v<double>` (constante)
inline constexpr double log10e	`log10e_v<double>` (constante)
inline constexpr double pi	`pi_v<double>` (constante)
inline constexpr double inv_pi	`inv_pi_v<double>` (constante)
inline constexpr double inv_sqrtpi	`inv_sqrtpi_v<double>` (constante)
inline constexpr double ln2	`ln2_v<double>` (constante)
inline constexpr double ln10	`ln10_v<double>` (constante)
inline constexpr double sqrt2	`sqrt2_v<double>` (constante)
inline constexpr double sqrt3	`sqrt3_v<double>` (constante)
inline constexpr double inv_sqrt3	`inv_sqrt3_v<double>` (constante)
inline constexpr double egamma	`egamma_v<double>` (constante)
inline constexpr double phi	`phi_v<double>` (constante)

Notas

Un programa que instancia una plantilla primaria de una plantilla de variable de una constante matemática está mal formado.

La bilioteca estándar especializa las plantillas de variable de constantes matemáticas para todos los tipos de punto flotante (es decir, float, double y long double).

Un programa puede especializar parcialmente o totalmente una plantilla de variable de una constante matemática dado que la especialización dependa de un tipo definido por el programa.

Macro de Prueba de característica
`__cpp_lib_math_constants`

Ejemplo

#include <cmath>
#include <iomanip>
#include <iostream>
#include <limits>
#include <numbers>
#include <string_view>

struct two_t {};
template <class T>
constexpr auto operator^(T base, two_t) { return base * base; }

int main()
{
    using namespace std::numbers;
    constexpr two_t ²;

    std::cout << "La respuesta es " <<
        (((std::sin(e)^²) + (std::cos(e)^²)) + 
        std::pow(e, ln2) + std::sqrt(pi) * inv_sqrtpi +
        ((std::cosh(pi)^²) - (std::sinh(pi)^²)) +
        sqrt3 * inv_sqrt3 * log2e * ln2 * log10e * ln10 *
        pi * inv_pi + (phi * phi - phi)) *
        ((sqrt2 * sqrt3)^²) << '\n';

    auto egamma_aprox = [] (unsigned const iterations) {
        long double s = 0, m = 2.0;
        for (unsigned c = 2; c != iterations; ++c, ++m) {
            const long double t = std::riemann_zeta(m) / m;
            (c & 1) == 0 ? s += t : s -= t;
        }
        return s;
    };

    constexpr std::string_view γ {"0.577215664901532860606512090082402"};

    std::cout 
        << "γ como 10⁶ sums of ±ζ(m)/m   = "
        << egamma_aprox(1'000'000) << '\n'
        << "γ como egamma_v<float>       = "
        << std::setprecision(std::numeric_limits<float>::digits10 + 1)
        << egamma_v<float> << '\n'
        << "γ como egamma_v<double>      = "
        << std::setprecision(std::numeric_limits<double>::digits10 + 1)
        << egamma_v<double> << '\n'
        << "γ como egamma_v<long double> = "
        << std::setprecision(std::numeric_limits<long double>::digits10 + 1)
        << egamma_v<long double> << '\n'
        << "γ con " << γ.length() - 1 << " dígitos de precisión = " << γ << '\n';
}

Posible salida:

La respuesta es 42
γ como 10⁶ sums of ±ζ(m)/m   = 0.577215
γ como egamma_v<float>       = 0.5772157
γ como egamma_v<double>      = 0.5772156649015329
γ como egamma_v<long double> = 0.5772156649015328606
γ con 34 dígitos de precisión = 0.577215664901532860606512090082402

Véase también

Representa una fracción racional exacta.
(plantilla de clase) [editar]