[libc++] Add missing templated version of `std::lerp`

[• Quuxplusone]

Summary

Fixes https://github.com/llvm/llvm-project/issues/50806

The new implementation and new tests are both copy-pasted from hypot(a,b,c).

[jloser]

libcxx/test/std/numerics/c.math/cmath.pass.cpp

1139–1140

Why remove this? Seems unrelated?

[• Quuxplusone]

libcxx/test/std/numerics/c.math/cmath.pass.cpp

1139–1140

This is a duplicate of old line 1119, erroneously copied down here with the three-argument overload even though it's passing only two arguments. I discovered this error when I copied these lines to use with lerp (because lerp doesn't have a two-argument overload). I can put this in a separate git commit, for sure.

[Mordante]

Seems copy-pasting missed some code improvements and required changes.

libcxx/include/cmath

639

The function should be constexpr. Please make sure to also update the test.

648

This function requires C++20.

653

libcxx/test/std/numerics/c.math/cmath.pass.cpp

1171

The file libc++/test/std/numerics/c.math/c.math.lerp/c.math.lerp.pass.cpp has the other lerp tests, please move this test to that file.

1174

Please remove the empty strings and use std::is_same_v.

[• Quuxplusone]

Add constexpr, and test it.
Mildly modernize the static_assert in <cmath> to remove the ""; use _IsSame while I'm at it.

[• Quuxplusone]

libcxx/include/cmath

639

Good catch! Updated.

libcxx/test/std/numerics/c.math/cmath.pass.cpp

1139–1140

Merged this removal in eda5bbfb9db4d0dc3861333f7b4adf135fe20af8.

1174

Both here and above, this is for consistency with everything else in this file. Trying to "do something different" by creating a new c.math.lerp.pass.cpp is how we ended up missing tests (and code) to begin with; mclow should have just copy-pasted all the stuff for std::hypot (as I did here) and then the template overload couldn't have been missed.
(Although, as you see, the constexpr can be missed if I copy from hypot-which-is-not-constexpr. :))

[Mordante]

Thanks, a few minor points remaining. Otherwise then that LGTM!

libcxx/test/std/numerics/c.math/cmath.pass.cpp

1171

Please make the test constexpr and test it that way.

1174

I've no strong opinion whether lerp gets it's own file or becomes part of this test. I object against having the tests for lerp in two different files. If you want to keep it in this file, please make add the current lerp tests to this file in a separate commit.

[ldionne]

LGTM but like @Mordante said, please move the lerp tests to cmath.pass.cpp in a separate NFC commit.

[• Quuxplusone]

libcxx/test/std/numerics/c.math/cmath.pass.cpp

1174

In cmath.pass.cpp, we test the "shape" of each math function. These are static_asserts about the decltype of various calls, to prove we got the shape right; and then just a few lines of sanity-checks on the behavior (because we assume libc gets the behavior basically right, so the sanity-check is all we need).

The trick with lerp is that it has the same "shape" as the other cmath functions (like ilogb and lgamma and hypot), but whereas those just call out to libc, lerp is actually implemented directly in C++, so we need extra tests for its behavior. In this respect, lerp is like abs.

libcxx/test/std/numerics/c.math/c.math.lerp/c.math.lerp.pass.cpp is analogous to libcxx/test/std/numerics/c.math/abs.pass.cpp. It's specifically to test lerp's behavior because we implemented it ourselves and can't rely on libc to get it right.

What I can do, though, is simplify/expand c.math.lerp.pass.cpp to be more thorough, use our current style for constexpr-friendly tests, and test the generic template overload too. I would also be delighted to rename it to libcxx/test/std/numerics/c.math/lerp.pass.cpp, for parallelism with abs.pass.cpp; just like D116198 did for the range.access stuff.

[Mordante]

libcxx/test/std/numerics/c.math/cmath.pass.cpp

1174

Having a basic test here and a more verbose in the renamed lerp.pass.cpp works for me.
I would prefer to add some comment at both places referring to the other test, so the reader is aware of the other tests.

