[libc++] Implement <numbers>

[tambre]

Summary

Constants have 33 significant decimal digits for IEEE 754 128-bit floating-point numbers.

[tambre]

Is docs/TestingLibcxx.rst up-to-date? I can't find the lit.site.cfg for libc++ in my build directory to be able to run tests locally. I do see others for libc++ benchmarks and LLVM components.

[tambre]

Add version macro

[tambre]

libcxx/utils/generate_feature_test_macro_components.py

590

Minor fix for Python 3.

[rsmith]

Should we have some kind of test coverage that the values of these constants are correct?

libcxx/test/std/numerics/numbers/non_floating_point.fail.cpp

13–25 ↗

(On Diff #255285)

These are all missing their template arguments. I'm not sure exactly what this test is checking for, but I'm assuming it's not that these result in parse errors. (Should these tests omit the _v to check for a narrowing conversion, or should they include the <int> to check the floating-point constraint?)

libcxx/test/std/numerics/numbers/user_type.pass.cpp

19–31

These are similarly missing their template arguments.

[tambre]

In D77505#1965306, @rsmith wrote:

Should we have some kind of test coverage that the values of these constants are correct?

How would we test constants?

Regarding tests, as I mentioned in my comment, I couldn't figure out how to run libc++ tests locally, so I wrote them blindly. Maybe I missed something, I'll try again tonight.

[tambre]

Fix floating point constraint tests, remove bad test

libcxx/test/std/numerics/numbers/non_floating_point.fail.cpp

13–25 ↗

(On Diff #255285)

This was meant to test "Pursuant to [namespace.std], a program may partially or explicitly specialize a mathematical constant variable template provided that the specialization depends on a program-defined type."
I've removed this test for now, as I'm not sure how to properly test this and if there's even a point.

libcxx/test/std/numerics/numbers/user_type.pass.cpp

19–31

Fixed. Meant to check floating point constraint.

[tambre]

ldionne: ping

[EricWF]

This needs a bunch of additional tests. Specifically of the passing kind :-)

[tambre]

Add more tests, assert on ill-formed specialization

[tambre]

In D77505#1986893, @EricWF wrote:

This needs a bunch of additional tests. Specifically of the passing kind :-)

Added a few more tests.
I have no idea what else I could test, so let me know. :)

Also added a static_assert for ill-formed programs.

[tambre]

EricWF: ping

[tambre]

ping

[kamleshbhalui]

thanks @curdeius for pointing this.
Hi @tambre
I was unaware of this work and ended of doing same work.
please take things from here D78427 which seems reasonable.
and update the this review. so i can cancel my review.

[tambre]

In D77505#2051115, @kamleshbhalui wrote:

thanks @curdeius for pointing this.
Hi @tambre
I was unaware of this work and ended of doing same work.
please take things from here D78427 which seems reasonable.
and update the this review. so i can cancel my review.

Unfortunate to have a bit of duplicated work.
I'll take a look at yours and borrow what's useful. :)

[tambre]

Borrow useful things from D78427:

• A test
• Version guard
• Double include test

Rebased on master.

[tambre]

Adding a few reviewers from D78427 so they can take a look at this too.

[kamleshbhalui]

In D77505#2051950, @tambre wrote:

Borrow useful things from D78427:

• A test
• Version guard
• Double include test

Rebased on master.

you can also take comments like
https://oeis.org/A001113 for e.

[tambre]

In D77505#2052012, @kamleshbhalui wrote:

In D77505#2051950, @tambre wrote:

Borrow useful things from D78427:

• A test
• Version guard
• Double include test

Rebased on master.

you can also take comments like
https://oeis.org/A001113 for e.

I didn't add those, as I don't think it'd be appropriate to link to an external site in standard library headers.

[curdeius]

libcxx/test/std/numerics/numbers/specialize.pass.cpp

14

Typo: instantiations.

[tambre]

Fix typo in a comment.

[curdeius]

LGTM. But you need to wait for a review from somebody from libc++ group.

[ldionne]

Thanks for the contribution, and thanks to other reviewers for taking a look before!

To run the tests, perform the CMake configuration step, then run ninja -C <build-dir> check-cxx-deps, and then <build-dir>/bin/llvm-lit -sv libcxx/test/std/<whatever>.

libcxx/include/numbers

104

I don't see that concept defined inside <numbers> in http://wg21.link/p0631 -- should this be kept as an implementation detail instead?

Or was it moved there by another paper? In all cases, if that is public according to the Standard, please add tests for it.

