Biblioteca estándar de C++<numbers>

Antes de C++20, normalmente escribíamos las constantes matemáticas así:

const double PI = 3.14159265358979323846;

El problema es muy evidente:Precisión arbitraria, no uniforme, fácil de equivocarse, tipo no seguro. </p>

C++20 introduce oficialmente#include <numbers>, proporcionando un conjunto estandarizado de constantes matemáticas, donde el compilador garantiza la precisión y la corrección de tipos.

std::numbersEs un módulo de la biblioteca estándar introducido en C++20, que se utiliza principalmente para proporcionar un conjunto de constantes matemáticas comunes; es un repositorio estándar de constantes matemáticas y físicas.

std::numbersSe encuentra en<numbers>el archivo de cabecera, y contiene muchas constantes matemáticas, que abarcan constantes comunes como pi, la base del logaritmo natural, la proporción áurea, etc.

El uso de estas constantes en C++ puede mejorar la legibilidad, precisión y eficiencia del código, evitando definiciones repetidas y la entrada manual de valores constantes.

std::numbersVentajas en comparación con el método tradicional:

Dimensión Método tradicional <numbers>
Precisión Escritura arbitraria Alta precisión estándar
Tipo Fijo Coincidencia automática
Legibilidad Media Semántica clara
Constante en tiempo de compilación No necesariamente Siempre
Normalización Malo Nivel de biblioteca estándar

Constantes incluidas en el módulo std::numbers

El espacio de nombres std::numbers contiene los siguientes miembros:

template<floating_point T> inline constexpr T e_v<T> // 自然常数e
template<floating_point T> inline constexpr T log2e_v<T> // log2e
template<floating_point T> inline constexpr T log10e_v<T> // log10e
template<floating_point T> inline constexpr T pi_v<T> // 圆周率π
template<floating_point T> inline constexpr T inv_pi_v<T> // 1/π
template<floating_point T> inline constexpr T inv_sqrtpi_v<T> //1/根号π
template<floating_point T> inline constexpr T ln2_v<T> // ln2
template<floating_point T> inline constexpr T ln10_v<T> // ln10
template<floating_point T> inline constexpr T sqrt2_v<T> //根号2
template<floating_point T> inline constexpr T sqrt3_v<T> //根号3
template<floating_point T> inline constexpr T inv_sqrt3_v<T> // 1/根号3
template<floating_point T> inline constexpr T egamma_v<T> // 欧拉常数γ
template<floating_point T> inline constexpr T phi_v<T> // 黄金分割比Φ
inline constexpr double e = e_v<double>
inline constexpr double log2e = log2e_v<double>
inline constexpr double log10e = log10e_v<double>
inline constexpr double pi = pi_v<double>
inline constexpr double inv_pi = pi_v<double>
inline constexpr double inv_sqrtpi = pi_v<double>
inline constexpr double ln2 = ln2_v<double>
inline constexpr double ln10 = ln10_v<double>
inline constexpr double sqrt2 = sqrt2_v<double>
inline constexpr double sqrt3 = sqrt3_v<double>
inline constexpr double inv_sqrt3 = sqrt3_v<double>
inline constexpr double egamma = egamma_v<double>
inline constexpr double phi = phi_v<double>

La siguiente es la lista de constantes incluidas en std::numbers:

Constante / nombre de plantillaDescripciónValor de ejemplo (aproximado)
e_vConstante matemática e (base del logaritmo natural)2.718281828459045
log2e_vLogaritmo de e en base 2 (log₂(e))1.4426950408889634
log10e_vLogaritmo de e en base 10 (log₁₀(e))0.4342944819032518
pi_vConstante matemática π (pi)3.141592653589793
inv_pi_v1/π (recíproco de π)0.318309886183121
inv_sqrtpi_v1/√π (recíproco de la raíz cuadrada de π)0.5641895835477563
ln2_vLogaritmo natural de 2 (ln(2))0.6931471805599453
ln10_vLogaritmo natural de 10 (ln(10))2.302585092994046
sqrt2_v√2 (raíz cuadrada de 2)1.4142135623730951
sqrt3_v√3 (raíz cuadrada de 3)1.7320508075688772
inv_sqrt3_v1/√3 (recíproco de la raíz cuadrada de 3)0.5773502691896257
egamma_vConstante de Euler-Mascheroni γ (Euler-Mascheroni constant)0.5772156649015329
phi_vProporción áurea Φ ((1 + √5) / 2)1.618033988749895
eConstante e (equivalente ae_v<double>)2.718281828459045
log2eConstante log₂(e) (equivalente alog2e_v<double>)1.4426950408889634
log10eConstante log₁₀(e) (equivalente alog10e_v<double>)0.4342944819032518
piConstante π (equivalente api_v<double>)3.141592653589793
inv_piConstante 1/π (equivalente ainv_pi_v<double>)0.318309886183121
inv_sqrtpiConstante 1/√π (equivalente ainv_sqrtpi_v<double>)0.5641895835477563
ln2Constante ln(2) (equivalente aln2_v<double>)0.6931471805599453
ln10Constante ln(10) (equivalente aln10_v<double>)2.302585092994046
sqrt2Constante √2 (equivalente asqrt2_v<double>)1.4142135623730951
sqrt3Constante √3 (equivalente asqrt3_v<double>)1.7320508075688772
inv_sqrt3Constante 1/√3 (equivalente ainv_sqrt3_v<double>)0.5773502691896257
egammaConstante γ (constante de Euler-Mascheroni) (equivalente aegamma_v<double>)0.5772156649015329
phiConstante de proporción áurea Φ (equivalente aphi_v<double>)1.618033988749895

