Another bash on midpoint and lerp now that it looks like it might go in.

Author: emsr

Makefile

@@ -1,4 +1,4 @@
-CXX = /home/ed/bin/bin/g++ -std=c++17 -g
+CXX = /home/ed/bin/bin/g++ -std=c++17 -g -Wall -Wextra
 
 all: test_lerp test_midpoint
 

lerp.h

@@ -12,18 +12,24 @@ namespace std
     {
       if (std::isnan(__a) || std::isnan(__b) || std::isnan(__t))
 	return std::numeric_limits<_Float>::quiet_NaN();
-      else if (__a <= _Float{0} && __b >= _Float{0}
-	    || __a >= _Float{0} && __b <= _Float{0})
+      else if ((__a <= _Float{0} && __b >= _Float{0})
+	    || (__a >= _Float{0} && __b <= _Float{0}))
 	// ab <= 0 but product could overflow.
-	//return __t * __b + (_Float{1} - __t) * __a;
-	return std::fma(__t, __b, (_Float{1} - __t) * __a)
+#ifndef FMA
+	return __t * __b + (_Float{1} - __t) * __a;
+#else
+	return std::fma(__t, __b, (_Float{1} - __t) * __a);
+#endif
       else if (__t == _Float{1})
 	return __b;
       else
 	{ // monotonic near t == 1.
-	  //const auto __x = __a + __t * (__b - __a);
+#ifndef FMA
+	  const auto __x = __a + __t * (__b - __a);
+#else
 	  const auto __x = std::fma(__t, __b - __a, __a);
-	  return __t > _Float{1} == __b > __a
+#endif
+	  return (__t > _Float{1}) == (__b > __a)
 		 ? std::max(__b, __x)
 		 : std::min(__b, __x);
 	}

midpoint.h

@@ -2,6 +2,7 @@
 #define MIDPOINT_H 1
 
 #include <cmath>
+#include <cstdint>
 
 namespace std
 {
@@ -12,6 +13,12 @@ namespace std
     midpoint(_Int __a, _Int __b) noexcept
     {
       using _UInt = std::make_unsigned_t<_Int>;
+/*
+      const auto __ua = _UInt(__a);
+      const auto __ub = _UInt(__b);
+      const auto __del = (__ub > __ua ? +(__ub - __ua) : -(__ua - __ub));
+      return _Int(__ua + __del / 2);
+*/
       return _Int(_UInt(__a) + (_UInt(__b) - _UInt(__a)) / 2);
     }
 
@@ -31,7 +38,12 @@ namespace std
   template<typename _Tp>
     _Tp*
     midpoint(_Tp* __a, _Tp* __b)
-    { return static_cast<_Tp*>(std::midpoint(intptr_t(__a), intptr_t(__b))); }
+    {
+      //using _Iptr = std::intptr_t;
+      //return static_cast<_Tp*>(__a + std::midpoint(_Iptr(__a), _Iptr(__b)));
+      const auto __diff = (__b - __a) / 2;
+      return __a + __diff;
+    }
 
 } // namespace std
 

test_lerp.cpp

@@ -1,5 +1,5 @@
 /*
-/home/ed/bin/bin/g++ -std=c++17 -o test_lerp test_lerp.cpp
+/home/ed/bin/bin/g++ -std=c++17 -g -Wall -Wextra -o test_lerp test_lerp.cpp
 */
 
 #include <limits>
@@ -9,33 +9,76 @@
 
 #include <iostream>
 
+template<typename Real>
+  bool
+  test()
+  {
+    const auto a = Real{5};
+    const auto b = Real{10};
+    const auto t = Real{0.75L};
+    const auto x = std::lerp(a, b, t);
+
+    std::cout << "x = " << x << '\n';
+
+    return true;
+  }
+
 template<typename Real>
   bool
   test_ends()
   {
     const auto a = Real{-3};
     const auto b = Real{+5};
-    const auto t = Real{3} / Real{4};
-    auto ca = std::lerp(a, b, Real{0});
+
+    const auto ca = std::lerp(a, b, Real{0});
     std::cout << "ca = " << ca << '\n';
-    std::cout << std::boolalpha << "ca == a: " << (ca == a) << '\n';
-    auto cb = std::lerp(a, b, Real{1});
+    std::cout << "ca == a: " << std::boolalpha << (ca == a) << '\n';
+
+    const auto cb = std::lerp(a, b, Real{1});
     std::cout << "cb = " << cb << '\n';
-    std::cout << std::boolalpha << "cb == b: " << (cb == b) << '\n';
+    std::cout << "cb == b: " << std::boolalpha << (cb == b) << '\n';
+
     return ca == a && cb == b;
   }
 
 template<typename Real>
   bool
-  test_huge()
+  test_nan()
   {
-    const auto a = -std::numeric_limits<Real>::max();
-    const auto b = +std::numeric_limits<Real>::max();
-    const auto t = Real{3} / Real{4};
-    auto c = std::lerp(a, b, t);
-    std::cout << "c = " << c << '\n';
-    std::cout << std::boolalpha << "c == b/2: " << (c == b / Real{2}) << '\n';
-    return c == b / Real{2};
+    const auto a = Real{5};
+    const auto b = Real{10};
+    const auto t = Real{0.75L};
+
+    const auto anan = std::numeric_limits<Real>::quiet_NaN();
+    const auto bnan = std::numeric_limits<Real>::quiet_NaN();
+    const auto tnan = std::numeric_limits<Real>::quiet_NaN();
+
+    const auto nan = std::isnan(std::lerp(anan, b, t))
+		  && std::isnan(std::lerp(a, bnan, t))
+		  && std::isnan(std::lerp(a, b, tnan));
+
+    std::cout << "nan: " << std::boolalpha << nan << '\n';
+
+    return nan;
+  }
+
+template<typename Real>
+  bool
+  test_subnorm()
+  {
+    const auto denorm = std::numeric_limits<Real>::denorm_min();
+
+    const auto a = Real{5} * denorm;
+    const auto b = Real{10} * denorm;
+    const auto t = Real{0.75L};
+    const auto x = std::lerp(a, b, t);
+    std::cout << "x: " << x / denorm << '\n';
+
+    const auto a00 = Real{500} * denorm;
+    const auto b00 = Real{1000} * denorm;
+    const auto x00 = std::lerp(a00, b00, t);
+    std::cout << "x00: " << x00 / denorm << '\n';
+    return true;
   }
 
 template<typename Real>
@@ -45,28 +88,58 @@ template<typename Real>
     const auto a = Real{5};
     const auto b = a;
     const auto t = std::numeric_limits<Real>::infinity();
-    auto c = std::lerp(a, b, t);
+    const auto c = std::lerp(a, b, t);
     std::cout << "c = " << c << '\n';
-    std::cout << std::boolalpha << "c == a: " << (c == a) << '\n';
+    std::cout << "c == a: " << std::boolalpha << (c == a) << '\n';
     return c == a;
   }
 