[• Quuxplusone]

Flatten c.math.lerp/c.math.lerp.pass.cpp to lerp.pass.cpp, to match abs.pass.cpp.
Add "See also" comments to both test_abs and test_lerp.
Reindent test_abs for consistency with the rest of these functions.

If CI is green, imma land this. There may be room for more thorough testing in lerp.pass.cpp, but at least test_lerp() does smoke-test the new overload (with both assert and static_assert).

libcxx/include/cmath

 lerp(float __a, float __b, float __t)                   _NOEXCEPT { return __lerp(__a, __b, __t); }
 
 constexpr double
 lerp(double __a, double __b, double __t)                _NOEXCEPT { return __lerp(__a, __b, __t); }
 
 constexpr long double
 lerp(long double __a, long double __b, long double __t) _NOEXCEPT { return __lerp(__a, __b, __t); }
 
+template <class _A1, class _A2, class _A3>
+inline _LIBCPP_HIDE_FROM_ABI
+constexpr typename enable_if_t
+<
+    is_arithmetic<_A1>::value &&
+    is_arithmetic<_A2>::value &&
+    is_arithmetic<_A3>::value,
+    __promote<_A1, _A2, _A3>
+>::type
+lerp(_A1 __a, _A2 __b, _A3 __t) noexcept
+{
+    typedef typename __promote<_A1, _A2, _A3>::type __result_type;
+    static_assert(!(_IsSame<_A1, __result_type>::value &&
+                    _IsSame<_A2, __result_type>::value &&
+                    _IsSame<_A3, __result_type>::value));
+    return __lerp((__result_type)__a, (__result_type)__b, (__result_type)__t);
+}
 #endif // _LIBCPP_STD_VER > 17
 
 _LIBCPP_END_NAMESPACE_STD
 
 _LIBCPP_POP_MACROS
 
 #endif // _LIBCPP_CMATH

