[libc++] P1645 constexpr for <numeric>

[Mordante]

Summary

Implements P1645: constexpr for <numeric> algorithms

[ldionne]

Or do you prefer small patches per function? (In that case I'll to update the status since it now expects one patch.)

One patch for all is fine. But it's a good idea to iterate on this one function for now until we are good to go, and then you can do the other ones. This will avoid back and forth.

libcxx/include/numeric

20

Please add // constexpr since C++20 to note that the API is only constexpr in C++20.

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp

76

The tests for runtime and constexpr should be the same. Can you please take a look at libcxx/test/std/utilities/memory/specialized.algorithms/specialized.destroy/destroy_n.pass.cpp to see how we do it elsewhere?

[Mordante]

In D90569#2371040, @ldionne wrote:

Or do you prefer small patches per function? (In that case I'll to update the status since it now expects one patch.)

One patch for all is fine. But it's a good idea to iterate on this one function for now until we are good to go, and then you can do the other ones. This will avoid back and forth.

Thanks for the feedback. Then I'll make one patch for the paper once the first function is approved.

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp

76

That's a nice approach and indeed looks better than my approach.

[Mordante]

Addresses the review comments. Adds a comment and improves the unit tests.

[Mordante]

I had another look at the header and noticed something odd for all overloads of inclusive_scan and transform_inclusive_scan and their signatures are odd

template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
                               _OutputIterator __result, _BinaryOp __b,  _Tp __init)

Instead of the expected

template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
inline _LIBCPP_INLINE_VISIBILITY
_OutputIterator
inclusive_scan(_InputIterator __first, _InputIterator __last,
               _OutputIterator __result, _BinaryOp __b,  _Tp __init)

Is there a reason why their signatures differ or is it an oversight?
Shall I fix them in this patch?

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.pass.cpp

10–11

I reverted the original change and redid the changes. I just noticed I forgot to re-add the // Became constexpr in C++20 comment here.

[ldionne]

In D90569#2371916, @Mordante wrote:

I had another look at the header and noticed something odd for all overloads of inclusive_scan and transform_inclusive_scan and their signatures are odd

template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
_OutputIterator inclusive_scan(_InputIterator __first, _InputIterator __last,
                               _OutputIterator __result, _BinaryOp __b,  _Tp __init)

Instead of the expected

template <class _InputIterator, class _OutputIterator, class _Tp, class _BinaryOp>
inline _LIBCPP_INLINE_VISIBILITY
_OutputIterator
inclusive_scan(_InputIterator __first, _InputIterator __last,
               _OutputIterator __result, _BinaryOp __b,  _Tp __init)

Is there a reason why their signatures differ or is it an oversight?
Shall I fix them in this patch?

I believe those are oversights, and the blame seems to confirm this. Good catch, and please fix them in this patch. You don't need inline though, just _LIBCPP_INLINE_VISIBILITY. These functions are already inline (i.e. linkonce-ODR) because they are templates.

On a different note, I would like to mention that I really like your approach of making sure everything's fine with a single function, and then going for the whole thing. I feel like this is a productive way to proceed, and I appreciate that.

Your approach LGTM, feel free to go ahead with the full thing!

[Mordante]

Added an updated test for libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp.

Since this tests uses std::vector which can't be used as constexpr in libc++ at the moment I took a different approach. Several other tests have the same issue. @ldionne can you have a look only at this test before I proceed?

[Mordante]

In D90569#2385641, @ldionne wrote:

In D90569#2371916, @Mordante wrote:

Is there a reason why their signatures differ or is it an oversight?
Shall I fix them in this patch?

I believe those are oversights, and the blame seems to confirm this. Good catch, and please fix them in this patch. You don't need inline though, just _LIBCPP_INLINE_VISIBILITY. These functions are already inline (i.e. linkonce-ODR) because they are templates.

Thanks will do.

On a different note, I would like to mention that I really like your approach of making sure everything's fine with a single function, and then going for the whole thing. I feel like this is a productive way to proceed, and I appreciate that.

Thanks. I also prefer this way since it saves everybody time!

[ldionne]

libcxx/test/std/numerics/numeric.ops/exclusive.scan/exclusive_scan.pass.cpp

39 ↗

(On Diff #306144)

LGTM, but could you add a FIXME to remind us to go back and fix those once constexpr std::vector is finished?

If you keep the FIXME exactly the same in all places where you use this pattern, we'll be able to search for it and easily replace all locations where we used the workaround.

[Mordante]

This should complete the implementation of P1645
Additional changes

• Since constexpr vector isn't available some test have a workaround to be tested without this feature. The changes are marked with a fixme to be removed once the support is available.
• Enables additional unit tests in libcxx/test/std/numerics/numeric.ops/inclusive.scan/inclusive_scan_op.pass.cpp. These were disabled when added, but that seems an oversight.
• Changes the changed numeric functions to all use _LIBCPP_INLINE_VISIBILITY and removed the unneeded inline.

[ldionne]

This LGTM, but I'd really like to see CI running. I added the LLVM monorepo to the revision -- can you try rebasing onto master just to see if it'll trigger CI?

[Mordante]

Thanks for the review.
I've switched to arc, so that should solve the CI issues.

[Mordante]

Rebase to trigger CI.

[Mordante]

Rebase to trigger CI.

[Mordante]

Reopened since I reverted to commit. It fails on several build bots using LLVM 8.

[Mordante]

Disable the unit tests on clang-8, they fail and we don't support these old compilers for libc++.
Switch to the new status page
Adjusted the unit tests modified in D61170 to work in constexpr evaluation. Since constexpr string isn't supported yet the std::string tests are disabled in constant evaluation context.

libcxx/docs/FeatureTestMacroTable.rst

.. table:: Current Status
     ``__cpp_lib_char8_t``                             ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_concepts``                            *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_dynamic_alloc``             ``201907L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_misc``                      *unimplemented*
     ------------------------------------------------- -----------------
+    ``__cpp_lib_constexpr_numeric``                   ``201911L``
+    ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_swap_algorithms``           *unimplemented*
     ------------------------------------------------- -----------------
     ``__cpp_lib_constexpr_utility``                   ``201811L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_destroying_delete``                   ``201806L``
     ------------------------------------------------- -----------------
     ``__cpp_lib_endian``                              ``201907L``
     ------------------------------------------------- -----------------

libcxx/include/numeric

 
 /*
     numeric synopsis
 
 namespace std
 {
 
 template <class InputIterator, class T>
-    T
+    constexpr T
     accumulate(InputIterator first, InputIterator last, T init);
 
 template <class InputIterator, class T, class BinaryOperation>
     T
     accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op);
 
 template<class InputIterator>
     typename iterator_traits<InputIterator>::value_type

 #endif
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 template <class _InputIterator, class _Tp>
-inline _LIBCPP_INLINE_VISIBILITY
+inline _LIBCPP_INLINE_VISIBILITY _LIBCPP_CONSTEXPR_AFTER_CXX17
 _Tp
 accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
 {
     for (; __first != __last; ++__first)
         __init = __init + *__first;
     return __init;
 }
 

libcxx/include/version

 __cpp_lib_chrono                                        201611L <chrono>
 __cpp_lib_chrono_udls                                   201304L <chrono>
 __cpp_lib_clamp                                         201603L <algorithm>
 __cpp_lib_complex_udls                                  201309L <complex>
 __cpp_lib_concepts                                      201806L <concepts>
 __cpp_lib_constexpr_dynamic_alloc                       201907L <memory>
 __cpp_lib_constexpr_misc                                201811L <array> <functional> <iterator>
                                                                 <string_view> <tuple> <utility>
+__cpp_lib_constexpr_numeric                             201911L <numeric>
 __cpp_lib_constexpr_swap_algorithms                     201806L <algorithm>
 __cpp_lib_constexpr_utility                             201811L <utility>
 __cpp_lib_destroying_delete                             201806L <new>
 __cpp_lib_enable_shared_from_this                       201603L <memory>
 __cpp_lib_endian                                        201907L <bit>
 __cpp_lib_erase_if                                      202002L <string> <deque> <forward_list>
                                                                 <list> <vector> <map>
                                                                 <set> <unordered_map> <unordered_set>

 // # define __cpp_lib_bind_front                           201811L
 // # define __cpp_lib_bit_cast                             201806L
 # if !defined(_LIBCPP_NO_HAS_CHAR8_T)
 #   define __cpp_lib_char8_t                            201811L
 # endif
 // # define __cpp_lib_concepts                             201806L
 # define __cpp_lib_constexpr_dynamic_alloc              201907L
 // # define __cpp_lib_constexpr_misc                       201811L
+# define __cpp_lib_constexpr_numeric                    201911L
 // # define __cpp_lib_constexpr_swap_algorithms            201806L
 # define __cpp_lib_constexpr_utility                    201811L
 # if _LIBCPP_STD_VER > 17 && defined(__cpp_impl_destroying_delete) && __cpp_impl_destroying_delete >= 201806L
 #   define __cpp_lib_destroying_delete                  201806L
 # endif
 # define __cpp_lib_endian                               201907L
 # define __cpp_lib_erase_if                             202002L
 // # define __cpp_lib_generic_unordered_lookup             201811L

libcxx/test/std/language.support/support.limits/support.limits.general/numeric.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.
 
 // <numeric>
 
 // Test the feature test macros defined by <numeric>
 
 /*  Constant                        Value
+    __cpp_lib_constexpr_numeric     201911L [C++2a]
     __cpp_lib_gcd_lcm               201606L [C++17]
     __cpp_lib_interpolate           201902L [C++2a]
     __cpp_lib_parallel_algorithm    201603L [C++17]
 */
 
 #include <numeric>
 #include "test_macros.h"
 
 #if TEST_STD_VER < 14
 
+# ifdef __cpp_lib_constexpr_numeric
+#   error "__cpp_lib_constexpr_numeric should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_gcd_lcm
 #   error "__cpp_lib_gcd_lcm should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_interpolate
 #   error "__cpp_lib_interpolate should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_parallel_algorithm
 #   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
 # endif
 
 #elif TEST_STD_VER == 14
 
+# ifdef __cpp_lib_constexpr_numeric
+#   error "__cpp_lib_constexpr_numeric should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_gcd_lcm
 #   error "__cpp_lib_gcd_lcm should not be defined before c++17"
 # endif
 
 # ifdef __cpp_lib_interpolate
 #   error "__cpp_lib_interpolate should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_parallel_algorithm
 #   error "__cpp_lib_parallel_algorithm should not be defined before c++17"
 # endif
 
 #elif TEST_STD_VER == 17
 
+# ifdef __cpp_lib_constexpr_numeric
+#   error "__cpp_lib_constexpr_numeric should not be defined before c++2a"
+# endif
+
 # ifndef __cpp_lib_gcd_lcm
 #   error "__cpp_lib_gcd_lcm should be defined in c++17"
 # endif
 # if __cpp_lib_gcd_lcm != 201606L
 #   error "__cpp_lib_gcd_lcm should have the value 201606L in c++17"
 # endif
 
 # ifdef __cpp_lib_interpolate

 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_parallel_algorithm
 #     error "__cpp_lib_parallel_algorithm should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
 #elif TEST_STD_VER > 17
 
+# ifndef __cpp_lib_constexpr_numeric
+#   error "__cpp_lib_constexpr_numeric should be defined in c++2a"
+# endif
+# if __cpp_lib_constexpr_numeric != 201911L
+#   error "__cpp_lib_constexpr_numeric should have the value 201911L in c++2a"
+# endif
+
 # ifndef __cpp_lib_gcd_lcm
 #   error "__cpp_lib_gcd_lcm should be defined in c++2a"
 # endif
 # if __cpp_lib_gcd_lcm != 201606L
 #   error "__cpp_lib_gcd_lcm should have the value 201606L in c++2a"
 # endif
 
 # ifndef __cpp_lib_interpolate

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

/*  Constant                                       Value
     __cpp_lib_char8_t                              201811L [C++2a]
     __cpp_lib_chrono                               201611L [C++17]
     __cpp_lib_chrono_udls                          201304L [C++14]
     __cpp_lib_clamp                                201603L [C++17]
     __cpp_lib_complex_udls                         201309L [C++14]
     __cpp_lib_concepts                             201806L [C++2a]
     __cpp_lib_constexpr_dynamic_alloc              201907L [C++2a]
     __cpp_lib_constexpr_misc                       201811L [C++2a]
+    __cpp_lib_constexpr_numeric                    201911L [C++2a]
     __cpp_lib_constexpr_swap_algorithms            201806L [C++2a]
     __cpp_lib_constexpr_utility                    201811L [C++2a]
     __cpp_lib_destroying_delete                    201806L [C++2a]
     __cpp_lib_enable_shared_from_this              201603L [C++17]
     __cpp_lib_endian                               201907L [C++2a]
     __cpp_lib_erase_if                             202002L [C++2a]
     __cpp_lib_exchange_function                    201304L [C++14]
     __cpp_lib_execution                            201603L [C++17]

 # ifdef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_numeric
+#   error "__cpp_lib_constexpr_numeric should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_constexpr_swap_algorithms
 #   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_utility
 #   error "__cpp_lib_constexpr_utility should not be defined before c++2a"
 # endif
 

 # ifdef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_numeric
+#   error "__cpp_lib_constexpr_numeric should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_constexpr_swap_algorithms
 #   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_utility
 #   error "__cpp_lib_constexpr_utility should not be defined before c++2a"
 # endif
 

 # ifdef __cpp_lib_constexpr_dynamic_alloc
 #   error "__cpp_lib_constexpr_dynamic_alloc should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_misc
 #   error "__cpp_lib_constexpr_misc should not be defined before c++2a"
 # endif
 
+# ifdef __cpp_lib_constexpr_numeric
+#   error "__cpp_lib_constexpr_numeric should not be defined before c++2a"
+# endif
+
 # ifdef __cpp_lib_constexpr_swap_algorithms
 #   error "__cpp_lib_constexpr_swap_algorithms should not be defined before c++2a"
 # endif
 
 # ifdef __cpp_lib_constexpr_utility
 #   error "__cpp_lib_constexpr_utility should not be defined before c++2a"
 # endif
 

 #     error "__cpp_lib_constexpr_misc should have the value 201811L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION
 #   ifdef __cpp_lib_constexpr_misc
 #     error "__cpp_lib_constexpr_misc should not be defined because it is unimplemented in libc++!"
 #   endif
 # endif
 
+# ifndef __cpp_lib_constexpr_numeric
+#   error "__cpp_lib_constexpr_numeric should be defined in c++2a"
+# endif
+# if __cpp_lib_constexpr_numeric != 201911L
+#   error "__cpp_lib_constexpr_numeric should have the value 201911L in c++2a"
+# endif
+
 # if !defined(_LIBCPP_VERSION)
 #   ifndef __cpp_lib_constexpr_swap_algorithms
 #     error "__cpp_lib_constexpr_swap_algorithms should be defined in c++2a"
 #   endif
 #   if __cpp_lib_constexpr_swap_algorithms != 201806L
 #     error "__cpp_lib_constexpr_swap_algorithms should have the value 201806L in c++2a"
 #   endif
 # else // _LIBCPP_VERSION

libcxx/test/std/numerics/numeric.ops/accumulate/accumulate.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
 //
 //===----------------------------------------------------------------------===//
 
 // <numeric>
 
+// Became constexpr in C++20
 // template <InputIterator Iter, MoveConstructible T>
 //   requires HasPlus<T, Iter::reference>
 //         && HasAssign<T, HasPlus<T, Iter::reference>::result_type>
-//   T
+//   constexpr T
 //   accumulate(Iter first, Iter last, T init);
 
 #include <numeric>
 #include <cassert>
 
 #include "test_macros.h"
 #include "test_iterators.h"
 
+#if _LIBCPP_STD_VER > 17
+template <class Iter, class T>
+constexpr T
+constexpr_test(Iter first, Iter last, T init)
+{
+    return std::accumulate(first, last, init);
+}
+
+template <class Iter>
+constexpr void
+constexpr_test()
+{
+    constexpr const int ia[] = {1, 2, 3, 4, 5, 6};
+    constexpr unsigned sa = sizeof(ia) / sizeof(ia[0]);
+
+    static_assert(constexpr_test(Iter(ia), Iter(ia), 0) == 0);
+    static_assert(constexpr_test(Iter(ia), Iter(ia), 10) == 10);
+    static_assert(constexpr_test(Iter(ia), Iter(ia + 1), 0) == 1);
+    static_assert(constexpr_test(Iter(ia), Iter(ia + 1), 10) == 11);
+    static_assert(constexpr_test(Iter(ia), Iter(ia + 2), 0) == 3);
+    static_assert(constexpr_test(Iter(ia), Iter(ia + 2), 10) == 13);
+    static_assert(constexpr_test(Iter(ia), Iter(ia + sa), 0) == 21);
+    static_assert(constexpr_test(Iter(ia), Iter(ia + sa), 10) == 31);
+}
+#endif
+
 template <class Iter, class T>
 void
-test(Iter first, Iter last, T init, T x)
+runtime_test(Iter first, Iter last, T init, T x)
 {
     assert(std::accumulate(first, last, init) == x);
 }
 
 template <class Iter>
 void
-test()
+runtime_test()
 {
     int ia[] = {1, 2, 3, 4, 5, 6};
     unsigned sa = sizeof(ia) / sizeof(ia[0]);
-    test(Iter(ia), Iter(ia), 0, 0);
-    test(Iter(ia), Iter(ia), 10, 10);
-    test(Iter(ia), Iter(ia+1), 0, 1);
-    test(Iter(ia), Iter(ia+1), 10, 11);
-    test(Iter(ia), Iter(ia+2), 0, 3);
-    test(Iter(ia), Iter(ia+2), 10, 13);
-    test(Iter(ia), Iter(ia+sa), 0, 21);
-    test(Iter(ia), Iter(ia+sa), 10, 31);
+
+    runtime_test(Iter(ia), Iter(ia), 0, 0);
+    runtime_test(Iter(ia), Iter(ia), 10, 10);
+    runtime_test(Iter(ia), Iter(ia+1), 0, 1);
+    runtime_test(Iter(ia), Iter(ia+1), 10, 11);
+    runtime_test(Iter(ia), Iter(ia+2), 0, 3);
+    runtime_test(Iter(ia), Iter(ia+2), 10, 13);
+    runtime_test(Iter(ia), Iter(ia+sa), 0, 21);
+    runtime_test(Iter(ia), Iter(ia+sa), 10, 31);
 }
 
 int main(int, char**)
 {
-    test<input_iterator<const int*> >();
-    test<forward_iterator<const int*> >();
-    test<bidirectional_iterator<const int*> >();
-    test<random_access_iterator<const int*> >();
-    test<const int*>();
+#if _LIBCPP_STD_VER > 17
+    constexpr_test<input_iterator<const int*> >();
+    constexpr_test<forward_iterator<const int*> >();
+    constexpr_test<bidirectional_iterator<const int*> >();
+    constexpr_test<random_access_iterator<const int*> >();
+    constexpr_test<const int*>();
+#endif
+
+    runtime_test<input_iterator<const int*> >();
+    runtime_test<forward_iterator<const int*> >();
+    runtime_test<bidirectional_iterator<const int*> >();
+    runtime_test<random_access_iterator<const int*> >();
+    runtime_test<const int*>();
 
   return 0;
 }

libcxx/utils/generate_feature_test_macro_components.py

# C++2a
     "headers": ["algorithm"],
     "unimplemented": True,
    }, {
     "name": "__cpp_lib_constexpr_misc",
     "values": { "c++2a": int(201811) },
     "headers": ["array", "functional", "iterator", "string_view", "tuple", "utility"],
     "unimplemented": True,
    }, {
+    "name": "__cpp_lib_constexpr_numeric",
+    "values": { "c++2a": int(201911) },
+    "headers": ["numeric"],
+   }, {
     "name": "__cpp_lib_bind_front",
     "values": { "c++2a": int(201811) },
     "headers": ["functional"],
     "unimplemented": True,
    }, {
     "name": "__cpp_lib_is_constant_evaluated",
     "values": { "c++2a": int(201811) },
     "headers": ["type_traits"],

libcxx/www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P1754">P1754</a></td><td>LWG</td><td>Rename concepts to standard_case for C++20, while we still can</td><td>Cologne</td><td></td><td></td></tr>
 
    <tr><td></td><td></td><td></td><td></td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0883">P0883</a></td><td>LWG</td><td>Fixing Atomic Initialization </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1391">P1391</a></td><td>LWG</td><td>Range constructor for std::string_view </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1394">P1394</a></td><td>LWG</td><td>Range constructor for std::span </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1456">P1456</a></td><td>LWG</td><td>Move-only views </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1622">P1622</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 32 - Thread support library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P1645">P1645</a></td><td>LWG</td><td>constexpr for numeric algorithms </td><td>Belfast</td><td><i> </i></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P1645">P1645</a></td><td>LWG</td><td>constexpr for numeric algorithms </td><td>Belfast</td><td>Complete</td><td>12.0</td></tr>
   <tr><td><a href="https://wg21.link/P1664">P1664</a></td><td>LWG</td><td>reconstructible_range - a concept for putting ranges back together </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1686">P1686</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 27 - Time library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1690">P1690</a></td><td>LWG</td><td>Refinement Proposal for P0919 Heterogeneous lookup for unordered containers </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1716">P1716</a></td><td>LWG</td><td>ranges compare algorithm are over-constrained </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1718">P1718</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 25 - Algorithms library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1719">P1719</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 26 - Numerics library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1720">P1720</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 28 - Localization library </td><td>Belfast</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1721">P1721</a></td><td>LWG</td><td>Mandating the Standard Library: Clause 29 - Input/Output library </td><td>Belfast</td><td><i> </i></td><td></td></tr>