Estas constantes y plantillas de variables abarcan constantes matemáticas comunes como pi, base del logaritmo natural, proporción áurea, y ofrecen opciones de precisión mediante plantillas de variables de diferentes tipos, como float, double y long double.

Ejemplo

#include <iostream>
#include <iomanip>
#include <numbers>
#include <cmath> // para funciones matemáticas estándar sin, cos, log, etc.

using namespace std;

int main()
{
    // Usa constantes del tipo double predeterminado
    cout << fixed << setprecision(15); // Establece todas las salidas a 15 decimales

    // Imprime el valor de pi π
    cout << "El valor de pi es: " << numbers::pi << endl;

    // Imprime el valor de la base del logaritmo natural, e
    cout << "El valor de la constante natural e es: " << numbers::e << endl;

    // Imprime el valor de la raíz cuadrada de 2 (sqrt2)
    cout << "El valor de la raíz cuadrada de 2 (sqrt2) es: " << numbers::sqrt2 << endl;

    // Imprime el valor de la raíz cuadrada de 3 (sqrt3)
    cout << "El valor de la raíz cuadrada de 3 (sqrt3) es: " << numbers::sqrt3 << endl;

    // Imprime el valor de la proporción áurea phi
    cout << "El valor de la proporción áurea phi es: " << numbers::phi << endl;

    // Imprime el valor de la constante de Euler-Mascheroni egamma
    cout << "El valor de la constante de Euler-Mascheroni egamma es: " << numbers::egamma << endl;

    // Imprime el valor de 1/π (inv_pi)
    cout << "El valor de 1/π (inv_pi) es: " << numbers::inv_pi << endl;

    // Imprime el valor de 1/√π (inv_sqrtpi)
    cout << "El valor de 1/√π (inv_sqrtpi) es: " << numbers::inv_sqrtpi << endl;

    // Imprime el valor del logaritmo de e en base 2 (log2e)
    cout << "El valor del logaritmo de e en base 2 (log2e) es: " << numbers::log2e << endl;

    // Imprime el valor del logaritmo de e en base 10 (log10e)
    cout << "El valor del logaritmo de e en base 10 (log10e) es: " << numbers::log10e << endl;

    // Imprime el valor de sin(π/2)
    cout << "El valor de sin(π/2) es: " << sin(numbers::pi / 2) << endl;

    // Imprime el valor de cos(π)
    cout << "El valor de cos(π) es: " << cos(numbers::pi) << endl;

    // Imprime el valor de ln(e)
    cout << "El valor de ln(e) es: " << log(numbers::e) << endl;

    // Demuestra el uso de diferentes tipos de datos
    float pi_f = numbers::pi_v<float>;  // Usa pi de tipo float
    cout << "\npi de tipo float: " << setprecision(7) << pi_f << endl; // Muestra 7 decimales
   
    long double pi_ld = numbers::pi_v<long double>;  // Usa pi de tipo long double
    cout << "pi de tipo long double: " << setprecision(21) << pi_ld << endl; // Muestra 21 decimales

    // Calcula valores de diferentes precisiones
    cout << "\nsin(π/2) usando double: " << sin(numbers::pi / 2) << endl;
    cout << "sin(π/2) usando float: " << sin(static_cast<float>(numbers::pi) / 2) << endl;
    cout << "sin(π/2) usando long double: " << sin(static_cast<long double>(numbers::pi) / 2) << endl;

    return 0;
}

Análisis del código:

Salida formateada:

  • Se usafixedysetprecision()para asegurar un número fijo de decimales después del punto decimal en la salida. Aquí se muestran 15 decimales por defecto, pero también se puede establecer una precisión diferente para cada tipo de dato.

Cálculo de funciones matemáticas comunes:

  • Se calcularonsin(π/2)、cos(π)yln(e)funciones matemáticas comunes, y se usaroncmathfunciones de (por ejemplosin、cosylog) para mostrar cómo usar las constantes matemáticas.

Precisión de diferentes tipos de datos:

  • Se usanumbers::pi_v<float>ynumbers::pi_v<long double>para mostrar diferentes tipos de constantes. Parafloatylong double, se puede usar una precisión diferente en la salida.

Cálculo usando diferentes tipos:

  • Al calcularsin, se muestra cómo calcular con tipos de diferente precisión, demostrandofloat、doubleylong doublelas diferencias bajo la misma expresión matemática.

