From ade489a163755dd54578a58e97bfbd87ccd682c3 Mon Sep 17 00:00:00 2001
From: Ryan <ryan.elandt@gmail.com>
Date: Fri, 25 Aug 2023 21:33:18 -0400
Subject: [PATCH 1/4] initial commit

---
 include/boost/math/tools/promotion.hpp | 313 ++++++-------------------
 1 file changed, 76 insertions(+), 237 deletions(-)

diff --git a/include/boost/math/tools/promotion.hpp b/include/boost/math/tools/promotion.hpp
index 68127efb04..7894d05e61 100644
--- a/include/boost/math/tools/promotion.hpp
+++ b/include/boost/math/tools/promotion.hpp
@@ -26,9 +26,6 @@
 #include <boost/math/tools/config.hpp>
 #include <type_traits>
 
-#if __has_include(<stdfloat>)
-#  include <stdfloat>
-#endif
 
 namespace boost
 {
@@ -36,230 +33,90 @@ namespace boost
   {
     namespace tools
     {
+      ///// This promotion system works as follows:
+      // 
+      // Rule<T1> (one argument promotion rule):
+      //   - Promotes `T` to `double` if `T` is an integer type as identified by
+      //     `std::is_integral`, otherwise is `T`
+      //
+      // Rule<T1, T2_to_TN...> (two or more argument promotion rule):
+      //   - 1. Calculates type using applying Rule<T1>.
+      //   - 2. Calculates type using applying Rule<T2_to_TN...> 
+      //   - If the type calculated in 1 and 2 are both floating point types, as
+      //     identified by `std::is_floating_point`, then return the type
+      //     determined by `std::common_type`. Otherwise return the type using
+      //     an asymmetric convertibility rule.
+      //
+      ///// Discussion:
+      //
       // If either T1 or T2 is an integer type,
       // pretend it was a double (for the purposes of further analysis).
       // Then pick the wider of the two floating-point types
       // as the actual signature to forward to.
       // For example:
-      // foo(int, short) -> double foo(double, double);
-      // foo(int, float) -> double foo(double, double);
-      // Note: NOT float foo(float, float)
-      // foo(int, double) -> foo(double, double);
-      // foo(double, float) -> double foo(double, double);
-      // foo(double, float) -> double foo(double, double);
-      // foo(any-int-or-float-type, long double) -> foo(long double, long double);
-      // but ONLY float foo(float, float) is unchanged.
-      // So the only way to get an entirely float version is to call foo(1.F, 2.F),
-      // But since most (all?) the math functions convert to double internally,
-      // probably there would not be the hoped-for gain by using float here.
-
+      //    foo(int, short) -> double foo(double, double);  // ***NOT*** float foo(float, float)
+      //    foo(int, float) -> double foo(double, double);  // ***NOT*** float foo(float, float)
+      //    foo(int, double) -> foo(double, double);
+      //    foo(double, float) -> double foo(double, double);
+      //    foo(double, float) -> double foo(double, double);
+      //    foo(any-int-or-float-type, long double) -> foo(long double, long double);
+      // ONLY float foo(float, float) is unchanged, so the only way to get an
+      // entirely float version is to call foo(1.F, 2.F). But since most (all?) the
+      // math functions convert to double internally, probably there would not be the
+      // hoped-for gain by using float here.
+      //
       // This follows the C-compatible conversion rules of pow, etc
       // where pow(int, float) is converted to pow(double, double).
 
+
+      // Promotes a single argument to double if it is an integer type
       template <class T>
-      struct promote_arg
-      { // If T is integral type, then promote to double.
-        using type = typename std::conditional<std::is_integral<T>::value, double, T>::type;
+      struct promote_arg {
+         using type = typename std::conditional<std::is_integral<T>::value, double, T>::type;
       };
-      // These full specialisations reduce std::conditional usage and speed up
-      // compilation:
-      template <> struct promote_arg<float> { using type = float; };
-      template <> struct promote_arg<double>{ using type = double; };
-      template <> struct promote_arg<long double> { using type = long double; };
-      template <> struct promote_arg<int> {  using type = double; };
-
-      #ifdef __STDCPP_FLOAT16_T__
-      template <> struct promote_arg<std::float16_t> { using type = std::float16_t; };
-      #endif
-      #ifdef __STDCPP_FLOAT32_T__
-      template <> struct promote_arg<std::float32_t> { using type = std::float32_t; };
-      #endif
-      #ifdef __STDCPP_FLOAT64_T__
-      template <> struct promote_arg<std::float64_t> { using type = std::float64_t; };
-      #endif
-      #ifdef __STDCPP_FLOAT128_T__
-      template <> struct promote_arg<std::float128_t> { using type = std::float128_t; };
-      #endif
 
-      template <typename T>
-      using promote_arg_t = typename promote_arg<T>::type;
 
+      // Promotes two arguments, neither of which is an integer type using an asymmetric
+      // convertibility rule.
+      template <class T1, class T2, bool = (std::is_floating_point<T1>::value && std::is_floating_point<T2>::value)>
+      struct pa2_integral_already_removed {
+         using type = typename std::conditional<
+            !std::is_floating_point<T2>::value && std::is_convertible<T1, T2>::value, 
+            T2, T1>::type;
+      };
+      // For two floating point types, promotes using `std::common_type` functionality 
       template <class T1, class T2>
-      struct promote_args_2
-      { // Promote, if necessary, & pick the wider of the two floating-point types.
-        // for both parameter types, if integral promote to double.
-        using T1P = typename promote_arg<T1>::type; // T1 perhaps promoted.
-        using T2P = typename promote_arg<T2>::type; // T2 perhaps promoted.
-        using intermediate_type = typename std::conditional<
-          std::is_floating_point<T1P>::value && std::is_floating_point<T2P>::value, // both T1P and T2P are floating-point?
-#ifdef __STDCPP_FLOAT128_T__
-           typename std::conditional<std::is_same<std::float128_t, T1P>::value || std::is_same<std::float128_t, T2P>::value, // either long double?
-            std::float128_t,
-#endif 
-#ifdef BOOST_MATH_USE_FLOAT128
-           typename std::conditional<std::is_same<__float128, T1P>::value || std::is_same<__float128, T2P>::value, // either long double?
-            __float128,
-#endif 
-             typename std::conditional<std::is_same<long double, T1P>::value || std::is_same<long double, T2P>::value, // either long double?
-               long double, // then result type is long double.
-#ifdef __STDCPP_FLOAT64_T__
-             typename std::conditional<std::is_same<std::float64_t, T1P>::value || std::is_same<std::float64_t, T2P>::value, // either float64?
-               std::float64_t, // then result type is float64_t.
-#endif
-               typename std::conditional<std::is_same<double, T1P>::value || std::is_same<double, T2P>::value, // either double?
-                  double, // result type is double.
-#ifdef __STDCPP_FLOAT32_T__
-             typename std::conditional<std::is_same<std::float32_t, T1P>::value || std::is_same<std::float32_t, T2P>::value, // either float32?
-               std::float32_t, // then result type is float32_t.
-#endif
-                  float // else result type is float.
-             >::type
-#ifdef BOOST_MATH_USE_FLOAT128
-             >::type
-#endif
-#ifdef __STDCPP_FLOAT128_T__
-             >::type
-#endif
-#ifdef __STDCPP_FLOAT64_T__
-             >::type
-#endif
-#ifdef __STDCPP_FLOAT32_T__
-             >::type
-#endif
-             >::type,
-          // else one or the other is a user-defined type:
-          typename std::conditional<!std::is_floating_point<T2P>::value && std::is_convertible<T1P, T2P>::value, T2P, T1P>::type>::type;
-
-#ifdef __STDCPP_FLOAT64_T__
-          // If long doubles are doubles then we should prefer to use std::float64_t when available
-          using type = std::conditional_t<(sizeof(double) == sizeof(long double) && std::is_same<intermediate_type, long double>::value), std::float64_t, intermediate_type>;
-#else
-          using type = intermediate_type;
-#endif
-      }; // promote_arg2
-      // These full specialisations reduce std::conditional usage and speed up
-      // compilation:
-      template <> struct promote_args_2<float, float> { using type = float; };
-      template <> struct promote_args_2<double, double>{ using type = double; };
-      template <> struct promote_args_2<long double, long double> { using type = long double; };
-      template <> struct promote_args_2<int, int> {  using type = double; };
-      template <> struct promote_args_2<int, float> {  using type = double; };
-      template <> struct promote_args_2<float, int> {  using type = double; };
-      template <> struct promote_args_2<int, double> {  using type = double; };
-      template <> struct promote_args_2<double, int> {  using type = double; };
-      template <> struct promote_args_2<int, long double> {  using type = long double; };
-      template <> struct promote_args_2<long double, int> {  using type = long double; };
-      template <> struct promote_args_2<float, double> {  using type = double; };
-      template <> struct promote_args_2<double, float> {  using type = double; };
-      template <> struct promote_args_2<float, long double> {  using type = long double; };
-      template <> struct promote_args_2<long double, float> {  using type = long double; };
-      template <> struct promote_args_2<double, long double> {  using type = long double; };
-      template <> struct promote_args_2<long double, double> {  using type = long double; };
-
-      #ifdef __STDCPP_FLOAT128_T__
-      template <> struct promote_args_2<int, std::float128_t> { using type = std::float128_t; };
-      template <> struct promote_args_2<std::float128_t, int> { using type = std::float128_t; };
-      template <> struct promote_args_2<std::float128_t, float> { using type = std::float128_t; };
-      template <> struct promote_args_2<float, std::float128_t> { using type = std::float128_t; };
-      template <> struct promote_args_2<std::float128_t, double> { using type = std::float128_t; };
-      template <> struct promote_args_2<double, std::float128_t> { using type = std::float128_t; };
-      template <> struct promote_args_2<std::float128_t, long double> { using type = std::float128_t; };
-      template <> struct promote_args_2<long double, std::float128_t> { using type = std::float128_t; };
-
-      #ifdef __STDCPP_FLOAT16_T__
-      template <> struct promote_args_2<std::float128_t, std::float16_t> { using type = std::float128_t; };
-      template <> struct promote_args_2<std::float16_t, std::float128_t> { using type = std::float128_t; };
-      #endif
-
-      #ifdef __STDCPP_FLOAT32_T__
-      template <> struct promote_args_2<std::float128_t, std::float32_t> { using type = std::float128_t; };
-      template <> struct promote_args_2<std::float32_t, std::float128_t> { using type = std::float128_t; };
-      #endif
-
-      #ifdef __STDCPP_FLOAT64_T__
-      template <> struct promote_args_2<std::float128_t, std::float64_t> { using type = std::float128_t; };
-      template <> struct promote_args_2<std::float64_t, std::float128_t> { using type = std::float128_t; };
-      #endif
-
-      template <> struct promote_args_2<std::float128_t, std::float128_t> { using type = std::float128_t; };
-      #endif
-
-      #ifdef __STDCPP_FLOAT64_T__
-      template <> struct promote_args_2<int, std::float64_t> { using type = std::float64_t; };
-      template <> struct promote_args_2<std::float64_t, int> { using type = std::float64_t; };
-      template <> struct promote_args_2<std::float64_t, float> { using type = std::float64_t; };
-      template <> struct promote_args_2<float, std::float64_t> { using type = std::float64_t; };
-      template <> struct promote_args_2<std::float64_t, double> { using type = std::float64_t; };
-      template <> struct promote_args_2<double, std::float64_t> { using type = std::float64_t; };
-      template <> struct promote_args_2<std::float64_t, long double> { using type = long double; };
-      template <> struct promote_args_2<long double, std::float64_t> { using type = long double; };
-
-      #ifdef __STDCPP_FLOAT16_T__
-      template <> struct promote_args_2<std::float64_t, std::float16_t> { using type = std::float64_t; };
-      template <> struct promote_args_2<std::float16_t, std::float64_t> { using type = std::float64_t; };
-      #endif
-
-      #ifdef __STDCPP_FLOAT32_T__
-      template <> struct promote_args_2<std::float64_t, std::float32_t> { using type = std::float64_t; };
-      template <> struct promote_args_2<std::float32_t, std::float64_t> { using type = std::float64_t; };
-      #endif
-
-      template <> struct promote_args_2<std::float64_t, std::float64_t> { using type = std::float64_t; };
-      #endif
-
-      #ifdef __STDCPP_FLOAT32_T__
-      template <> struct promote_args_2<int, std::float32_t> { using type = std::float32_t; };
-      template <> struct promote_args_2<std::float32_t, int> { using type = std::float32_t; };
-      template <> struct promote_args_2<std::float32_t, float> { using type = std::float32_t; };
-      template <> struct promote_args_2<float, std::float32_t> { using type = std::float32_t; };
-      template <> struct promote_args_2<std::float32_t, double> { using type = double; };
-      template <> struct promote_args_2<double, std::float32_t> { using type = double; };
-      template <> struct promote_args_2<std::float32_t, long double> { using type = long double; };
-      template <> struct promote_args_2<long double, std::float32_t> { using type = long double; };
-
-      #ifdef __STDCPP_FLOAT16_T__
-      template <> struct promote_args_2<std::float32_t, std::float16_t> { using type = std::float32_t; };
-      template <> struct promote_args_2<std::float16_t, std::float32_t> { using type = std::float32_t; };
-      #endif
-
-      template <> struct promote_args_2<std::float32_t, std::float32_t> { using type = std::float32_t; };
-      #endif
+      struct pa2_integral_already_removed<T1, T2, true> {
+         using type = std::common_type_t<T1, T2>;
+      };
 
-      #ifdef __STDCPP_FLOAT16_T__
-      template <> struct promote_args_2<int, std::float16_t> { using type = std::float16_t; };
-      template <> struct promote_args_2<std::float16_t, int> { using type = std::float16_t; };
-      template <> struct promote_args_2<std::float16_t, float> { using type = float; };
-      template <> struct promote_args_2<float, std::float16_t> { using type = float; };
-      template <> struct promote_args_2<std::float16_t, double> { using type = double; };
-      template <> struct promote_args_2<double, std::float16_t> { using type = double; };
-      template <> struct promote_args_2<std::float16_t, long double> { using type = long double; };
-      template <> struct promote_args_2<long double, std::float16_t> { using type = long double; };
 
-      template <> struct promote_args_2<std::float16_t, std::float16_t> { using type = std::float16_t; };
-      #endif
+      // Template definition for promote_args_permissive
+      template <typename... Args>
+      struct promote_args_permissive;
+      // Specialization for one argument
+      template <typename T>
+      struct promote_args_permissive<T> {
+         using type = typename promote_arg<typename std::remove_cv<T>::type>::type;
+      };
+      // Specialization for two or more arguments
+      template <typename T1, typename... T2_to_TN>
+      struct promote_args_permissive<T1, T2_to_TN...> {
+         using type = typename pa2_integral_already_removed<
+                  typename promote_args_permissive<T1>::type,
+                  typename promote_args_permissive<T2_to_TN...>::type
+               >::type;
+      };
 
-      template <typename T, typename U>
-      using promote_args_2_t = typename promote_args_2<T, U>::type;
+      template <class... Args>
+      using promote_args_permissive_t = typename promote_args_permissive<Args...>::type;
 
-      template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
-      struct promote_args
-      {
-         using type = typename promote_args_2<
-            typename std::remove_cv<T1>::type,
-            typename promote_args_2<
-               typename std::remove_cv<T2>::type,
-               typename promote_args_2<
-                  typename std::remove_cv<T3>::type,
-                  typename promote_args_2<
-                     typename std::remove_cv<T4>::type,
-                     typename promote_args_2<
-                        typename std::remove_cv<T5>::type, typename std::remove_cv<T6>::type
-                     >::type
-                  >::type
-               >::type
-            >::type
-         >::type;
 
+      // Same as `promote_args_permissive` but with a static assertion that the promoted type
+      // is not `long double` if `BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS` is defined
+      template <class... Args>
+      struct promote_args {
+         using type = typename promote_args_permissive<Args...>::type;
 #if defined(BOOST_MATH_NO_LONG_DOUBLE_MATH_FUNCTIONS)
          //
          // Guard against use of long double if it's not supported:
@@ -268,40 +125,22 @@ namespace boost
 #endif
       };
 
-      template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
-      using promote_args_t = typename promote_args<T1, T2, T3, T4, T5, T6>::type;
+      template <class... Args>
+      using promote_args_t = typename promote_args<Args...>::type;
 
-      //
-      // This struct is the same as above, but has no static assert on long double usage,
-      // it should be used only on functions that can be implemented for long double
-      // even when std lib support is missing or broken for that type.
-      //
-      template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
-      struct promote_args_permissive
-      {
-         using type = typename promote_args_2<
-            typename std::remove_cv<T1>::type,
-            typename promote_args_2<
-               typename std::remove_cv<T2>::type,
-               typename promote_args_2<
-                  typename std::remove_cv<T3>::type,
-                  typename promote_args_2<
-                     typename std::remove_cv<T4>::type,
-                     typename promote_args_2<
-                        typename std::remove_cv<T5>::type, typename std::remove_cv<T6>::type
-                     >::type
-                  >::type
-               >::type
-            >::type
-         >::type;
+
+      // Used by autodiff and files in ccmath
+      template <class T1, class T2>
+      struct promote_args_2 {
+         using type = typename promote_args_permissive<T1, T2>::type;
       };
 
-      template <class T1, class T2=float, class T3=float, class T4=float, class T5=float, class T6=float>
-      using promote_args_permissive_t = typename promote_args_permissive<T1, T2, T3, T4, T5, T6>::type;
+      template <typename T, typename U>
+      using promote_args_2_t = typename promote_args_2<T, U>::type;
+
 
     } // namespace tools
   } // namespace math
 } // namespace boost
 
 #endif // BOOST_MATH_PROMOTION_HPP
-

From de16b832d30b1c5cc881d4369e6de255a00ecb9e Mon Sep 17 00:00:00 2001
From: Ryan <ryan.elandt@gmail.com>
Date: Sat, 26 Aug 2023 14:57:20 -0400
Subject: [PATCH 2/4] test fix for float16_t

---
 include/boost/math/policies/policy.hpp  | 40 +++++++++++++++++--------
 test/compile_test/test_promote_args.cpp |  2 +-
 2 files changed, 28 insertions(+), 14 deletions(-)

diff --git a/include/boost/math/policies/policy.hpp b/include/boost/math/policies/policy.hpp
index 6daebaa64f..8d6b020f54 100644
--- a/include/boost/math/policies/policy.hpp
+++ b/include/boost/math/policies/policy.hpp
@@ -9,6 +9,7 @@
 
 #include <boost/math/tools/config.hpp>
 #include <boost/math/tools/mp.hpp>
+#include <boost/math/tools/promotion.hpp>
 #include <limits>
 #include <type_traits>
 #include <cmath>
@@ -723,22 +724,35 @@ inline constexpr typename normalise<policy<>, A1, A2, A3, A4, A5, A6, A7, A8, A9
 //
 // Traits class to handle internal promotion:
 //
+
 template <class Real, class Policy>
-struct evaluation
-{
-   typedef Real type;
-};
+struct evaluation {
+   // Operation specific minimum float type
+   struct min_policy_allowed_float_type {
+      using type = float;
+   };
 
-template <class Policy>
-struct evaluation<float, Policy>
-{
-   using type = typename std::conditional<Policy::promote_float_type::value, double, float>::type;
-};
+   // Minimum type returned after applying double promotion rules
+   struct min_promote_with_float_type {
+      using type = typename std::conditional<Policy::promote_float_type::value,
+         double, typename min_policy_allowed_float_type::type>::type;
+   };
 
-template <class Policy>
-struct evaluation<double, Policy>
-{
-   using type = typename std::conditional<Policy::promote_double_type::value, long double, double>::type;
+   // Minimum type returned after applying long double promotion rules
+   struct min_promote_with_double_type {
+      using type = typename std::conditional<Policy::promote_double_type::value,
+         long double, typename min_policy_allowed_float_type::type>::type;
+   };
+
+   // Minimum type returned after applying double and long double promotion rules 
+   struct min_evaluation_float_type {
+      using type = typename tools::promote_args<typename min_policy_allowed_float_type::type,
+                                                typename min_promote_with_float_type::type,
+                                                typename min_promote_with_double_type::type>::type;   
+   };
+  
+  using type = typename tools::promote_args<Real, 
+                                            typename min_evaluation_float_type::type>::type;
 };
 
 template <class Real, class Policy>
diff --git a/test/compile_test/test_promote_args.cpp b/test/compile_test/test_promote_args.cpp
index 2281aa7115..3205f139a3 100644
--- a/test/compile_test/test_promote_args.cpp
+++ b/test/compile_test/test_promote_args.cpp
@@ -89,7 +89,7 @@ int main()
    static_assert(std::is_same_v<promote_args_t<std::float16_t, double>, double>);
    static_assert(std::is_same_v<promote_args_t<std::float16_t, long double>, long double>);
 #ifdef __STDCPP_FLOAT16_T__
-   static_assert(std::is_same_v<promote_args_t<std::float16_t, std::float16_t>, float>);
+   static_assert(std::is_same_v<promote_args_t<std::float16_t, std::float16_t>, std::float16_t>);
 #endif
 #ifdef __STDCPP_FLOAT32_T__
    static_assert(std::is_same_v<promote_args_t<std::float16_t, std::float32_t>, std::float32_t>);

From a47822f72be660a9fcc8e769dde04a956cf677e4 Mon Sep 17 00:00:00 2001
From: Ryan <ryan.elandt@gmail.com>
Date: Sat, 26 Aug 2023 17:05:21 -0400
Subject: [PATCH 3/4] fix autodiff tests

---
 include/boost/math/tools/promotion.hpp |   1 +
 test/test_autodiff.hpp                 |  14 ++--
 test/test_autodiff_3.cpp               |   2 +-
 test/test_autodiff_6.cpp               |   4 +-
 test/test_autodiff_8.cpp               | 102 ++++++++++++-------------
 5 files changed, 62 insertions(+), 61 deletions(-)

diff --git a/include/boost/math/tools/promotion.hpp b/include/boost/math/tools/promotion.hpp
index 7894d05e61..2a58a31660 100644
--- a/include/boost/math/tools/promotion.hpp
+++ b/include/boost/math/tools/promotion.hpp
@@ -3,6 +3,7 @@
 // Copyright John Maddock 2006.
 // Copyright Paul A. Bristow 2006.
 // Copyright Matt Borland 2023.
+// Copyright Ryan Elandt 2023.
 
 // Use, modification and distribution are subject to the
 // Boost Software License, Version 1.0.
diff --git a/test/test_autodiff.hpp b/test/test_autodiff.hpp
index 3a53827262..5f68e5577a 100644
--- a/test/test_autodiff.hpp
+++ b/test/test_autodiff.hpp
@@ -161,8 +161,8 @@ static_assert(std::is_same<RandomSample<bmp::cpp_bin_float_50>::dist_t,
 
 }  // namespace test_detail
 
-template<typename T>
-auto isNearZero(const T& t) noexcept -> typename std::enable_if<!diff::is_fvar<T>::value, bool>::type
+template<typename T1, typename T2>
+auto isNearZero(const T2& t) noexcept -> typename std::enable_if<!diff::is_fvar<T2>::value, bool>::type
 {
   using std::sqrt;
   using bmp::sqrt;
@@ -172,14 +172,14 @@ auto isNearZero(const T& t) noexcept -> typename std::enable_if<!diff::is_fvar<T
   using detail::fabs;
   using boost::math::fpclassify;
   using std::sqrt;
-  return fpclassify(fabs(t)) == FP_ZERO || fpclassify(fabs(t)) == FP_SUBNORMAL || boost::math::fpc::is_small(fabs(t), sqrt(std::numeric_limits<T>::epsilon()));
+  return fpclassify(fabs(t)) == FP_ZERO || fpclassify(fabs(t)) == FP_SUBNORMAL || boost::math::fpc::is_small(fabs(t), sqrt(std::numeric_limits<T1>::epsilon()));
 }
 
-template<typename T>
-auto isNearZero(const T& t) noexcept -> typename std::enable_if<diff::is_fvar<T>::value, bool>::type
+template<typename T1, typename T2>
+auto isNearZero(const T2& t) noexcept -> typename std::enable_if<diff::is_fvar<T2>::value, bool>::type
 {
-  using root_type = typename T::root_type;
-  return isNearZero(static_cast<root_type>(t));
+  using root_type = typename T2::root_type;
+  return isNearZero<T1>(static_cast<root_type>(t));
 }
 
 template <typename T, std::size_t Order = 5>
diff --git a/test/test_autodiff_3.cpp b/test/test_autodiff_3.cpp
index e4d8590673..b44e055179 100644
--- a/test/test_autodiff_3.cpp
+++ b/test/test_autodiff_3.cpp
@@ -134,7 +134,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(tanh_test, T, all_float_types) {
   auto x = make_fvar<T, m>(cx);
   auto t = tanh(x);
   for (auto i : boost::irange(tanh_derivatives.size())) {
-    BOOST_TEST_WARN(isNearZero(t.derivative(i) - tanh_derivatives[i]));
+    BOOST_TEST_WARN(isNearZero<T>(t.derivative(i) - tanh_derivatives[i]));
   }
 }
 #endif
diff --git a/test/test_autodiff_6.cpp b/test/test_autodiff_6.cpp
index 7cbc11d0f3..0d8c80e92b 100644
--- a/test/test_autodiff_6.cpp
+++ b/test/test_autodiff_6.cpp
@@ -252,9 +252,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(erf_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
 
-    BOOST_CHECK(isNearZero(erf(make_fvar<T, m>(x)).derivative(0u) -
+    BOOST_CHECK(isNearZero<T>(erf(make_fvar<T, m>(x)).derivative(0u) -
                            boost::math::erf(x)));
-    BOOST_CHECK(isNearZero(erfc(make_fvar<T, m>(x)).derivative(0u) -
+    BOOST_CHECK(isNearZero<T>(erfc(make_fvar<T, m>(x)).derivative(0u) -
                            boost::math::erfc(x)));
   }
 }
diff --git a/test/test_autodiff_8.cpp b/test/test_autodiff_8.cpp
index ecbf3fdc3b..e1776e2d5a 100644
--- a/test/test_autodiff_8.cpp
+++ b/test/test_autodiff_8.cpp
@@ -16,7 +16,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(hermite_hpp, T, all_float_types) {
     auto x = x_sampler.next();
     auto autodiff_v = boost::math::hermite(i, make_fvar<T, m>(x));
     auto anchor_v = boost::math::hermite(i, x);
-    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(heuman_lambda_hpp, T, all_float_types) {
     auto autodiff_v =
         boost::math::heuman_lambda(make_fvar<T, m>(x), make_fvar<T, m>(phi));
     auto anchor_v = boost::math::heuman_lambda(x, phi);
-    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -49,7 +49,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(hypot_hpp, T, all_float_types) {
     auto autodiff_v =
         boost::math::hypot(make_fvar<T, m>(x), make_fvar<T, m>(y));
     auto anchor_v = boost::math::hypot(x, y);
-    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -62,51 +62,51 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(jacobi_elliptic_hpp, T, all_float_types) {
     std::ignore = i;
     auto k = k_sampler.next();
     auto theta = theta_sampler.next();
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_cd(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_cd(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_cn(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_cn(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_cs(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_cs(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_dc(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_dc(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_dn(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_dn(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_ds(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_ds(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_nc(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_nc(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_nd(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_nd(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_ns(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_ns(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_sc(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_sc(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_sd(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_sd(k, theta)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_sn(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_sn(k, theta)));
@@ -123,7 +123,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(jacobi_zeta_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     auto phi = phi_sampler.next();
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         boost::math::jacobi_zeta(make_fvar<T, m>(x), make_fvar<T, m>(phi))
             .derivative(0u) -
         boost::math::jacobi_zeta(x, phi)));
@@ -149,12 +149,12 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(laguerre_hpp, T, all_float_types) {
     {
       auto autodiff_v = boost::math::laguerre(n, make_fvar<T, m>(x));
       auto anchor_v = boost::math::laguerre(n, x);
-      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
     }
     {
       auto autodiff_v = boost::math::laguerre(n, r, make_fvar<T, m>(x));
       auto anchor_v = boost::math::laguerre(n, r, x);
-      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
     }
   }
 }
@@ -185,12 +185,12 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(lambert_w_hpp, T, all_float_types) {
       {
         auto autodiff_v = boost::math::lambert_w0(make_fvar<T, m>(x_));
         auto anchor_v = boost::math::lambert_w0(x_);
-        BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+        BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
       }
       {
         auto autodiff_v = boost::math::lambert_w0_prime(make_fvar<T, m>(x_));
         auto anchor_v = boost::math::lambert_w0_prime(x_);
-        BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+        BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
       }
     }
 
@@ -201,10 +201,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(lambert_w_hpp, T, all_float_types) {
               ((std::numeric_limits<promoted_t>::max))())),
           ((std::numeric_limits<T>::max))());
       x_ = (max)(static_cast<T>(-0.36), x_);
-      BOOST_CHECK(isNearZero(
+      BOOST_CHECK(isNearZero<T>(
           boost::math::lambert_wm1(make_fvar<T, m>(x_)).derivative(0u) -
           boost::math::lambert_wm1(x_)));
-      BOOST_CHECK(isNearZero(
+      BOOST_CHECK(isNearZero<T>(
           boost::math::lambert_wm1_prime(make_fvar<T, m>(x_)).derivative(0u) -
           boost::math::lambert_wm1_prime(x_)));
     }
@@ -222,7 +222,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(log1p_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     BOOST_CHECK(
-        isNearZero(log1p(make_fvar<T, m>(x)).derivative(0u) - log1p(x)));
+        isNearZero<T>(log1p(make_fvar<T, m>(x)).derivative(0u) - log1p(x)));
   }
 }
 
@@ -239,59 +239,59 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(next_hpp, T, all_float_types) {
   for (auto i : boost::irange(test_constants::n_samples)) {
     const auto j = static_cast<T>(i);
     auto fvar_j = make_fvar<T, m>(j);
-    BOOST_CHECK(isNearZero(float_next(fvar_j).derivative(0u) - float_next(j)));
+    BOOST_CHECK(isNearZero<T>(float_next(fvar_j).derivative(0u) - float_next(j)));
     BOOST_CHECK(
-        isNearZero(float_prior(fvar_j).derivative(0u) - float_prior(j)));
+        isNearZero<T>(float_prior(fvar_j).derivative(0u) - float_prior(j)));
 
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(1))).derivative(0u) -
         nextafter(j, static_cast<T>(1))));
     BOOST_CHECK(
-        isNearZero(nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(i + 2))) -
+        isNearZero<T>(nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(i + 2))) -
                    nextafter(j, static_cast<T>(i + 2))));
     BOOST_CHECK(
-        isNearZero(nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(i + 1)))
+        isNearZero<T>(nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(i + 1)))
                        .derivative(0u) -
                    nextafter(j, static_cast<T>(i + 2))));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(-1))).derivative(0u) -
         nextafter(j, static_cast<T>(-1))));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(-1 * (i + 2))))
             .derivative(0u) -
         nextafter(j, -1 * static_cast<T>(i + 2))));
 
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(-1 * (i + 1))))
             .derivative(0u) -
         nextafter(j, -1 * static_cast<T>(i + 2))));
 
-    BOOST_CHECK(isNearZero(nextafter(fvar_j, fvar_j) - fvar_j));
+    BOOST_CHECK(isNearZero<T>(nextafter(fvar_j, fvar_j) - fvar_j));
 
-    BOOST_CHECK(isNearZero(float_advance(fvar_j, 1).derivative(0u) -
+    BOOST_CHECK(isNearZero<T>(float_advance(fvar_j, 1).derivative(0u) -
                            float_advance(j, 1)));
-    BOOST_CHECK(isNearZero(float_advance(fvar_j, i + 2).derivative(0u) -
+    BOOST_CHECK(isNearZero<T>(float_advance(fvar_j, i + 2).derivative(0u) -
                            float_advance(j, i + 2)));
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         float_advance(fvar_j, i + 1).derivative(0u) -
         float_advance(float_advance(fvar_j, i + 2), -1).derivative(0u)));
 
-    BOOST_CHECK(isNearZero(float_advance(fvar_j, -1).derivative(0u) -
+    BOOST_CHECK(isNearZero<T>(float_advance(fvar_j, -1).derivative(0u) -
                            float_advance(j, -1)));
 
-    BOOST_CHECK(isNearZero(
+    BOOST_CHECK(isNearZero<T>(
         float_advance(fvar_j, -i - 1).derivative(0u) -
         float_advance(float_advance(fvar_j, -i - 2), 1).derivative(0u)));
 
-    BOOST_CHECK(isNearZero(float_advance(fvar_j, 0) - fvar_j));
+    BOOST_CHECK(isNearZero<T>(float_advance(fvar_j, 0) - fvar_j));
 
-    BOOST_CHECK(isNearZero(float_distance(fvar_j, j).derivative(0u) -
+    BOOST_CHECK(isNearZero<T>(float_distance(fvar_j, j).derivative(0u) -
                            static_cast<T>(0)));
     BOOST_CHECK(
-        isNearZero(float_distance(float_next(fvar_j), fvar_j).derivative(0u) -
+        isNearZero<T>(float_distance(float_next(fvar_j), fvar_j).derivative(0u) -
                    ((make_fvar<T, m>(-1))).derivative(0u)));
     BOOST_CHECK(
-        isNearZero(float_distance(float_prior(fvar_j), fvar_j).derivative(0u) -
+        isNearZero<T>(float_distance(float_prior(fvar_j), fvar_j).derivative(0u) -
                    (make_fvar<T, m>(1)).derivative(0u)));
   }
 }
@@ -309,7 +309,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(owens_t_hpp, T, bin_float_types) {
     auto autodiff_v =
         boost::math::owens_t(make_fvar<T, m>(h), make_fvar<T, m>(a));
     auto anchor_v = boost::math::owens_t(h, a);
-    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -360,7 +360,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(polygamma_hpp, T, all_float_types) {
     try {
       auto autodiff_v = boost::math::polygamma(i, make_fvar<T, m>(x));
       auto anchor_v = boost::math::polygamma(i, x);
-      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
     } catch (const std::overflow_error &) {
       std::cout << "Overflow Error thrown with inputs i: " << i << " x: " << x
                 << std::endl;
@@ -406,7 +406,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(powm1_hpp, T, all_float_types) {
     auto autodiff_v =
         boost::math::powm1(make_fvar<T, m>(x), make_fvar<T, m>(y));
     auto anchor_v = boost::math::powm1(x, y);
-    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -420,7 +420,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(sin_pi_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     BOOST_CHECK(
-        isNearZero(boost::math::sin_pi(make_fvar<T, m>(x)).derivative(0u) -
+        isNearZero<T>(boost::math::sin_pi(make_fvar<T, m>(x)).derivative(0u) -
                    boost::math::sin_pi(x)));
   }
 }
@@ -459,23 +459,23 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(spherical_harmonic_hpp, T, all_float_types) {
           n, r, make_fvar<T, m>(theta), make_fvar<T, m>(phi));
       auto anchor_v = boost::math::spherical_harmonic(n, r, theta, phi);
       BOOST_CHECK(
-          isNearZero(autodiff_v.real().derivative(0u) - anchor_v.real()));
+          isNearZero<T>(autodiff_v.real().derivative(0u) - anchor_v.real()));
       BOOST_CHECK(
-          isNearZero(autodiff_v.imag().derivative(0u) - anchor_v.imag()));
+          isNearZero<T>(autodiff_v.imag().derivative(0u) - anchor_v.imag()));
     }
 
     {
       auto autodiff_v = boost::math::spherical_harmonic_r(
           n, r, make_fvar<T, m>(theta), make_fvar<T, m>(phi));
       auto anchor_v = boost::math::spherical_harmonic_r(n, r, theta, phi);
-      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
     }
 
     {
       auto autodiff_v = boost::math::spherical_harmonic_i(
           n, r, make_fvar<T, m>(theta), make_fvar<T, m>(phi));
       auto anchor_v = boost::math::spherical_harmonic_i(n, r, theta, phi);
-      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
     }
   }
 }
@@ -488,7 +488,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(sqrt1pm1_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     BOOST_CHECK(
-        isNearZero(boost::math::sqrt1pm1(make_fvar<T, m>(x)).derivative(0u) -
+        isNearZero<T>(boost::math::sqrt1pm1(make_fvar<T, m>(x)).derivative(0u) -
                    boost::math::sqrt1pm1(x)));
   }
 }
@@ -501,7 +501,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(trigamma_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     BOOST_CHECK(
-        isNearZero(boost::math::trigamma(make_fvar<T, m>(x)).derivative(0u) -
+        isNearZero<T>(boost::math::trigamma(make_fvar<T, m>(x)).derivative(0u) -
                    boost::math::trigamma(x)));
   }
 }

From 024d56cc38ac86d3dc62752f90f5633fef40ed62 Mon Sep 17 00:00:00 2001
From: Ryan <ryan.elandt@gmail.com>
Date: Sat, 26 Aug 2023 17:58:49 -0400
Subject: [PATCH 4/4] specialize promote_args for autodiff

---
 include/boost/math/ccmath/copysign.hpp        |   2 +-
 include/boost/math/ccmath/fdim.hpp            |   2 +-
 include/boost/math/ccmath/fmax.hpp            |   2 +-
 include/boost/math/ccmath/fmin.hpp            |   2 +-
 include/boost/math/ccmath/hypot.hpp           |   2 +-
 .../boost/math/differentiation/autodiff.hpp   |  14 +--
 include/boost/math/tools/promotion.hpp        |  11 --
 test/test_autodiff.hpp                        |  14 +--
 test/test_autodiff_3.cpp                      |   2 +-
 test/test_autodiff_6.cpp                      |   4 +-
 test/test_autodiff_8.cpp                      | 102 +++++++++---------
 11 files changed, 73 insertions(+), 84 deletions(-)

diff --git a/include/boost/math/ccmath/copysign.hpp b/include/boost/math/ccmath/copysign.hpp
index 90a58102b1..e117e57faa 100644
--- a/include/boost/math/ccmath/copysign.hpp
+++ b/include/boost/math/ccmath/copysign.hpp
@@ -54,7 +54,7 @@ constexpr auto copysign(T1 mag, T2 sgn) noexcept
 {
     if (BOOST_MATH_IS_CONSTANT_EVALUATED(mag))
     {        
-        using promoted_type = boost::math::tools::promote_args_2_t<T1, T2>;
+        using promoted_type = boost::math::tools::promote_args_t<T1, T2>;
         return boost::math::ccmath::copysign(static_cast<promoted_type>(mag), static_cast<promoted_type>(sgn));
     }
     else
diff --git a/include/boost/math/ccmath/fdim.hpp b/include/boost/math/ccmath/fdim.hpp
index 024eb9c934..3aeddda9b5 100644
--- a/include/boost/math/ccmath/fdim.hpp
+++ b/include/boost/math/ccmath/fdim.hpp
@@ -64,7 +64,7 @@ constexpr auto fdim(T1 x, T2 y) noexcept
 {
     if (BOOST_MATH_IS_CONSTANT_EVALUATED(x))
     {
-        using promoted_type = boost::math::tools::promote_args_2_t<T1, T2>;
+        using promoted_type = boost::math::tools::promote_args_t<T1, T2>;
         return boost::math::ccmath::fdim(promoted_type(x), promoted_type(y));
     }
     else
diff --git a/include/boost/math/ccmath/fmax.hpp b/include/boost/math/ccmath/fmax.hpp
index 0eb1ecbaae..e477b41dc6 100644
--- a/include/boost/math/ccmath/fmax.hpp
+++ b/include/boost/math/ccmath/fmax.hpp
@@ -60,7 +60,7 @@ constexpr auto fmax(T1 x, T2 y) noexcept
 {
     if (BOOST_MATH_IS_CONSTANT_EVALUATED(x))
     {
-        using promoted_type = boost::math::tools::promote_args_2_t<T1, T2>;
+        using promoted_type = boost::math::tools::promote_args_t<T1, T2>;
         return boost::math::ccmath::fmax(static_cast<promoted_type>(x), static_cast<promoted_type>(y));
     }
     else
diff --git a/include/boost/math/ccmath/fmin.hpp b/include/boost/math/ccmath/fmin.hpp
index 3de0b7e434..d2a8570755 100644
--- a/include/boost/math/ccmath/fmin.hpp
+++ b/include/boost/math/ccmath/fmin.hpp
@@ -60,7 +60,7 @@ constexpr auto fmin(T1 x, T2 y) noexcept
 {
     if (BOOST_MATH_IS_CONSTANT_EVALUATED(x))
     {
-        using promoted_type = boost::math::tools::promote_args_2_t<T1, T2>;
+        using promoted_type = boost::math::tools::promote_args_t<T1, T2>;
         return boost::math::ccmath::fmin(static_cast<promoted_type>(x), static_cast<promoted_type>(y));
     }
     else
diff --git a/include/boost/math/ccmath/hypot.hpp b/include/boost/math/ccmath/hypot.hpp
index 613b2681ac..9f866dbb70 100644
--- a/include/boost/math/ccmath/hypot.hpp
+++ b/include/boost/math/ccmath/hypot.hpp
@@ -87,7 +87,7 @@ constexpr auto hypot(T1 x, T2 y) noexcept
 {
     if(BOOST_MATH_IS_CONSTANT_EVALUATED(x))
     {
-        using promoted_type = boost::math::tools::promote_args_2_t<T1, T2>;
+        using promoted_type = boost::math::tools::promote_args_t<T1, T2>;
         return boost::math::ccmath::hypot(static_cast<promoted_type>(x), static_cast<promoted_type>(y));
     }
     else
diff --git a/include/boost/math/differentiation/autodiff.hpp b/include/boost/math/differentiation/autodiff.hpp
index 7cda196852..9ee5bdcd63 100644
--- a/include/boost/math/differentiation/autodiff.hpp
+++ b/include/boost/math/differentiation/autodiff.hpp
@@ -39,7 +39,7 @@ namespace detail {
 
 template <typename RealType, typename... RealTypes>
 struct promote_args_n {
-  using type = typename tools::promote_args_2<RealType, typename promote_args_n<RealTypes...>::type>::type;
+  using type = typename tools::promote_args<RealType, typename promote_args_n<RealTypes...>::type>::type;
 };
 
 template <typename RealType>
@@ -2002,9 +2002,9 @@ using autodiff_root_type = typename autodiff_fvar_type<RealType, Order>::root_ty
 
 // See boost/math/tools/promotion.hpp
 template <typename RealType0, size_t Order0, typename RealType1, size_t Order1>
-struct promote_args_2<detail::autodiff_fvar_type<RealType0, Order0>,
+struct promote_args<detail::autodiff_fvar_type<RealType0, Order0>,
                       detail::autodiff_fvar_type<RealType1, Order1>> {
-  using type = detail::autodiff_fvar_type<typename promote_args_2<RealType0, RealType1>::type,
+  using type = detail::autodiff_fvar_type<typename promote_args<RealType0, RealType1>::type,
 #ifndef BOOST_NO_CXX14_CONSTEXPR
                                           (std::max)(Order0, Order1)>;
 #else
@@ -2018,13 +2018,13 @@ struct promote_args<detail::autodiff_fvar_type<RealType, Order>> {
 };
 
 template <typename RealType0, size_t Order0, typename RealType1>
-struct promote_args_2<detail::autodiff_fvar_type<RealType0, Order0>, RealType1> {
-  using type = detail::autodiff_fvar_type<typename promote_args_2<RealType0, RealType1>::type, Order0>;
+struct promote_args<detail::autodiff_fvar_type<RealType0, Order0>, RealType1> {
+  using type = detail::autodiff_fvar_type<typename promote_args<RealType0, RealType1>::type, Order0>;
 };
 
 template <typename RealType0, typename RealType1, size_t Order1>
-struct promote_args_2<RealType0, detail::autodiff_fvar_type<RealType1, Order1>> {
-  using type = detail::autodiff_fvar_type<typename promote_args_2<RealType0, RealType1>::type, Order1>;
+struct promote_args<RealType0, detail::autodiff_fvar_type<RealType1, Order1>> {
+  using type = detail::autodiff_fvar_type<typename promote_args<RealType0, RealType1>::type, Order1>;
 };
 
 template <typename destination_t, typename RealType, std::size_t Order>
diff --git a/include/boost/math/tools/promotion.hpp b/include/boost/math/tools/promotion.hpp
index 2a58a31660..54920b4628 100644
--- a/include/boost/math/tools/promotion.hpp
+++ b/include/boost/math/tools/promotion.hpp
@@ -129,17 +129,6 @@ namespace boost
       template <class... Args>
       using promote_args_t = typename promote_args<Args...>::type;
 
-
-      // Used by autodiff and files in ccmath
-      template <class T1, class T2>
-      struct promote_args_2 {
-         using type = typename promote_args_permissive<T1, T2>::type;
-      };
-
-      template <typename T, typename U>
-      using promote_args_2_t = typename promote_args_2<T, U>::type;
-
-
     } // namespace tools
   } // namespace math
 } // namespace boost
diff --git a/test/test_autodiff.hpp b/test/test_autodiff.hpp
index 5f68e5577a..3a53827262 100644
--- a/test/test_autodiff.hpp
+++ b/test/test_autodiff.hpp
@@ -161,8 +161,8 @@ static_assert(std::is_same<RandomSample<bmp::cpp_bin_float_50>::dist_t,
 
 }  // namespace test_detail
 
-template<typename T1, typename T2>
-auto isNearZero(const T2& t) noexcept -> typename std::enable_if<!diff::is_fvar<T2>::value, bool>::type
+template<typename T>
+auto isNearZero(const T& t) noexcept -> typename std::enable_if<!diff::is_fvar<T>::value, bool>::type
 {
   using std::sqrt;
   using bmp::sqrt;
@@ -172,14 +172,14 @@ auto isNearZero(const T2& t) noexcept -> typename std::enable_if<!diff::is_fvar<
   using detail::fabs;
   using boost::math::fpclassify;
   using std::sqrt;
-  return fpclassify(fabs(t)) == FP_ZERO || fpclassify(fabs(t)) == FP_SUBNORMAL || boost::math::fpc::is_small(fabs(t), sqrt(std::numeric_limits<T1>::epsilon()));
+  return fpclassify(fabs(t)) == FP_ZERO || fpclassify(fabs(t)) == FP_SUBNORMAL || boost::math::fpc::is_small(fabs(t), sqrt(std::numeric_limits<T>::epsilon()));
 }
 
-template<typename T1, typename T2>
-auto isNearZero(const T2& t) noexcept -> typename std::enable_if<diff::is_fvar<T2>::value, bool>::type
+template<typename T>
+auto isNearZero(const T& t) noexcept -> typename std::enable_if<diff::is_fvar<T>::value, bool>::type
 {
-  using root_type = typename T2::root_type;
-  return isNearZero<T1>(static_cast<root_type>(t));
+  using root_type = typename T::root_type;
+  return isNearZero(static_cast<root_type>(t));
 }
 
 template <typename T, std::size_t Order = 5>
diff --git a/test/test_autodiff_3.cpp b/test/test_autodiff_3.cpp
index b44e055179..e4d8590673 100644
--- a/test/test_autodiff_3.cpp
+++ b/test/test_autodiff_3.cpp
@@ -134,7 +134,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(tanh_test, T, all_float_types) {
   auto x = make_fvar<T, m>(cx);
   auto t = tanh(x);
   for (auto i : boost::irange(tanh_derivatives.size())) {
-    BOOST_TEST_WARN(isNearZero<T>(t.derivative(i) - tanh_derivatives[i]));
+    BOOST_TEST_WARN(isNearZero(t.derivative(i) - tanh_derivatives[i]));
   }
 }
 #endif
diff --git a/test/test_autodiff_6.cpp b/test/test_autodiff_6.cpp
index 0d8c80e92b..7cbc11d0f3 100644
--- a/test/test_autodiff_6.cpp
+++ b/test/test_autodiff_6.cpp
@@ -252,9 +252,9 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(erf_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
 
-    BOOST_CHECK(isNearZero<T>(erf(make_fvar<T, m>(x)).derivative(0u) -
+    BOOST_CHECK(isNearZero(erf(make_fvar<T, m>(x)).derivative(0u) -
                            boost::math::erf(x)));
-    BOOST_CHECK(isNearZero<T>(erfc(make_fvar<T, m>(x)).derivative(0u) -
+    BOOST_CHECK(isNearZero(erfc(make_fvar<T, m>(x)).derivative(0u) -
                            boost::math::erfc(x)));
   }
 }
diff --git a/test/test_autodiff_8.cpp b/test/test_autodiff_8.cpp
index e1776e2d5a..ecbf3fdc3b 100644
--- a/test/test_autodiff_8.cpp
+++ b/test/test_autodiff_8.cpp
@@ -16,7 +16,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(hermite_hpp, T, all_float_types) {
     auto x = x_sampler.next();
     auto autodiff_v = boost::math::hermite(i, make_fvar<T, m>(x));
     auto anchor_v = boost::math::hermite(i, x);
-    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -33,7 +33,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(heuman_lambda_hpp, T, all_float_types) {
     auto autodiff_v =
         boost::math::heuman_lambda(make_fvar<T, m>(x), make_fvar<T, m>(phi));
     auto anchor_v = boost::math::heuman_lambda(x, phi);
-    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -49,7 +49,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(hypot_hpp, T, all_float_types) {
     auto autodiff_v =
         boost::math::hypot(make_fvar<T, m>(x), make_fvar<T, m>(y));
     auto anchor_v = boost::math::hypot(x, y);
-    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -62,51 +62,51 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(jacobi_elliptic_hpp, T, all_float_types) {
     std::ignore = i;
     auto k = k_sampler.next();
     auto theta = theta_sampler.next();
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_cd(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_cd(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_cn(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_cn(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_cs(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_cs(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_dc(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_dc(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_dn(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_dn(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_ds(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_ds(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_nc(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_nc(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_nd(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_nd(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_ns(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_ns(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_sc(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_sc(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_sd(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_sd(k, theta)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_sn(make_fvar<T, m>(k), make_fvar<T, m>(theta))
             .derivative(0u) -
         boost::math::jacobi_sn(k, theta)));
@@ -123,7 +123,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(jacobi_zeta_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     auto phi = phi_sampler.next();
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         boost::math::jacobi_zeta(make_fvar<T, m>(x), make_fvar<T, m>(phi))
             .derivative(0u) -
         boost::math::jacobi_zeta(x, phi)));
@@ -149,12 +149,12 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(laguerre_hpp, T, all_float_types) {
     {
       auto autodiff_v = boost::math::laguerre(n, make_fvar<T, m>(x));
       auto anchor_v = boost::math::laguerre(n, x);
-      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
     }
     {
       auto autodiff_v = boost::math::laguerre(n, r, make_fvar<T, m>(x));
       auto anchor_v = boost::math::laguerre(n, r, x);
-      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
     }
   }
 }
@@ -185,12 +185,12 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(lambert_w_hpp, T, all_float_types) {
       {
         auto autodiff_v = boost::math::lambert_w0(make_fvar<T, m>(x_));
         auto anchor_v = boost::math::lambert_w0(x_);
-        BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+        BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
       }
       {
         auto autodiff_v = boost::math::lambert_w0_prime(make_fvar<T, m>(x_));
         auto anchor_v = boost::math::lambert_w0_prime(x_);
-        BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+        BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
       }
     }
 
@@ -201,10 +201,10 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(lambert_w_hpp, T, all_float_types) {
               ((std::numeric_limits<promoted_t>::max))())),
           ((std::numeric_limits<T>::max))());
       x_ = (max)(static_cast<T>(-0.36), x_);
-      BOOST_CHECK(isNearZero<T>(
+      BOOST_CHECK(isNearZero(
           boost::math::lambert_wm1(make_fvar<T, m>(x_)).derivative(0u) -
           boost::math::lambert_wm1(x_)));
-      BOOST_CHECK(isNearZero<T>(
+      BOOST_CHECK(isNearZero(
           boost::math::lambert_wm1_prime(make_fvar<T, m>(x_)).derivative(0u) -
           boost::math::lambert_wm1_prime(x_)));
     }
@@ -222,7 +222,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(log1p_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     BOOST_CHECK(
-        isNearZero<T>(log1p(make_fvar<T, m>(x)).derivative(0u) - log1p(x)));
+        isNearZero(log1p(make_fvar<T, m>(x)).derivative(0u) - log1p(x)));
   }
 }
 
@@ -239,59 +239,59 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(next_hpp, T, all_float_types) {
   for (auto i : boost::irange(test_constants::n_samples)) {
     const auto j = static_cast<T>(i);
     auto fvar_j = make_fvar<T, m>(j);
-    BOOST_CHECK(isNearZero<T>(float_next(fvar_j).derivative(0u) - float_next(j)));
+    BOOST_CHECK(isNearZero(float_next(fvar_j).derivative(0u) - float_next(j)));
     BOOST_CHECK(
-        isNearZero<T>(float_prior(fvar_j).derivative(0u) - float_prior(j)));
+        isNearZero(float_prior(fvar_j).derivative(0u) - float_prior(j)));
 
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(1))).derivative(0u) -
         nextafter(j, static_cast<T>(1))));
     BOOST_CHECK(
-        isNearZero<T>(nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(i + 2))) -
+        isNearZero(nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(i + 2))) -
                    nextafter(j, static_cast<T>(i + 2))));
     BOOST_CHECK(
-        isNearZero<T>(nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(i + 1)))
+        isNearZero(nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(i + 1)))
                        .derivative(0u) -
                    nextafter(j, static_cast<T>(i + 2))));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(-1))).derivative(0u) -
         nextafter(j, static_cast<T>(-1))));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(-1 * (i + 2))))
             .derivative(0u) -
         nextafter(j, -1 * static_cast<T>(i + 2))));
 
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         nextafter(fvar_j, make_fvar<T, m>(static_cast<T>(-1 * (i + 1))))
             .derivative(0u) -
         nextafter(j, -1 * static_cast<T>(i + 2))));
 
-    BOOST_CHECK(isNearZero<T>(nextafter(fvar_j, fvar_j) - fvar_j));
+    BOOST_CHECK(isNearZero(nextafter(fvar_j, fvar_j) - fvar_j));
 
-    BOOST_CHECK(isNearZero<T>(float_advance(fvar_j, 1).derivative(0u) -
+    BOOST_CHECK(isNearZero(float_advance(fvar_j, 1).derivative(0u) -
                            float_advance(j, 1)));
-    BOOST_CHECK(isNearZero<T>(float_advance(fvar_j, i + 2).derivative(0u) -
+    BOOST_CHECK(isNearZero(float_advance(fvar_j, i + 2).derivative(0u) -
                            float_advance(j, i + 2)));
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         float_advance(fvar_j, i + 1).derivative(0u) -
         float_advance(float_advance(fvar_j, i + 2), -1).derivative(0u)));
 
-    BOOST_CHECK(isNearZero<T>(float_advance(fvar_j, -1).derivative(0u) -
+    BOOST_CHECK(isNearZero(float_advance(fvar_j, -1).derivative(0u) -
                            float_advance(j, -1)));
 
-    BOOST_CHECK(isNearZero<T>(
+    BOOST_CHECK(isNearZero(
         float_advance(fvar_j, -i - 1).derivative(0u) -
         float_advance(float_advance(fvar_j, -i - 2), 1).derivative(0u)));
 
-    BOOST_CHECK(isNearZero<T>(float_advance(fvar_j, 0) - fvar_j));
+    BOOST_CHECK(isNearZero(float_advance(fvar_j, 0) - fvar_j));
 
-    BOOST_CHECK(isNearZero<T>(float_distance(fvar_j, j).derivative(0u) -
+    BOOST_CHECK(isNearZero(float_distance(fvar_j, j).derivative(0u) -
                            static_cast<T>(0)));
     BOOST_CHECK(
-        isNearZero<T>(float_distance(float_next(fvar_j), fvar_j).derivative(0u) -
+        isNearZero(float_distance(float_next(fvar_j), fvar_j).derivative(0u) -
                    ((make_fvar<T, m>(-1))).derivative(0u)));
     BOOST_CHECK(
-        isNearZero<T>(float_distance(float_prior(fvar_j), fvar_j).derivative(0u) -
+        isNearZero(float_distance(float_prior(fvar_j), fvar_j).derivative(0u) -
                    (make_fvar<T, m>(1)).derivative(0u)));
   }
 }
@@ -309,7 +309,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(owens_t_hpp, T, bin_float_types) {
     auto autodiff_v =
         boost::math::owens_t(make_fvar<T, m>(h), make_fvar<T, m>(a));
     auto anchor_v = boost::math::owens_t(h, a);
-    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -360,7 +360,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(polygamma_hpp, T, all_float_types) {
     try {
       auto autodiff_v = boost::math::polygamma(i, make_fvar<T, m>(x));
       auto anchor_v = boost::math::polygamma(i, x);
-      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
     } catch (const std::overflow_error &) {
       std::cout << "Overflow Error thrown with inputs i: " << i << " x: " << x
                 << std::endl;
@@ -406,7 +406,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(powm1_hpp, T, all_float_types) {
     auto autodiff_v =
         boost::math::powm1(make_fvar<T, m>(x), make_fvar<T, m>(y));
     auto anchor_v = boost::math::powm1(x, y);
-    BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+    BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
   }
 }
 
@@ -420,7 +420,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(sin_pi_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     BOOST_CHECK(
-        isNearZero<T>(boost::math::sin_pi(make_fvar<T, m>(x)).derivative(0u) -
+        isNearZero(boost::math::sin_pi(make_fvar<T, m>(x)).derivative(0u) -
                    boost::math::sin_pi(x)));
   }
 }
@@ -459,23 +459,23 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(spherical_harmonic_hpp, T, all_float_types) {
           n, r, make_fvar<T, m>(theta), make_fvar<T, m>(phi));
       auto anchor_v = boost::math::spherical_harmonic(n, r, theta, phi);
       BOOST_CHECK(
-          isNearZero<T>(autodiff_v.real().derivative(0u) - anchor_v.real()));
+          isNearZero(autodiff_v.real().derivative(0u) - anchor_v.real()));
       BOOST_CHECK(
-          isNearZero<T>(autodiff_v.imag().derivative(0u) - anchor_v.imag()));
+          isNearZero(autodiff_v.imag().derivative(0u) - anchor_v.imag()));
     }
 
     {
       auto autodiff_v = boost::math::spherical_harmonic_r(
           n, r, make_fvar<T, m>(theta), make_fvar<T, m>(phi));
       auto anchor_v = boost::math::spherical_harmonic_r(n, r, theta, phi);
-      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
     }
 
     {
       auto autodiff_v = boost::math::spherical_harmonic_i(
           n, r, make_fvar<T, m>(theta), make_fvar<T, m>(phi));
       auto anchor_v = boost::math::spherical_harmonic_i(n, r, theta, phi);
-      BOOST_CHECK(isNearZero<T>(autodiff_v.derivative(0u) - anchor_v));
+      BOOST_CHECK(isNearZero(autodiff_v.derivative(0u) - anchor_v));
     }
   }
 }
@@ -488,7 +488,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(sqrt1pm1_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     BOOST_CHECK(
-        isNearZero<T>(boost::math::sqrt1pm1(make_fvar<T, m>(x)).derivative(0u) -
+        isNearZero(boost::math::sqrt1pm1(make_fvar<T, m>(x)).derivative(0u) -
                    boost::math::sqrt1pm1(x)));
   }
 }
@@ -501,7 +501,7 @@ BOOST_AUTO_TEST_CASE_TEMPLATE(trigamma_hpp, T, all_float_types) {
     std::ignore = i;
     auto x = x_sampler.next();
     BOOST_CHECK(
-        isNearZero<T>(boost::math::trigamma(make_fvar<T, m>(x)).derivative(0u) -
+        isNearZero(boost::math::trigamma(make_fvar<T, m>(x)).derivative(0u) -
                    boost::math::trigamma(x)));
   }
 }