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 plantilla | Descripción | Valor de ejemplo (aproximado) |
|---|---|---|
e_v | Constante matemática e (base del logaritmo natural) | 2.718281828459045 |
log2e_v | Logaritmo de e en base 2 (log₂(e)) | 1.4426950408889634 |
log10e_v | Logaritmo de e en base 10 (log₁₀(e)) | 0.4342944819032518 |
pi_v | Constante matemática π (pi) | 3.141592653589793 |
inv_pi_v | 1/π (recíproco de π) | 0.318309886183121 |
inv_sqrtpi_v | 1/√π (recíproco de la raíz cuadrada de π) | 0.5641895835477563 |
ln2_v | Logaritmo natural de 2 (ln(2)) | 0.6931471805599453 |
ln10_v | Logaritmo 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_v | 1/√3 (recíproco de la raíz cuadrada de 3) | 0.5773502691896257 |
egamma_v | Constante de Euler-Mascheroni γ (Euler-Mascheroni constant) | 0.5772156649015329 |
phi_v | Proporción áurea Φ ((1 + √5) / 2) | 1.618033988749895 |
e | Constante e (equivalente ae_v<double>) | 2.718281828459045 |
log2e | Constante log₂(e) (equivalente alog2e_v<double>) | 1.4426950408889634 |
log10e | Constante log₁₀(e) (equivalente alog10e_v<double>) | 0.4342944819032518 |
pi | Constante π (equivalente api_v<double>) | 3.141592653589793 |
inv_pi | Constante 1/π (equivalente ainv_pi_v<double>) | 0.318309886183121 |
inv_sqrtpi | Constante 1/√π (equivalente ainv_sqrtpi_v<double>) | 0.5641895835477563 |
ln2 | Constante ln(2) (equivalente aln2_v<double>) | 0.6931471805599453 |
ln10 | Constante ln(10) (equivalente aln10_v<double>) | 2.302585092994046 |
sqrt2 | Constante √2 (equivalente asqrt2_v<double>) | 1.4142135623730951 |
sqrt3 | Constante √3 (equivalente asqrt3_v<double>) | 1.7320508075688772 |
inv_sqrt3 | Constante 1/√3 (equivalente ainv_sqrt3_v<double>) | 0.5773502691896257 |
egamma | Constante γ (constante de Euler-Mascheroni) (equivalente aegamma_v<double>) | 0.5772156649015329 |
phi | Constante 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 <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 usa
fixedysetprecision()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 calcularon
sin(π/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 usa
numbers::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 calcular
sin, 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 <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 <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 <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 <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;
}