Integer and pointer types of 'midpoint' from P0811

[mclow.lists]

Summary

https://wg21.link/P0811

This is just the integer and pointer parts of std::midpoint.
The floating point bits and the lerp will come later.'

[EricWF]

libcxx/include/numeric

533

Does const or volatile occur for by-value template parameters?

551

Why the SFINAE?

Just declare it midpoint(_Tp*, _Tp*) ?

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp

29

How about cases where the sum is odd? AKA 0, 3, 3, 0, 4, -1, and -1, 4).

32

How about all these same tests but with -2 instead?

[mclow.lists]

libcxx/include/numeric

533

I can remove that now that I realize that users are not supposed to explicitly list the template parameters.

551

Because of this bad thing:

midpoint<int>(0, 0)

returns a int *

Yes, I know that users are not supposed to do that, but this is easy prevention.

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp

29

I have more down below.

[mclow.lists]

Address Eric's comments.
Remove all the explicit template lists from the tests.
Add a couple "odd" tests.
Add a couple more failing pointer tests.

[EricWF]

LGTM minus inline comments.

libcxx/include/numeric

529

TODO on the floating point overloads?

549

This overload isn't constexpr in the paper.

551

The int case isn't quite right, but midpoint<long>(0, 0) triggers the bug you mention.

Is there a test case?

553

minpoint needs to be qualified.

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp

31

There's no reason why midpoint needs to be declared as a template. This test is non-portable.

64

I think we need more constexpr test that try to tickle overflows and other boundary conditions to ensure we're constexpr in those cases as well.

[EricWF]

libcxx/include/numeric

549

Ignore me. It is in r3.

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp

31

Ignore me. It is in r3.

[mclow.lists]

Landed as r356162

libcxx/include/numeric

553

I changed this to be: return __a + _VSTD::midpoint(ptrdiff_t(0), __b - __a);

[zoecarver]

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.fail.cpp

19

Is this necessary?

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp

29

nit: any reason not to use`ASSERT_SAME_TYPE`?

[mclow.lists]

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.pass.cpp

29

I actually changed that before I committed.

libcxx/include/numeric

 template <class M, class N>
     constexpr common_type_t<M,N> lcm(M m, N n);    // C++17
 
+integer         midpoint(integer a, integer b);                  // C++20
+pointer         midpoint(pointer a, pointer b);                  // C++20
+floating_point  midpoint(floating_point a, floating_point b);    // C++20
+
 }  // std
 
 */

 
 #endif /* _LIBCPP_STD_VER > 14 */
 
