Constantes matemáticas

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos(C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación(C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos(C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos(C++17)

Biblioteca de apoyo de concurrencia(C++11)

Biblioteca de apoyo de ejecución(C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca numérica

Funciones matemáticas comunes
Funciones matemáticas especiales(C++17)
Constantes matemáticas(C++20)
Algoritmos básicos de álgebra lineal(C++26)
Entorno de punto flotante(C++11)
Números complejos
Arrays numéricos
Generación de números pseudoaleatorios
Operaciones de factores
gcd (C++17)
lcm (C++17)
Interpolaciones
midpoint (C++20)
lerp (C++20)
Saturación aritmética
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Operaciones numéricas genéricas
iota (C++11)
ranges::iota (C++23)
accumulate
inner_product
adjacent_difference
partial_sum
reduce (C++17)
transform_reduce (C++17)
inclusive_scan (C++17)
exclusive_scan (C++17)
transform_inclusive_scan (C++17)
transform_exclusive_scan (C++17)
Operaciones de bits
bit_cast (C++20)
byteswap (C++23)
has_single_bit (C++20)
bit_ceil (C++20)
bit_floor (C++20)
bit_width (C++20)
rotl (C++20)
rotr (C++20)
countl_zero (C++20)
countl_one (C++20)
countr_zero (C++20)
countr_one (C++20)
popcount (C++20)
endian (C++20)

 

Constantes matemáticas

 

Constantes (desde C++20)

Definido en el archivo de encabezado <numbers>
Definido en el espacio de nombres std::numbers
e_v	La constante matemática e (plantilla de variables)
log2e_v	\(\log_{2}e\)log 2e (plantilla de variables)
log10e_v	\(\log_{10}e\)log 10e (plantilla de variables)
pi_v	\(\pi\)π (plantilla de variables)
inv_pi_v	\(\frac1\pi\) 1 π (plantilla de variables)
inv_sqrtpi_v	\(\frac1{\sqrt\pi}\) 1 √π (plantilla de variables)
ln2_v	\(\ln{2}\)ln 2 (plantilla de variables)
ln10_v	\(\ln{10}\)ln 10 (plantilla de variables)
sqrt2_v	\(\sqrt2\)√2 (plantilla de variables)
sqrt3_v	\(\sqrt3\)√3 (plantilla de variables)
inv_sqrt3_v	\(\frac1{\sqrt3}\) 1 √3 (plantilla de variables)
egamma_v	La constante Euler–Mascheroni (plantilla de variables)
phi_v	La constante del número aúreo Φ (\(\frac{1+\sqrt5}2\) 1 + √5 2 ) (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 longdouble).

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

Ejecuta este código

#include <cmath>#include <iomanip>#include <iostream>#include <limits>#include <numbers>#include <string_view>   struct two_t {};template<class T>constexprauto operator^(T base, two_t){return base * base;}   int main(){usingnamespace 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 =[](unsignedconst iterations){longdouble s =0, m =2.0;for(unsigned c =2; c != iterations;++c, ++m){constlongdouble t =std::riemann_zeta(m)/ m;(c &1)==0? s += t : s -= t;}return s;};   constexprstd::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<longdouble>::digits10+1)<< egamma_v<longdouble><<'\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

ratio (C++11)

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