libcxx/test/std/numerics/c.math/cmath.pass.cpp

 Ambiguous expm1(Ambiguous){ return Ambiguous(); }
 Ambiguous fdim(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous fma(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous fmax(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous fmin(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous hypot(Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous hypot(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous ilogb(Ambiguous){ return Ambiguous(); }
+Ambiguous lerp(Ambiguous, Ambiguous, Ambiguous){ return Ambiguous(); }
 Ambiguous lgamma(Ambiguous){ return Ambiguous(); }
 Ambiguous llrint(Ambiguous){ return Ambiguous(); }
 Ambiguous llround(Ambiguous){ return Ambiguous(); }
 Ambiguous log1p(Ambiguous){ return Ambiguous(); }
 Ambiguous log2(Ambiguous){ return Ambiguous(); }
 Ambiguous logb(Ambiguous){ return Ambiguous(); }
 Ambiguous lrint(Ambiguous){ return Ambiguous(); }
 Ambiguous lround(Ambiguous){ return Ambiguous(); }

 template <class T, class = decltype(std::abs(std::declval<T>()))>
 std::true_type has_abs_imp(int);
 template <class T>
 std::false_type has_abs_imp(...);
 
 template <class T>
 struct has_abs : decltype(has_abs_imp<T>(0)) {};
 
-void test_abs() {
+void test_abs()
+{
+    // See also "abs.pass.cpp"
+
 #ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Wabsolute-value"
 #endif
     static_assert((std::is_same<decltype(std::abs((float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::abs((double)0)), double>::value), "");
-  static_assert(
-      (std::is_same<decltype(std::abs((long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::abs((long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::abs((int)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::abs((long)0)), long>::value), "");
-  static_assert((std::is_same<decltype(std::abs((long long)0)), long long>::value),
-                "");
-  static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value),
-                "");
-  static_assert((std::is_same<decltype(std::abs((unsigned short)0)), int>::value),
-                "");
-  static_assert((std::is_same<decltype(std::abs((signed char)0)), int>::value),
-                "");
-  static_assert((std::is_same<decltype(std::abs((short)0)), int>::value),
-                "");
-  static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value),
-                "");
-  static_assert((std::is_same<decltype(std::abs((char)0)), int>::value),
-                "");
+    static_assert((std::is_same<decltype(std::abs((long long)0)), long long>::value), "");
+    static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value), "");
+    static_assert((std::is_same<decltype(std::abs((unsigned short)0)), int>::value), "");
+    static_assert((std::is_same<decltype(std::abs((signed char)0)), int>::value), "");
+    static_assert((std::is_same<decltype(std::abs((short)0)), int>::value), "");
+    static_assert((std::is_same<decltype(std::abs((unsigned char)0)), int>::value), "");
+    static_assert((std::is_same<decltype(std::abs((char)0)), int>::value), "");
     static_assert((std::is_same<decltype(abs(Ambiguous())), Ambiguous>::value), "");
 
     static_assert(!has_abs<unsigned>::value, "");
     static_assert(!has_abs<unsigned long>::value, "");
     static_assert(!has_abs<unsigned long long>::value, "");
     static_assert(!has_abs<size_t>::value, "");
-
 #ifdef __clang__
 #pragma clang diagnostic pop
 #endif
 
     assert(std::abs(-1.) == 1);
 }
 
 
 void test_acos()
 {
     static_assert((std::is_same<decltype(std::acos((float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::acos((bool)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::acos((unsigned short)0)), double>::value), "");
void test_hypot()
     static_assert((std::is_same<decltype(std::hypot((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::hypot(3,4) == 5);
 
 #if TEST_STD_VER > 14
     static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned short)0, (double)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0, (unsigned long)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (double)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (double)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (long double)0)), long double>::value), "");
void test_ilogb()
     static_assert((std::is_same<decltype(std::ilogb((double)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::ilogb((long double)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::ilogbf(0)), int>::value), "");
     static_assert((std::is_same<decltype(std::ilogbl(0)), int>::value), "");
     static_assert((std::is_same<decltype(ilogb(Ambiguous())), Ambiguous>::value), "");
     assert(std::ilogb(1) == 0);
 }
 
+void test_lerp()
+{
+    // See also "lerp.pass.cpp"
+
+#if TEST_STD_VER > 17
+    static_assert((std::is_same<decltype(std::lerp((float)0, (float)0, (float)0)), float>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (bool)0, (float)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (unsigned short)0, (double)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (int)0, (long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (double)0, (long)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (long double)0, (unsigned long)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (int)0, (long long)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (int)0, (unsigned long long)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (double)0, (double)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (long double)0, (long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (float)0, (double)0)), double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (float)0, (long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((float)0, (double)0, (long double)0)), long double>::value), "");
+    static_assert((std::is_same<decltype(std::lerp((int)0, (int)0, (int)0)), double>::value), "");
+    static_assert((std::is_same<decltype(lerp(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
+
+    assert(std::lerp(2, 3, 1) == 3);
+    assert(std::lerp(1, 3, 0.5) == 2);
+    assert(std::lerp(0, 4.0, 0) == 0);
+    static_assert(std::lerp(2, 3, 1) == 3);
+    static_assert(std::lerp(1, 3, 0.5) == 2);
+    static_assert(std::lerp(0, 4.0, 0) == 0);
+#endif
+}
+
 void test_lgamma()
 {
     static_assert((std::is_same<decltype(std::lgamma((float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::lgamma((bool)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::lgamma((unsigned short)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::lgamma((int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::lgamma((unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::lgamma((long)0)), double>::value), "");
int main(int, char**)
     test_exp2();
     test_expm1();
     test_fdim();
     test_fma();
     test_fmax();
     test_fmin();
     test_hypot();
     test_ilogb();
+    test_lerp();
     test_lgamma();
     test_llrint();
     test_llround();
     test_log1p();
     test_log2();
     test_logb();
     test_lrint();
     test_lround();