Add lerp function to cmath (P0811R3)

[zoecarver]

Summary

Adds the lerp function as specified in P0811R3.

I don't think the special conditions are necessary, but if they are, I can add them (from the sample implementation).

[cpplearner]

As mentioned in https://math.stackexchange.com/questions/907327/accurate-floating-point-linear-interpolation, given

double a = 4000;
double b = a;
double t = 0x1.b2f3db7800a39p-2;

((1 - t) * a + t * b) != a. This does not conform to the requirement "If isfinite(t) && a == b, then r == a."

[mclow.lists]

This is too simplistic.

I have a better implementation of this; but I need more tests for the denormalized cases.
Mine also fails for edge cases like this: assert(std::isinf(std::lerp(T( 0), T( 1), inf)));

[mclow.lists]

The paper suggests an implementation like this:

constexpr Float lerp(Float a, Float b, Float t) {
  // Exact, monotonic, bounded, determinate, and (for a=b=0) consistent:
  if(a<=0 && b>=0 || a>=0 && b<=0) return t*b + (1-t)*a;

  if(t==1) return b;                        // exact
  // Exact at t=0, monotonic except near t=1,
  // bounded, determinate, and consistent:
  const Float x = a + t*(b-a);
  return t>1 == b>a ? max(b,x) : min(b,x);  // monotonic near t=1
}

I've tested this, and it works "pretty well", but not (I think) well enough.

[zoecarver]

@cpplearner that link is very helpful. In the first answer, there is a suggested function which might work well (though I haven't had time to test it yet). It is similar to the suggested implementation. There is one case which this function does not work for, but we could add a case for that. In pseudocode:

if (t < 0.5) a + (b - a) * t  
else b - (b - a) * (1 - t)

Additionally, the link has a lot of good exceptions which we could add to our tests. How does this compare to what you have @mclow.lists? I am going to add some tests to this patch in the meantime, mind sharing what you have so far?

[zoecarver]

Already implemented (better) by Marshall.

include/cmath

 floating_point tgamma (arithmetic x);
 float          tgammaf(float x);
 long double    tgammal(long double x);
 
 floating_point trunc (arithmetic x);
 float          truncf(float x);
 long double    truncl(long double x);
 
+constexpr float       lerp(float a,       float b,       float t);
+constexpr double      lerp(double a,      double b,      double t);
+constexpr long double lerp(long double a, long double b, long double t);
+
 }  // std
 
 */
 
 #include <__config>
 #include <math.h>
 #include <version>
 

 template <class _A1>
 _LIBCPP_INLINE_VISIBILITY
 _LIBCPP_CONSTEXPR typename enable_if<!is_floating_point<_A1>::value, bool>::type
 __libcpp_isfinite_or_builtin(_A1 __lcpp_x) _NOEXCEPT
 {
     return isfinite(__lcpp_x);
 }
 
+#if _LIBCPP_STD_VER > 17
+
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR float
+lerp(float __a, float __b, float __t)
+{
+    return (1 - __t) * __a + __t * __b;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR double
+lerp(double __a, double __b, double __t)
+{
+    return (1 - __t) * __a + __t * __b;
+}
+
+_LIBCPP_INLINE_VISIBILITY
+_LIBCPP_CONSTEXPR long double
+lerp(long double __a, long double __b, long double __t)
+{
+    return (1 - __t) * __a + __t * __b;
+}
+
+#endif // _LIBCPP_STD_VER > 17
+
 _LIBCPP_END_NAMESPACE_STD
 
 #endif  // _LIBCPP_CMATH

test/std/numerics/c.math/lerp.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
+
+// cmath
+
+// constexpr float       lerp(float a,       float b,       float t);
+// constexpr double      lerp(double a,      double b,      double t);
+// constexpr long double lerp(long double a, long double b, long double t);
+
+#include "test_macros.h"
+
+#include <cmath>
+
+void test_double()
+{
+    constexpr double a = 4;
+    constexpr double b = 0;
+    constexpr double t = 0.25;
+    constexpr double r = 3;
+    
+    constexpr auto res = std::lerp(a, b, t);
+    static_assert(res == r);
+    ASSERT_SAME_TYPE(decltype(t), decltype(res));
+}
+
+void test_long_double()
+{
+    constexpr long double a = 4;
+    constexpr long double b = 0;
+    constexpr long double t = 0.25;
+    constexpr long double r = 3;
+    
+    constexpr auto res = std::lerp(a, b, t);
+    static_assert(res == r);
+    ASSERT_SAME_TYPE(decltype(t), decltype(res));
+}
+
+void test_float()
+{
+    constexpr float a = 4;
+    constexpr float b = 0;
+    constexpr float t = 0.25;
+    constexpr float r = 3;
+    
+    constexpr auto res = std::lerp(a, b, t);
+    static_assert(res == r);
+    ASSERT_SAME_TYPE(decltype(t), decltype(res));
+}
+
+int main(int, char**)
+{
+    test_double();
+    test_long_double();
+    test_float();
+    
+    return 0;
+}
 No newline at end of file

www/cxx2a_status.html

-->
   <tr><td><a href="https://wg21.link/P1248R1">P1248R1</a></td><td>LWG</td><td>Remove CommonReference requirement from StrictWeakOrdering (a.k.a Fixing Relations)</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1285R0">P1285R0</a></td><td>LWG</td><td>Improving Completeness Requirements for Type Traits</td><td>San Diego</td><td><i> </i></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1353R0">P1353R0</a></td><td>CWG</td><td>Missing feature test macros</td><td>San Diego</td><td><i> </i></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/P0339R6">P0339R6</a></td><td>LWG</td><td>polymorphic_allocator<> as a vocabulary type</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0340R3">P0340R3</a></td><td>LWG</td><td>Making std::underlying_type SFINAE-friendly</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0738R2">P0738R2</a></td><td>LWG</td><td>I Stream, You Stream, We All Stream for istream_iterator</td><td>Kona</td><td></td><td></td></tr>
-  <tr><td><a href="https://wg21.link/P0811R3">P0811R3</a></td><td>LWG</td><td>Well-behaved interpolation for numbers and pointers</td><td>Kona</td><td></td><td></td></tr>
+  <tr><td><a href="https://wg21.link/P0811R3">P0811R3</a></td><td>LWG</td><td>Well-behaved interpolation for numbers and pointers</td><td>Kona</td><td>Complete</td><td></td></tr>
   <tr><td><a href="https://wg21.link/P0920R2">P0920R2</a></td><td>LWG</td><td>Precalculated hash values in lookup</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1001R2">P1001R2</a></td><td>LWG</td><td>Target Vectorization Policies from Parallelism V2 TS to C++20</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1024R3">P1024R3</a></td><td>LWG</td><td>Usability Enhancements for std::span</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
   <tr><td><a href="https://wg21.link/P1164R1">P1164R1</a></td><td>LWG</td><td>Make create_directory() Intuitive</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1227R2">P1227R2</a></td><td>LWG</td><td>Signed ssize() functions, unsigned size() functions </td><td>Kona</td><td>Complete</td><td>9.0</td></tr>
   <tr><td><a href="https://wg21.link/P1252R2">P1252R2</a></td><td>LWG</td><td>Ranges Design Cleanup</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1286R2">P1286R2</a></td><td>CWG</td><td>Contra CWG DR1778</td><td>Kona</td><td></td><td></td></tr>
   <tr><td><a href="https://wg21.link/P1357R1">P1357R1</a></td><td>LWG</td><td>Traits for [Un]bounded Arrays</td><td>Kona</td><td>Complete</td><td>9.0</td></tr>