+#if _LIBCPP_STD_VER > 17
+template <class _Tp>
+_LIBCPP_INLINE_VISIBILITY constexpr
+enable_if_t<is_integral_v<_Tp> && !is_same_v<bool, _Tp>, _Tp>
+midpoint(_Tp __a, _Tp __b) noexcept
+_LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
+{
+    using _Up = std::make_unsigned_t<_Tp>;
+
+    int __sign = 1;
+    _Up __m = __a;
+    _Up __M = __b;
+    if (__a > __b)
+    {
+        __sign = -1;
+        __m = __b;
+        __M = __a;
+    }
+     return __a + __sign * _Tp(_Up(__M-__m) >> 1);
+}
+
+
+template <class _TPtr>
+_LIBCPP_INLINE_VISIBILITY constexpr
+enable_if_t<is_pointer_v<_TPtr>, _TPtr>
+midpoint(_TPtr __a, _TPtr __b) noexcept
+{
+    return __a + midpoint<ptrdiff_t>(0, __b - __a);
+}
+#endif
+
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.fail.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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// <numeric>
+
+// template <class _Tp>
+// _Tp midpoint(_Tp __a, _Tp __b) noexcept
+
+// An overload exists for each of char and all arithmetic types except bool.
+
+#include <numeric>
+
+#include "test_macros.h"
+
+int main(int, char**)
+{
+    (void) std::midpoint(false, true); // expected-error {{no matching function for call to 'midpoint'}}
+
+//  A couple of odd pointer types that should fail
+    (void) std::midpoint(nullptr, nullptr);     // expected-error {{no matching function for call to 'midpoint'}}
+    (void) std::midpoint((void *)0, (void *)0); // expected-error@numeric:* {{arithmetic on pointers to void}}
+    
+    return 0;
+}

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.integer.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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// <numeric>
+
+// template <class _Tp>
+// _Tp midpoint(_Tp __a, _Tp __b) noexcept
+//
+
+#include <numeric>
+#include <cassert>
+#include "test_macros.h"
+
+template <typename T>
+void signed_test()
+{
+    constexpr T zero{0};
+    constexpr T one{1};
+    constexpr T two{2};
+    constexpr T three{3};
+    constexpr T four{4};
+
+    static_assert(std::is_same_v<T, decltype(std::midpoint(T(), T()))>, "");
+    static_assert(                  noexcept(std::midpoint(T(), T())), "");
+    static_assert(std::midpoint<T>(one, three) == two, "");
+    using limits = std::numeric_limits<T>;
+    
+    assert(std::midpoint(zero, zero) == zero);
+    assert(std::midpoint(zero, two)  == one);
+    assert(std::midpoint(two, zero)  == one);
+    assert(std::midpoint(two, two)   == two);
+
+    assert(std::midpoint(one, four)    == two);
+    assert(std::midpoint(four, one)    == three);
+    assert(std::midpoint(three, four)  == three);
+    assert(std::midpoint(four, three)  == four);
+
+    assert(std::midpoint(T( 3), T( 4)) == T(3));
+    assert(std::midpoint(T( 4), T( 3)) == T(4));
+    assert(std::midpoint(T(-3), T( 4)) == T(0));
+    assert(std::midpoint(T(-4), T( 3)) == T(-1));
+    assert(std::midpoint(T( 3), T(-4)) == T(0));
+    assert(std::midpoint(T( 4), T(-3)) == T(1));
+    assert(std::midpoint(T(-3), T(-4)) == T(-3));
+    assert(std::midpoint(T(-4), T(-3)) == T(-4));
+    
+    assert(std::midpoint(limits::min(), limits::max()) == T(-1));
+    assert(std::midpoint(limits::max(), limits::min()) == T(0));
+
+    assert(std::midpoint(limits::min(), T(6)) == limits::min()/2 + 3);
+    assert(std::midpoint(T(6), limits::min()) == limits::min()/2 + 3);
+    assert(std::midpoint(limits::max(), T(6)) == limits::max()/2 + 4);
+    assert(std::midpoint(T(6), limits::max()) == limits::max()/2 + 3);
+
+    assert(std::midpoint(limits::min(), T(-6)) == limits::min()/2 - 3);
+    assert(std::midpoint(T(-6), limits::min()) == limits::min()/2 - 3);
+    assert(std::midpoint(limits::max(), T(-6)) == limits::max()/2 - 2);
+    assert(std::midpoint(T(-6), limits::max()) == limits::max()/2 - 3);
+}
+
+template <typename T>
+void unsigned_test()
+{
+    constexpr T zero{0};
+    constexpr T one{1};
+    constexpr T two{2};
+    constexpr T three{3};
+    constexpr T four{4};
+
+    static_assert(std::is_same_v<T, decltype(std::midpoint(T(), T()))>, "");
+    static_assert(                  noexcept(std::midpoint(T(), T())), "");
+    static_assert(std::midpoint(one, three) == two, "");
+    using limits = std::numeric_limits<T>;
+    const T half_way = (limits::max() - limits::min())/2;
+    
+    assert(std::midpoint(zero, zero) == zero);
+    assert(std::midpoint(zero, two)  == one);
+    assert(std::midpoint(two, zero)  == one);
+    assert(std::midpoint(two, two)   == two);
+
+    assert(std::midpoint(one, four)    == two);
+    assert(std::midpoint(four, one)    == three);
+    assert(std::midpoint(three, four)  == three);
+    assert(std::midpoint(four, three)  == four);
+    
+    assert(std::midpoint(limits::min(), limits::max()) == T(half_way));
+    assert(std::midpoint(limits::max(), limits::min()) == T(half_way + 1));
+
+    assert(std::midpoint(limits::min(), T(6)) == limits::min()/2 + 3);
+    assert(std::midpoint(T(6), limits::min()) == limits::min()/2 + 3);
+    assert(std::midpoint(limits::max(), T(6)) == half_way + 4);
+    assert(std::midpoint(T(6), limits::max()) == half_way + 3);
+}
+
+
+int main(int, char**)
+{
+    signed_test<signed char>();
+    signed_test<short>();
+    signed_test<int>();
+    signed_test<long>();
+    signed_test<long long>();
+
+    signed_test<int8_t>();
+    signed_test<int16_t>();
+    signed_test<int32_t>();
+    signed_test<int64_t>();
+    signed_test<__int128_t>();
+
+    unsigned_test<unsigned char>();
+    unsigned_test<unsigned short>();
+    unsigned_test<unsigned int>();
+    unsigned_test<unsigned long>();
+    unsigned_test<unsigned long long>();
+
+    unsigned_test<uint8_t>();
+    unsigned_test<uint16_t>();
+    unsigned_test<uint32_t>();
+    unsigned_test<uint64_t>();
+    unsigned_test<__uint128_t>();
+
+//     int_test<char>();
+    signed_test<ptrdiff_t>();
+    unsigned_test<size_t>();
+
+    return 0;
+}

libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.pointer.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
+//
+//===----------------------------------------------------------------------===//
+//
+// UNSUPPORTED: c++98, c++03, c++11, c++14, c++17
+// <numeric>
+
+// template <class _Tp>
+// _Tp* midpoint(_Tp* __a, _Tp* __b) noexcept
+//
+
+#include <numeric>
+#include <cassert>
+
+#include "test_macros.h"
+
+
+
+template <typename T>
+void pointer_test()
+{
+    T array[1000] = {}; // we need an array to make valid pointers
+    constexpr T cArray[2] = {};
+    static_assert(std::is_same_v<T*, decltype(std::midpoint(array, array))>, "");   
+    static_assert(                   noexcept(std::midpoint(array, array)), "");
+    static_assert(std::midpoint(cArray, cArray + 2) == cArray + 1, "");
+
+    assert(std::midpoint(array, array)        == array);
+    assert(std::midpoint(array, array + 1000) == array + 500);
+
+    assert(std::midpoint(array, array +    9) == array + 4);
+    assert(std::midpoint(array, array +   10) == array + 5);
+    assert(std::midpoint(array, array +   11) == array + 5);
+    assert(std::midpoint(array +    9, array) == array + 5);
+    assert(std::midpoint(array +   10, array) == array + 5);
+    assert(std::midpoint(array +   11, array) == array + 6);
+}
+
+
+int main(int, char**)
+{
+    pointer_test<               char>();
+    pointer_test<const          char>();
+    pointer_test<      volatile char>();
+    pointer_test<const volatile char>();
+    
+    pointer_test<int>();
+    pointer_test<double>();
+
+    return 0;
+}