libcxx/test/std/numerics/numbers/illformed.fail.cpp

17

Can you make this test a .verify.cpp instead?

libcxx/test/std/numerics/numbers/specialize.pass.cpp

20

We should put all these tests in a constexpr function, and call it from a non-constexpr context and a constexpr context.

libcxx/test/std/numerics/numbers/value.pass.cpp

15

Same here, we should put all these as asserts inside a constexpr function, and call it from a constexpr context but also a runtime context. Otherwise, we're only testing the constexpr version, which doesn't take the same code path inside the compiler (no codegen, etc).

32

Please also check the specialization of foo_v<double> explicitly. Other implementations could conceivably not rely on that specialization to implement e.g. inv_pi.

[tambre]

Address comments.

[tambre]

I've addressed the comments.

libcxx/include/numbers

104

Yes, this is an implementation detail. I've prefixed it with two underscores now.

Technically this should be std::floating_point from the concepts library, but libc++ doesn't have a full implementation of that yet. Besides, it seems a bit heavy to pull in <concepts> just for one thing, when it's simple enough to define here.

[ldionne]

libcxx/test/std/numerics/numbers/specialize.pass.cpp

16

Indentation:

#if ...
#   pragma ...
#endif

20

I don't feel like you really addressed my comment -- my point was:

constexpr bool tests()
{
    float f0{std::numbers::e_v<float>};
    ...
}

Then, call that from a constexpr and a non-constexpr context.

Furthermore, you should probably try taking the address of these things to make sure they are defined somewhere.

81

Use static_assert here please, it's what we usually do.

libcxx/test/std/numerics/numbers/value.pass.cpp

15

My point was:

constexpr bool tests()
{
    assert(std::numbers::e == ...);
    ...
}

Otherwise you're still only using these constants from a constexpr context, i.e. the static_assert they appear in.

85

static_assert

[tambre]

Address comments.
Add test checking if the numbers are defined.

[tambre]

Hopefully I've managed to address the comments correctly this time around.

libcxx/test/std/numerics/numbers/specialize.pass.cpp

16

Unfortunately clang-format doesn't agree and will try to revert the indentation. Fixed manually.

[ldionne]

libcxx/test/std/numerics/numbers/specialize.pass.cpp

16

We don't use clang-format (yet) in libc++.

[tambre]

Please commit this for me in case no one else has objections. I lack commit privileges.

[kamleshbhalui]

In D77505#2102613, @tambre wrote:

Please commit this for me in case no one else has objections. I lack commit privileges.

name and email?

[tambre]

In D77505#2102705, @kamleshbhalui wrote:

In D77505#2102613, @tambre wrote:

Please commit this for me in case no one else has objections. I lack commit privileges.

name and email?

Raul Tambre <[e-mail]>

[ldionne]

@tambre What compiler(s) did you test this with? It's breaking pretty much all of the bots because of unguarded concepts use (I think -- haven't looked thoroughly yet).

[ldionne]

In D77505#2103503, @ldionne wrote:

@tambre What compiler(s) did you test this with? It's breaking pretty much all of the bots because of unguarded concepts use (I think -- haven't looked thoroughly yet).

Sorry, I had not seen https://reviews.llvm.org/D82171 yet. Thanks for being on top of this.

[tambre]

In D77505#2103503, @ldionne wrote:

@tambre What compiler(s) did you test this with? It's breaking pretty much all of the bots because of unguarded concepts use (I think -- haven't looked thoroughly yet).

I tested only with Clang. I'll make sure to test with GCC too in the future.

Thanks for fixing up D82171 while I was away.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_generic_unordered_lookup``            *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_interpolate``                         ``201902L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_is_constant_evaluated``               ``201811L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_list_remove_return_type``             ``201806L``      
     ------------------------------------------------- -----------------
+    ``__cpp_lib_math_constants``                      ``201907L``      
+    ------------------------------------------------- -----------------
     ``__cpp_lib_ranges``                              *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_span``                                ``202002L``      
     ------------------------------------------------- -----------------
     ``__cpp_lib_three_way_comparison``                *unimplemented*  
     ------------------------------------------------- -----------------
     ``__cpp_lib_to_array``                            ``201907L``      
     ================================================= =================
 
 

libcxx/docs/ReleaseNotes.rst

 see the `releases page <https://llvm.org/releases/>`_.
 
 What's New in Libc++ 11.0.0?
 ============================
 
 New Features
 ------------
 
+- ``<numbers>``
+
 API Changes
 -----------
 - ...