Salida:

圆周率 pi 的值是: 3.141592653589793
自然常数 e 的值是: 2.718281828459045
根号2 (sqrt2) 的值是: 1.414213562373095
根号3 (sqrt3) 的值是: 1.732050807568877
黄金比例 phi 的值是: 1.618033988749895
欧拉-马歇罗尼常数 egamma 的值是: 0.5772156649015329
1/π (inv_pi) 的值是: 0.318309886183121
1/√π (inv_sqrtpi) 的值是: 0.5641895835477563
以 2 为底的 e 的对数 log2e 的值是: 1.4426950408889634
以 10 为底的 e 的对数 log10e 的值是: 0.4342944819032518
sin(π/2) 的值是: 1
cos(π) 的值是: -1
ln(e) 的值是: 1

使用 float 类型的 pi: 3.1415927
使用 long double 类型的 pi: 3.141592653589793238462643
sin(π/2) 使用 double: 1
sin(π/2) 使用 float: 1
sin(π/2) 使用 long double: 1

Ejemplo de uso

Los siguientes ejemplos cubren<numbers>las constantes más utilizadas. El código se puede compilar y ejecutar directamente, recuerda añadir un parámetro estándar-std=c++20:

g++ -std=c++20 main.cpp -o main

Ejemplo 1: Uso básico

Calcular el área / circunferencia de un círculo con pi π:

Ejemplo

#include <iostream>
#include <numbers> // incluye constantes matemáticas
#include <cmath> // incluye funciones matemáticas como pow

using namespace std;
using namespace std::numbers;  // Simplifica la llamada a constantes (opcional)

int main() {
    // Radio del círculo
    double r = 5.0;

    // 1. Calcula la circunferencia del círculo: 2 * π * r
    double circumference = 2 * pi * r;  // Usa directamente la versión double de π
    cout << "Con radio " << r << ", la circunferencia es: " << circumference << endl;  // Salida: 31.4159

    // 2. Calcula el área del círculo: π * r²
    double area = pi * pow(r, 2);
    cout << "Con radio " << r << ", el área es: " << area << endl;  // Salida: 78.5398

    // 3. Versión de alta precisión (long double)
    long double r_ld = 5.0L;
    long double area_ld = pi_v<long double> * powl(r_ld, 2);  // powl es la versión long double de pow
    cout << "Área del círculo de alta precisión:" << area_ld << endl;  // Genera un valor más preciso: 78.53981633974483...

    return 0;
}

Ejemplo 2: Constante e

La constante natural e y el cálculo exponencial:

Ejemplo

#include <iostream>
#include <numbers>
#include <cmath>

using namespace std;
using namespace std::numbers;

int main() {
    // Cálculo exponencial natural: e^x (la función exp es la función exponencial en cmath)
    double x = 2.0;
    double exp_result = exp(x);          // Calcular e^2 manualmente
    double exp_result_direct = pow(e, x); // Calcular e^2 usando numbers::e
    cout << "e^2 = " << exp_result << endl;          // Salida: 7.38906
    cout << "e^2 (cálculo directo) = " << exp_result_direct << endl;  // Los resultados coinciden

    return 0;
}

Ejemplo 3: Proporción áurea

Aplicación de la proporción áurea φ:

Ejemplo

#include <iostream>
#include <numbers>

using namespace std;
using namespace std::numbers;

int main() {
    // Proporción áurea: cuando largo/ancho = φ, es un rectángulo áureo
    double width = 10.0;
    double golden_height = width * phi;  // Altura del rectángulo áureo
    cout << "Con un ancho de " << width << ", la altura del rectángulo áureo es: " << golden_height << endl;  // Salida: 16.1803

    // Verificar la definición matemática de φ: φ = (1 + √5)/2
    double phi_manual = (1 + sqrt(5.0)) / 2;
    cout << "Proporción áurea calculada manualmente:" << phi_manual << endl;  // Consistente con numbers::phi

    return 0;
}

Ejemplo 4: Tipos de coma flotante

Adaptación de constantes para diferentes tipos de punto flotante:

Ejemplo

#include <iostream>
#include <numbers>
#include <iomanip> // Se utiliza para establecer la precisión de salida

using namespace std;

int main() {
    // Establecer salida de alta precisión (mostrar 15 decimales)
    cout << fixed << setprecision(15);

    // π en versión float (precisión simple)
    float pi_float = std::numbers::pi_v<float>;
    cout << "π en versión float:" << pi_float << endl;  // Salida: 3.141592741012573

    // π en versión double (doble precisión, predeterminada)
    double pi_double = std::numbers::pi;
    cout << "π en versión double:" << pi_double << endl;  // Salida: 3.141592653589793

    // π en versión long double (alta precisión)
    long double pi_long_double = std::numbers::pi_v<long double>;
    cout << "π en versión long double:" << pi_long_double << endl;  // Genera un valor más preciso: 3.1415926535897932385...

    return 0;
}
Otras extensiones