+template<typename Real>
+  bool
+  test_huge()
+  {
+    const auto max = std::numeric_limits<Real>::max() / 16;
+    const auto a = Real{5} * max;
+    const auto b = Real{10} * max;
+    const auto t = Real{3} / Real{4};
+    const auto c = std::lerp(a, b, t);
+    std::cout << "c = " << c / max << '\n';
+    std::cout << "c == b/2: " << std::boolalpha << (c == Real{8.75} * max) << '\n';
+    return c == b / Real{2};
+  }
+
 int
 main()
 {
   bool ok = true;
 
+  std::cout << "\ntest\n";
+  ok = ok && test<float>();
+  ok = ok && test<double>();
+  ok = ok && test<long double>();
+
+  std::cout << "\ntest_nan\n";
+  ok = ok && test_nan<float>();
+  ok = ok && test_nan<double>();
+  ok = ok && test_nan<long double>();
+
+  std::cout << "\ntest_ends\n";
   ok = ok && test_ends<float>();
   ok = ok && test_ends<double>();
   ok = ok && test_ends<long double>();
 
-  ok = ok && test_huge<float>();
-  ok = ok && test_huge<double>();
-  ok = ok && test_huge<long double>();
-
+  std::cout << "\ntest_inf\n";
   ok = ok && test_inf<float>();
   ok = ok && test_inf<double>();
   ok = ok && test_inf<long double>();
 
+  std::cout << "\ntest_subnorm\n";
+  ok = ok && test_subnorm<float>();
+
+  std::cout << "\ntest_huge\n";
+  ok = ok && test_huge<float>();
+  ok = ok && test_huge<double>();
+  ok = ok && test_huge<long double>();
+
   return ok;
 }

test_midpoint.cpp

@@ -1,16 +1,79 @@
 /*
-/home/ed/bin/bin/g++ -std=c++17 -o test_midpoint test_midpoint.cpp
+/home/ed/bin/bin/g++ -std=c++17 -g -Wall -Wextra -o test_midpoint test_midpoint.cpp
 */
 
 #include <limits>
 #include <type_traits>
 
 #include "midpoint.h"
 
+#include <iostream>
+
+template<typename Int>
+  bool
+  test_twos_comp()
+  {
+    const std::make_unsigned_t<Int> a = 10, b = 5;
+    const auto mab = std::midpoint(a, b);
+    std::cout << "mab = " << int(mab) << '\n';
+
+    return true;
+  }
+
+template<typename Real>
+  bool
+  test_huge()
+  {
+    const auto huge = std::numeric_limits<Real>::max();
+    const auto a = -huge;
+    const auto b = +huge;
+    const auto c = std::midpoint(a, b);
+    std::cout << "c = " << c << '\n';
+    std::cout << "c == 0: " << std::boolalpha << (c == Real{0}) << '\n';
+    return c == Real{0};
+  }
+
+template<typename Tp>
+  bool
+  test_ptr()
+  {
+    constexpr int num = 21;
+    constexpr Tp arr[num]{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20};
+    const auto a = arr;
+    const auto b = arr + num;
+    auto ab = std::midpoint(a, b);
+    std::cout << "a = " << a << "; b = " << b << "; ab = " << ab << '\n';
+    std::cout << "ab - a = " << ab - a << "; ab - b = " << ab - b << '\n';
+    std::cout << "ab = " << ab << "; *ab = " << *ab << '\n';
+    auto ba = std::midpoint(b-1, a-1); // rbegin, rend
+    std::cout << "ba - (b-1) = " << ba - (b-1) << "; ba - (a-1) = " << ba - (a-1) << '\n';
+    std::cout << "ba = " << ba << "; *ba = " << *ba << '\n';
+    return true;
+  }
+
 int
 main()
 {
   bool ok = true;
 
+  const int a = 5, b = 10;
+  const auto mab = std::midpoint(a, b);
+  std::cout << "mab = " << mab << '\n';
+
+  std::cout << "\ntest_huge\n";
+  ok = ok && test_huge<float>();
+  ok = ok && test_huge<double>();
+  ok = ok && test_huge<long double>();
+
+  std::cout << "\ntest_twos_comp\n";
+  ok = ok && test_twos_comp<unsigned char>();
+  ok = ok && test_twos_comp<short>();
+  ok = ok && test_twos_comp<int>();
+  ok = ok && test_twos_comp<long>();
+  ok = ok && test_twos_comp<long long>();
+
+  std::cout << "\ntest_ptr\n";
+  ok = ok && test_ptr<int>();
+
   return ok;
 }