libcxx/include/CMakeLists.txt

set(files
   locale
   locale.h
   map
   math.h
   memory
   module.modulemap
   mutex
   new
+  numbers
   numeric
   optional
   ostream
   queue
   random
   ratio
   regex
   scoped_allocator

libcxx/include/module.modulemap

module std [system] {
   module mutex {
     header "mutex"
     export *
   }
   module new {
     header "new"
     export *
   }
+  module numbers {
+    header "numbers"
+    export *
+  }
   module numeric {
     header "numeric"
     export *
   }
   module optional {
     header "optional"
     export *
   }

libcxx/include/numbers

+// -*- C++ -*-
+//===---------------------------- numbers ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_NUMBERS
+#define _LIBCPP_NUMBERS
+
+/*
+    numbers synopsis
+
+namespace std::numbers {
+  template<class T> inline constexpr T e_v          = unspecified;
+  template<class T> inline constexpr T log2e_v      = unspecified;
+  template<class T> inline constexpr T log10e_v     = unspecified;
+  template<class T> inline constexpr T pi_v         = unspecified;
+  template<class T> inline constexpr T inv_pi_v     = unspecified;
+  template<class T> inline constexpr T inv_sqrtpi_v = unspecified;
+  template<class T> inline constexpr T ln2_v        = unspecified;
+  template<class T> inline constexpr T ln10_v       = unspecified;
+  template<class T> inline constexpr T sqrt2_v      = unspecified;
+  template<class T> inline constexpr T sqrt3_v      = unspecified;
+  template<class T> inline constexpr T inv_sqrt3_v  = unspecified;
+  template<class T> inline constexpr T egamma_v     = unspecified;
+  template<class T> inline constexpr T phi_v        = unspecified;
+
+  template<floating_point T> inline constexpr T e_v<T>          = see below;
+  template<floating_point T> inline constexpr T log2e_v<T>      = see below;
+  template<floating_point T> inline constexpr T log10e_v<T>     = see below;
+  template<floating_point T> inline constexpr T pi_v<T>         = see below;
+  template<floating_point T> inline constexpr T inv_pi_v<T>     = see below;
+  template<floating_point T> inline constexpr T inv_sqrtpi_v<T> = see below;
+  template<floating_point T> inline constexpr T ln2_v<T>        = see below;
+  template<floating_point T> inline constexpr T ln10_v<T>       = see below;
+  template<floating_point T> inline constexpr T sqrt2_v<T>      = see below;
+  template<floating_point T> inline constexpr T sqrt3_v<T>      = see below;
+  template<floating_point T> inline constexpr T inv_sqrt3_v<T>  = see below;
+  template<floating_point T> inline constexpr T egamma_v<T>     = see below;
+  template<floating_point T> inline constexpr T phi_v<T>        = see below;
+
+  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     = inv_pi_v<double>;
+  inline constexpr double inv_sqrtpi = inv_sqrtpi_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  = inv_sqrt3_v<double>;
+  inline constexpr double egamma     = egamma_v<double>;
+  inline constexpr double phi        = phi_v<double>;
+}
+*/
+
+#include <__config>
+
+#if _LIBCPP_STD_VER > 17
+
+#include <type_traits>
+#include <version>
+
+#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
+#pragma GCC system_header
+#endif
+
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+namespace numbers {
+
+template <class T>
+inline constexpr bool __false = false;
+
+template <class T>
+struct __illformed
+{
+  static_assert(__false<T>, "A program that instantiates a primary template of a mathematical constant variable template is ill-formed.");
+};
+
+template <class T> inline constexpr T e_v =          __illformed<T>{};
+template <class T> inline constexpr T log2e_v =      __illformed<T>{};
+template <class T> inline constexpr T log10e_v =     __illformed<T>{};
+template <class T> inline constexpr T pi_v =         __illformed<T>{};
+template <class T> inline constexpr T inv_pi_v =     __illformed<T>{};
+template <class T> inline constexpr T inv_sqrtpi_v = __illformed<T>{};
+template <class T> inline constexpr T ln2_v =        __illformed<T>{};
+template <class T> inline constexpr T ln10_v =       __illformed<T>{};
+template <class T> inline constexpr T sqrt2_v =      __illformed<T>{};
+template <class T> inline constexpr T sqrt3_v =      __illformed<T>{};
+template <class T> inline constexpr T inv_sqrt3_v =  __illformed<T>{};
+template <class T> inline constexpr T egamma_v =     __illformed<T>{};
+template <class T> inline constexpr T phi_v =        __illformed<T>{};
+
+template <class T>
+concept floating_point = std::is_floating_point_v<T>;
+
+template <floating_point T> inline constexpr T e_v<T>          = 2.718281828459045235360287471352662;
+template <floating_point T> inline constexpr T log2e_v<T>      = 1.442695040888963407359924681001892;
+template <floating_point T> inline constexpr T log10e_v<T>     = 0.434294481903251827651128918916605;
+template <floating_point T> inline constexpr T pi_v<T>         = 3.141592653589793238462643383279502;
+template <floating_point T> inline constexpr T inv_pi_v<T>     = 0.318309886183790671537767526745028;
+template <floating_point T> inline constexpr T inv_sqrtpi_v<T> = 0.564189583547756286948079451560772;
+template <floating_point T> inline constexpr T ln2_v<T>        = 0.693147180559945309417232121458176;
+template <floating_point T> inline constexpr T ln10_v<T>       = 2.302585092994045684017991454684364;
+template <floating_point T> inline constexpr T sqrt2_v<T>      = 1.414213562373095048801688724209698;
+template <floating_point T> inline constexpr T sqrt3_v<T>      = 1.732050807568877293527446341505872;
+template <floating_point T> inline constexpr T inv_sqrt3_v<T>  = 0.577350269189625764509148780501957;
+template <floating_point T> inline constexpr T egamma_v<T>     = 0.577215664901532860606512090082402;
+template <floating_point T> inline constexpr T phi_v<T>        = 1.618033988749894848204586834365638;
+
+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     = inv_pi_v<double>;
+inline constexpr double inv_sqrtpi = inv_sqrtpi_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  = inv_sqrt3_v<double>;
+inline constexpr double egamma     = egamma_v<double>;
+inline constexpr double phi        = phi_v<double>;
+
+} // namespace numbers
+
+_LIBCPP_END_NAMESPACE_STD
+
+_LIBCPP_POP_MACROS
+
+#endif //_LIBCPP_STD_VER > 17
+
+#endif // _LIBCPP_NUMBERS

libcxx/include/version

 __cpp_lib_is_swappable                                  201603L <type_traits>
 __cpp_lib_launder                                       201606L <new>
 __cpp_lib_list_remove_return_type                       201806L <forward_list> <list>
 __cpp_lib_logical_traits                                201510L <type_traits>
 __cpp_lib_make_from_tuple                               201606L <tuple>
 __cpp_lib_make_reverse_iterator                         201402L <iterator>
 __cpp_lib_make_unique                                   201304L <memory>
 __cpp_lib_map_try_emplace                               201411L <map>
+__cpp_lib_math_constants                                201907L <numbers>
 __cpp_lib_math_special_functions                        201603L <cmath>
 __cpp_lib_memory_resource                               201603L <memory_resource>
 __cpp_lib_node_extract                                  201606L <map> <set> <unordered_map>
                                                                 <unordered_set>
 __cpp_lib_nonmember_container_access                    201411L <iterator> <array> <deque>
                                                                 <forward_list> <list> <map>
                                                                 <regex> <set> <string>
                                                                 <unordered_map> <unordered_set> <vector>

 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             202002L
 // # define __cpp_lib_generic_unordered_lookup             201811L
 # define __cpp_lib_interpolate                          201902L
 # if !defined(_LIBCPP_HAS_NO_BUILTIN_IS_CONSTANT_EVALUATED)
 #   define __cpp_lib_is_constant_evaluated              201811L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
+# define __cpp_lib_math_constants                       201907L
 // # define __cpp_lib_ranges                               201811L
 # define __cpp_lib_span                                 202002L
 // # define __cpp_lib_three_way_comparison                 201711L
 # define __cpp_lib_to_array                             201907L
 #endif
 
 #endif // _LIBCPP_VERSIONH

libcxx/test/libcxx/double_include.sh.cpp

 #include <locale.h>
 #include <map>
 #include <math.h>
 #include <memory>
 #ifndef _LIBCPP_HAS_NO_THREADS
 #include <mutex>
 #endif
 #include <new>
+#include <numbers>
 #include <numeric>
 #include <optional>
 #include <ostream>
 #include <queue>
 #include <random>
 #include <ratio>
 #include <regex>
 #include <scoped_allocator>

libcxx/test/std/language.support/support.limits/support.limits.general/numbers.version.pass.cpp

+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// WARNING: This test was generated by generate_feature_test_macro_components.py
+// and should not be edited manually.
+
+// <numbers>
+
+// Test the feature test macros defined by <numbers>
+
+/*  Constant                    Value
+    __cpp_lib_math_constants    201907L [C++2a]
+*/
+
+#include <numbers>
+#include "test_macros.h"
+
+#if TEST_STD_VER < 14
+
+# ifdef __cpp_lib_math_constants
+#   error "__cpp_lib_math_constants should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 14
+
+# ifdef __cpp_lib_math_constants
+#   error "__cpp_lib_math_constants should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER == 17
+
+# ifdef __cpp_lib_math_constants
+#   error "__cpp_lib_math_constants should not be defined before c++2a"
+# endif
+
+#elif TEST_STD_VER > 17
+
+# ifndef __cpp_lib_math_constants
+#   error "__cpp_lib_math_constants should be defined in c++2a"
+# endif
+# if __cpp_lib_math_constants != 201907L
+#   error "__cpp_lib_math_constants should have the value 201907L in c++2a"
+# endif
+
+#endif // TEST_STD_VER > 17
+
+int main(int, char**) { return 0; }

libcxx/test/std/language.support/support.limits/support.limits.general/version.version.pass.cpp

/*  Constant                                       Value
     __cpp_lib_is_swappable                         201603L [C++17]
     __cpp_lib_launder                              201606L [C++17]
     __cpp_lib_list_remove_return_type              201806L [C++2a]
     __cpp_lib_logical_traits                       201510L [C++17]
     __cpp_lib_make_from_tuple                      201606L [C++17]
     __cpp_lib_make_reverse_iterator                201402L [C++14]
     __cpp_lib_make_unique                          201304L [C++14]
     __cpp_lib_map_try_emplace                      201411L [C++17]
+    __cpp_lib_math_constants                       201907L [C++2a]
     __cpp_lib_math_special_functions               201603L [C++17]
     __cpp_lib_memory_resource                      201603L [C++17]
     __cpp_lib_node_extract                         201606L [C++17]
     __cpp_lib_nonmember_container_access           201411L [C++17]
     __cpp_lib_not_fn                               201603L [C++17]
     __cpp_lib_null_iterators                       201304L [C++14]
     __cpp_lib_optional                             201606L [C++17]
     __cpp_lib_parallel_algorithm                   201603L [C++17]

 # ifdef __cpp_lib_make_unique
 #   error "__cpp_lib_make_unique should not be defined before c++14"
 # endif
 
 # ifdef __cpp_lib_map_try_emplace
 #   error "__cpp_lib_map_try_emplace should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_math_constants
+#   error "__cpp_lib_math_constants should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_math_special_functions
 #   error "__cpp_lib_math_special_functions should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should not be defined before c++17"
 # endif
 

 # if __cpp_lib_make_unique != 201304L
 #   error "__cpp_lib_make_unique should have the value 201304L in c++14"
 # endif
 
 # ifdef __cpp_lib_map_try_emplace
 #   error "__cpp_lib_map_try_emplace should not be defined before c++17"
 # endif
 
+# ifdef __cpp_lib_math_constants
+#   error "__cpp_lib_math_constants should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_math_special_functions
 #   error "__cpp_lib_math_special_functions should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_memory_resource
 #   error "__cpp_lib_memory_resource should not be defined before c++17"
 # endif
 

 
 # ifndef __cpp_lib_map_try_emplace
 #   error "__cpp_lib_map_try_emplace should be defined in c++17"
 # endif
 # if __cpp_lib_map_try_emplace != 201411L
 #   error "__cpp_lib_map_try_emplace should have the value 201411L in c++17"
 # endif
 
+# ifdef __cpp_lib_math_constants
+#   error "__cpp_lib_math_constants should not be defined before c++2a"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_math_special_functions
 #     error "__cpp_lib_math_special_functions should be defined in c++17"
 #   endif
 #   if __cpp_lib_math_special_functions != 201603L
 #     error "__cpp_lib_math_special_functions should have the value 201603L in c++17"
 #   endif
 # else // _LIBCPP_VERSION

 
 # ifndef __cpp_lib_map_try_emplace
 #   error "__cpp_lib_map_try_emplace should be defined in c++2a"
 # endif
 # if __cpp_lib_map_try_emplace != 201411L
 #   error "__cpp_lib_map_try_emplace should have the value 201411L in c++2a"
 # endif
 
+# ifndef __cpp_lib_math_constants
+#   error "__cpp_lib_math_constants should be defined in c++2a"
+# endif
+# if __cpp_lib_math_constants != 201907L
+#   error "__cpp_lib_math_constants should have the value 201907L in c++2a"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_math_special_functions
 #     error "__cpp_lib_math_special_functions should be defined in c++2a"
 #   endif
 #   if __cpp_lib_math_special_functions != 201603L
 #     error "__cpp_lib_math_special_functions should have the value 201603L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION

libcxx/test/std/numerics/numbers/illformed.fail.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+#include <numbers>
+
+// Initializing the primary template is ill-formed.
+int log2e{std::numbers::log2e_v<
+    int>}; // expected-error-re@numbers:* {{static_assert failed {{.*}} "A program that instantiates a primary template of a mathematical constant variable template is ill-formed."}}
+int log10e{std::numbers::log10e_v<int>};
+int pi{std::numbers::pi_v<int>};
+int inv_pi{std::numbers::inv_pi_v<int>};
+int inv_sqrtpi{std::numbers::inv_sqrtpi_v<int>};
+int ln2{std::numbers::ln2_v<int>};
+int ln10{std::numbers::ln10_v<int>};
+int sqrt2{std::numbers::sqrt2_v<int>};
+int sqrt3{std::numbers::sqrt3_v<int>};
+int inv_sqrt3{std::numbers::inv_sqrt3_v<int>};
+int egamma{std::numbers::egamma_v<int>};
+int phi{std::numbers::phi_v<int>};
+
+int main() { return 0; }

libcxx/test/std/numerics/numbers/specialize.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+#include <numbers>
+
+// We are testing if template instatiation works. Don't care if the result is unused.
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wunused-variable"
+#endif
+
+constexpr float f0{std::numbers::e_v<float>};
+constexpr float f1{std::numbers::log2e_v<float>};
+constexpr float f2{std::numbers::log10e_v<float>};
+constexpr float f3{std::numbers::pi_v<float>};
+constexpr float f4{std::numbers::inv_pi_v<float>};
+constexpr float f5{std::numbers::inv_sqrtpi_v<float>};
+constexpr float f6{std::numbers::ln2_v<float>};
+constexpr float f7{std::numbers::ln10_v<float>};
+constexpr float f8{std::numbers::sqrt2_v<float>};
+constexpr float f9{std::numbers::sqrt3_v<float>};
+constexpr float f10{std::numbers::inv_sqrt3_v<float>};
+constexpr float f11{std::numbers::egamma_v<float>};
+constexpr float f12{std::numbers::phi_v<float>};
+
+constexpr double d0{std::numbers::e_v<double>};
+constexpr double d1{std::numbers::log2e_v<double>};
+constexpr double d2{std::numbers::log10e_v<double>};
+constexpr double d3{std::numbers::pi_v<double>};
+constexpr double d4{std::numbers::inv_pi_v<double>};
+constexpr double d5{std::numbers::inv_sqrtpi_v<double>};
+constexpr double d6{std::numbers::ln2_v<double>};
+constexpr double d7{std::numbers::ln10_v<double>};
+constexpr double d8{std::numbers::sqrt2_v<double>};
+constexpr double d9{std::numbers::sqrt3_v<double>};
+constexpr double d10{std::numbers::inv_sqrt3_v<double>};
+constexpr double d11{std::numbers::egamma_v<double>};
+constexpr double d12{std::numbers::phi_v<double>};
+
+static_assert(d0 == std::numbers::e, "d != std::numbers::e");
+static_assert(d1 == std::numbers::log2e, "d1 != std::numbers::log2e");
+static_assert(d2 == std::numbers::log10e, "d2 != std::numbers::log10e");
+static_assert(d3 == std::numbers::pi, "d3 != std::numbers::pi");
+static_assert(d4 == std::numbers::inv_pi, "d4 != std::numbers::inv_pi");
+static_assert(d5 == std::numbers::inv_sqrtpi, "d5 != std::numbers::inv_sqrtpi");
+static_assert(d6 == std::numbers::ln2, "d6 != std::numbers::ln2");
+static_assert(d7 == std::numbers::ln10, "d7 != std::numbers::ln10");
+static_assert(d8 == std::numbers::sqrt2, "d8 != std::numbers::sqrt2");
+static_assert(d9 == std::numbers::sqrt3, "d9 != std::numbers::sqrt3");
+static_assert(d10 == std::numbers::inv_sqrt3, "d10 != std::numbers::inv_sqrt3");
+static_assert(d11 == std::numbers::egamma, "d11 != std::numbers::egamma");
+static_assert(d12 == std::numbers::phi, "d12 != std::numbers::phi");
+
+constexpr long double ld0{std::numbers::e_v<long double>};
+constexpr long double ld1{std::numbers::log2e_v<long double>};
+constexpr long double ld2{std::numbers::log10e_v<long double>};
+constexpr long double ld3{std::numbers::pi_v<long double>};
+constexpr long double ld4{std::numbers::inv_pi_v<long double>};
+constexpr long double ld5{std::numbers::inv_sqrtpi_v<long double>};
+constexpr long double ld6{std::numbers::ln2_v<long double>};
+constexpr long double ld7{std::numbers::ln10_v<long double>};
+constexpr long double ld8{std::numbers::sqrt2_v<long double>};
+constexpr long double ld9{std::numbers::sqrt3_v<long double>};
+constexpr long double ld10{std::numbers::inv_sqrt3_v<long double>};
+constexpr long double ld11{std::numbers::egamma_v<long double>};
+constexpr long double ld12{std::numbers::phi_v<long double>};
+
+int main() { return 0; }

libcxx/test/std/numerics/numbers/user_type.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+#include <numbers>
+
+struct user {
+  int value;
+};
+
+template <>
+user std::numbers::e_v<user>{};
+
+template <>
+user std::numbers::log2e_v<user>{};
+
+template <>
+user std::numbers::log10e_v<user>{};
+
+template <>
+user std::numbers::pi_v<user>{};
+
+template <>
+user std::numbers::inv_pi_v<user>{};
+
+template <>
+user std::numbers::inv_sqrtpi_v<user>{};
+
+template <>
+user std::numbers::ln2_v<user>{};
+
+template <>
+user std::numbers::ln10_v<user>{};
+
+template <>
+user std::numbers::sqrt2_v<user>{};
+
+template <>
+user std::numbers::sqrt3_v<user>{};
+
+template <>
+user std::numbers::inv_sqrt3_v<user>{};
+
+template <>
+user std::numbers::egamma_v<user>{};
+
+template <>
+user std::numbers::phi_v<user>{};
+
+int main() { return 0; }

libcxx/test/std/numerics/numbers/value.pass.cpp

+// -*- C++ -*-
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+
+#include <numbers>
+
+static_assert(std::numbers::e == 0x1.5bf0a8b145769p+1);
+static_assert(std::numbers::e_v<long double> == 0x1.5bf0a8b145769p+1l);
+static_assert(std::numbers::e_v<float> == 0x1.5bf0a8p+1f);
+
+static_assert(std::numbers::log2e == 0x1.71547652b82fep+0);
+static_assert(std::numbers::log2e_v<long double> == 0x1.71547652b82fep+0l);
+static_assert(std::numbers::log2e_v<float> == 0x1.715476p+0f);
+
+static_assert(std::numbers::log10e == 0x1.bcb7b1526e50ep-2);
+static_assert(std::numbers::log10e_v<long double> == 0x1.bcb7b1526e50ep-2l);
+static_assert(std::numbers::log10e_v<float> == 0x1.bcb7b15p-2f);
+
+static_assert(std::numbers::pi == 0x1.921fb54442d18p+1);
+static_assert(std::numbers::pi_v<long double> == 0x1.921fb54442d18p+1l);
+static_assert(std::numbers::pi_v<float> == 0x1.921fb54p+1f);
+
+static_assert(std::numbers::inv_pi == 0x1.45f306dc9c883p-2);
+static_assert(std::numbers::inv_pi_v<long double> == 0x1.45f306dc9c883p-2l);
+static_assert(std::numbers::inv_pi_v<float> == 0x1.45f306p-2f);
+
+static_assert(std::numbers::inv_sqrtpi == 0x1.20dd750429b6dp-1);
+static_assert(std::numbers::inv_sqrtpi_v<long double> == 0x1.20dd750429b6dp-1l);
+static_assert(std::numbers::inv_sqrtpi_v<float> == 0x1.20dd76p-1f);
+
+static_assert(std::numbers::ln2 == 0x1.62e42fefa39efp-1);
+static_assert(std::numbers::ln2_v<long double> == 0x1.62e42fefa39efp-1l);
+static_assert(std::numbers::ln2_v<float> == 0x1.62e42fp-1f);
+
+static_assert(std::numbers::ln10 == 0x1.26bb1bbb55516p+1);
+static_assert(std::numbers::ln10_v<long double> == 0x1.26bb1bbb55516p+1l);
+static_assert(std::numbers::ln10_v<float> == 0x1.26bb1bp+1f);
+
+static_assert(std::numbers::sqrt2 == 0x1.6a09e667f3bcdp+0);
+static_assert(std::numbers::sqrt2_v<long double> == 0x1.6a09e667f3bcdp+0l);
+static_assert(std::numbers::sqrt2_v<float> == 0x1.6a09e6p+0f);
+
+static_assert(std::numbers::sqrt3 == 0x1.bb67ae8584caap+0);
+static_assert(std::numbers::sqrt3_v<long double> == 0x1.bb67ae8584caap+0l);
+static_assert(std::numbers::sqrt3_v<float> == 0x1.bb67aep+0f);
+
+static_assert(std::numbers::inv_sqrt3 == 0x1.279a74590331cp-1);
+static_assert(std::numbers::inv_sqrt3_v<long double> == 0x1.279a74590331cp-1l);
+static_assert(std::numbers::inv_sqrt3_v<float> == 0x1.279a74p-1f);
+
+static_assert(std::numbers::egamma == 0x1.2788cfc6fb619p-1);
+static_assert(std::numbers::egamma_v<long double> == 0x1.2788cfc6fb619p-1l);
+static_assert(std::numbers::egamma_v<float> == 0x1.2788cfp-1f);
+
+static_assert(std::numbers::phi == 0x1.9e3779b97f4a8p+0);
+static_assert(std::numbers::phi_v<long double> == 0x1.9e3779b97f4a8p+0l);
+static_assert(std::numbers::phi_v<float> == 0x1.9e3779ap+0f);
+
+int main() { return 0; }

libcxx/utils/generate_feature_test_macro_components.py

feature_test_macros = sorted([ add_version_header(x) for x in [
   {"name": "__cpp_lib_endian",
    "values": {
      "c++2a": int(201907),
    },
    "headers": ["bit"],
    },
   {"name": "__cpp_lib_to_array",
    "values": {
      "c++2a": int(201907),
    },
    "headers": ["array"],
    },
   {"name": "__cpp_lib_span",
    "values": {
      "c++2a": int(202002),
    },
    "headers": ["span"],
    },
+  {"name": "__cpp_lib_math_constants",
+   "values": {
+     "c++2a": int(201907),
+   },
+   "headers": ["numbers"],
+   },
 ]], key=lambda tc: tc["name"])
 
 def get_std_dialects():
   std_dialects = ['c++14', 'c++17', 'c++2a']
   return list(std_dialects)
 
 def get_first_std(d):
     for s in get_std_dialects():

libcxx/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P1463R1">P1463R1</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 21 - Containers library</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1464R1">P1464R1</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 22 - Iterators library</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
 
    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0325">P0325</a></td><td>LWG</td><td>to_array from LFTS with updates</td><td>Cologne</td><td>Complete</td><td>10.0</td></tr>
   <tr><td><a href="https://wg21.link/P0408">P0408</a></td><td>LWG</td><td>Efficient Access to basic_stringbuf ’s Buffer</td><td>Cologne</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0466">P0466</a></td><td>LWG</td><td>Layout-compatibility and Pointer-interconvertibility Traits</td><td>Cologne</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0553">P0553</a></td><td>LWG</td><td>Bit operations</td><td>Cologne</td><td>Complete</td><td>9.0</td></tr>
-  <tr><td><a href="https://wg21.link/P0631">P0631</a></td><td>LWG</td><td>Math Constants</td><td>Cologne</td><td></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0631">P0631</a></td><td>LWG</td><td>Math Constants</td><td>Cologne</td><td>Complete</td><td>11.0</td></tr>
   <tr><td><a href="https://wg21.link/P0645">P0645</a></td><td>LWG</td><td>Text Formatting</td><td>Cologne</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0660">P0660</a></td><td>LWG</td><td>Stop Token and Joining Thread, Rev 10</td><td>Cologne</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0784">P0784</a></td><td>CWG</td><td>More constexpr containers</td><td>Cologne</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0980">P0980</a></td><td>LWG</td><td>Making std::string constexpr</td><td>Cologne</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1004">P1004</a></td><td>LWG</td><td>Making std::vector constexpr</td><td>Cologne</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1035">P1035</a></td><td>LWG</td><td>Input Range Adaptors</td><td>Cologne</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1065">P1065</a></td><td>LWG</td><td>Constexpr INVOKE</td><td>Cologne</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1135">P1135</a></td><td>LWG</td><td>The C++20 Synchronization Library</td><td>Cologne</td><td>Complete</td><td></td></tr>