change name of PBC assert for API preconditions to HPBC_CLOCKWORK_API_PRECONDITION

hurchalla · hurchalla · commit cb5e74a154dc · 2025-08-26T15:23:24.000-07:00
diff --git a/modular_arithmetic/include/hurchalla/modular_arithmetic/absolute_value_difference.h b/modular_arithmetic/include/hurchalla/modular_arithmetic/absolute_value_difference.h
@@ -24,8 +24,8 @@ template <typename T>  HURCHALLA_FORCE_INLINE
 T absolute_value_difference(T a, T b)
 {
     static_assert(ut_numeric_limits<T>::is_integer, "");
-    HPBC_CLOCKWORK_PRECONDITION(a >= 0);
-    HPBC_CLOCKWORK_PRECONDITION(b >= 0);
+    HPBC_CLOCKWORK_API_PRECONDITION(a >= 0);
+    HPBC_CLOCKWORK_API_PRECONDITION(b >= 0);
 
     T result = detail::impl_absolute_value_difference<T>::call(a, b);
 
diff --git a/modular_arithmetic/include/hurchalla/modular_arithmetic/detail/clockwork_programming_by_contract.h b/modular_arithmetic/include/hurchalla/modular_arithmetic/detail/clockwork_programming_by_contract.h
@@ -17,11 +17,11 @@
 
 
 
-#if defined(HURCHALLA_CLOCKWORK_ENABLE_ASSERTS) || defined(CLOCKWORK_CHECK_API_PRECONDITIONS)
+#if defined(HURCHALLA_CLOCKWORK_ENABLE_ASSERTS) || \
+    defined(CLOCKWORK_CHECK_API_PRECONDITIONS)
 
 #  include <cstdio>
 #  include <cstdlib>
-
       /* We can (probably) detect if exceptions are enabled by checking the
          gcc/clang macro __EXCEPTIONS, msvc's macro _CPPUNWIND, and the official
          but not always supported C++98 macro __cpp_exceptions. */
@@ -51,19 +51,20 @@
                } while(0)
 #  endif
 
-#  define HPBC_CLOCKWORK_PRECONDITION(...) do { \
+#  define HPBC_CLOCKWORK_API_PRECONDITION(...) do { \
                             HPBC_CLOCKWORK_BASIC_ASSERT(__VA_ARGS__); } while(0)
 
 #else
-#  define HPBC_CLOCKWORK_PRECONDITION(...) HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
+#  define HPBC_CLOCKWORK_API_PRECONDITION(...) \
+                            HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
 
 #endif
 
 
 
 #if !defined(HURCHALLA_CLOCKWORK_ENABLE_ASSERTS)
 
-#  define HPBC_CLOCKWORK_PRECONDITION1(...) HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
+#  define HPBC_CLOCKWORK_PRECONDITION(...) HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
 #  define HPBC_CLOCKWORK_PRECONDITION2(...) HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
 #  define HPBC_CLOCKWORK_PRECONDITION3(...) HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
 #  define HPBC_CLOCKWORK_POSTCONDITION(...) HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
@@ -81,7 +82,7 @@
 #  else
 #     define HPBC_CLOCKWORK_FALSE_VALUE (0)
 #  endif
-#  define HPBC_CLOCKWORK_PRECONDITION1_MACRO_IS_ACTIVE HPBC_CLOCKWORK_FALSE_VALUE
+#  define HPBC_CLOCKWORK_PRECONDITION_MACRO_IS_ACTIVE HPBC_CLOCKWORK_FALSE_VALUE
 #  define HPBC_CLOCKWORK_PRECONDITION2_MACRO_IS_ACTIVE HPBC_CLOCKWORK_FALSE_VALUE
 #  define HPBC_CLOCKWORK_PRECONDITION3_MACRO_IS_ACTIVE HPBC_CLOCKWORK_FALSE_VALUE
 #  define HPBC_CLOCKWORK_POSTCONDITION_MACRO_IS_ACTIVE HPBC_CLOCKWORK_FALSE_VALUE
@@ -112,7 +113,7 @@
                        if (HURCHALLA_CLOCKWORK_ASSERT_LEVEL >= LEVEL) { \
                             HPBC_CLOCKWORK_BASIC_ASSERT(__VA_ARGS__); } } while(0)
 
-#  define HPBC_CLOCKWORK_PRECONDITION1(...) HPBC_CLOCKWORK_LEVEL_ASSERT(1, __VA_ARGS__)
+#  define HPBC_CLOCKWORK_PRECONDITION(...) HPBC_CLOCKWORK_LEVEL_ASSERT(1, __VA_ARGS__)
 #  define HPBC_CLOCKWORK_PRECONDITION2(...) HPBC_CLOCKWORK_LEVEL_ASSERT(2, __VA_ARGS__)
 #  define HPBC_CLOCKWORK_PRECONDITION3(...) HPBC_CLOCKWORK_LEVEL_ASSERT(3, __VA_ARGS__)
 #  define HPBC_CLOCKWORK_POSTCONDITION(...) HPBC_CLOCKWORK_LEVEL_ASSERT(1, __VA_ARGS__)
@@ -125,7 +126,7 @@
 #  define HPBC_CLOCKWORK_ASSERT2(...) HPBC_CLOCKWORK_LEVEL_ASSERT(2, __VA_ARGS__)
 #  define HPBC_CLOCKWORK_ASSERT3(...) HPBC_CLOCKWORK_LEVEL_ASSERT(3, __VA_ARGS__)
 
-#  define HPBC_CLOCKWORK_PRECONDITION1_MACRO_IS_ACTIVE (HURCHALLA_CLOCKWORK_ASSERT_LEVEL >= 1)
+#  define HPBC_CLOCKWORK_PRECONDITION_MACRO_IS_ACTIVE (HURCHALLA_CLOCKWORK_ASSERT_LEVEL >= 1)
 #  define HPBC_CLOCKWORK_PRECONDITION2_MACRO_IS_ACTIVE (HURCHALLA_CLOCKWORK_ASSERT_LEVEL >= 2)
 #  define HPBC_CLOCKWORK_PRECONDITION3_MACRO_IS_ACTIVE (HURCHALLA_CLOCKWORK_ASSERT_LEVEL >= 3)
 #  define HPBC_CLOCKWORK_POSTCONDITION_MACRO_IS_ACTIVE (HURCHALLA_CLOCKWORK_ASSERT_LEVEL >= 1)
@@ -142,7 +143,7 @@
 
 
 
-#if defined(__cplusplus)
+#if defined(HURCHALLA_CLOCKWORK_ENABLE_ASSERTS)
    // this section was adapted from the ideas in
    // https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
    // https://gist.github.com/oliora/928424f7675d58fadf49c70fdba70d2f
@@ -172,6 +173,13 @@
 #  define HPBC_CLOCKWORK_CONSTEXPR_PRECONDITION(...) HPBC_CLOCKWORK_CONSTEXPR_ASSERT(__VA_ARGS__)
 #  define HPBC_CLOCKWORK_CONSTEXPR_POSTCONDITION(...) HPBC_CLOCKWORK_CONSTEXPR_ASSERT(__VA_ARGS__)
 #  define HPBC_CLOCKWORK_CONSTEXPR_INVARIANT(...) HPBC_CLOCKWORK_CONSTEXPR_ASSERT(__VA_ARGS__)
+
+#else
+
+#  define HPBC_CLOCKWORK_CONSTEXPR_PRECONDITION(...) HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
+#  define HPBC_CLOCKWORK_CONSTEXPR_POSTCONDITION(...) HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
+#  define HPBC_CLOCKWORK_CONSTEXPR_INVARIANT(...) HPBC_CLOCKWORK_DO_NOTHING(__VA_ARGS__)
+
 #endif
 
 
diff --git a/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_addition.h b/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_addition.h
@@ -22,9 +22,9 @@ template <typename T>  HURCHALLA_FORCE_INLINE
 T modular_addition_prereduced_inputs(T a, T b, T modulus)
 {
     static_assert(ut_numeric_limits<T>::is_integer, "");
-    HPBC_CLOCKWORK_PRECONDITION(modulus > 0);
-    HPBC_CLOCKWORK_PRECONDITION(0<=a && a<modulus);   // i.e. the input must be prereduced
-    HPBC_CLOCKWORK_PRECONDITION(0<=b && b<modulus);   // i.e. the input must be prereduced
+    HPBC_CLOCKWORK_API_PRECONDITION(modulus > 0);
+    HPBC_CLOCKWORK_API_PRECONDITION(0<=a && a<modulus);   // i.e. the input must be prereduced
+    HPBC_CLOCKWORK_API_PRECONDITION(0<=b && b<modulus);   // i.e. the input must be prereduced
     
     T result = detail::impl_modular_addition<T>::call(a, b, modulus);
 
diff --git a/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_multiplication.h b/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_multiplication.h
@@ -29,9 +29,9 @@ T modular_multiplication_prereduced_inputs(T a, T b, T modulus)
 {
     static_assert(ut_numeric_limits<T>::is_integer, "");
     static_assert(!(ut_numeric_limits<T>::is_signed), "");
-    HPBC_CLOCKWORK_PRECONDITION(modulus>0);
-    HPBC_CLOCKWORK_PRECONDITION(a<modulus);   // i.e. the input must be prereduced
-    HPBC_CLOCKWORK_PRECONDITION(b<modulus);   // i.e. the input must be prereduced
+    HPBC_CLOCKWORK_API_PRECONDITION(modulus>0);
+    HPBC_CLOCKWORK_API_PRECONDITION(a<modulus);   // i.e. the input must be prereduced
+    HPBC_CLOCKWORK_API_PRECONDITION(b<modulus);   // i.e. the input must be prereduced
 
     T result = detail::impl_modular_multiplication<T>::call(a, b, modulus);
 
diff --git a/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_multiplicative_inverse.h b/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_multiplicative_inverse.h
@@ -30,7 +30,7 @@ T modular_multiplicative_inverse(T a, T modulus, T& gcd)
 {
     static_assert(ut_numeric_limits<T>::is_integer, "");
     static_assert(!(ut_numeric_limits<T>::is_signed), "");
-    HPBC_CLOCKWORK_PRECONDITION(modulus > 1);
+    HPBC_CLOCKWORK_API_PRECONDITION(modulus > 1);
 
     T inv = detail::impl_modular_multiplicative_inverse::call(a, modulus, gcd);
 
diff --git a/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_pow.h b/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_pow.h
@@ -28,7 +28,7 @@ T modular_pow(T base, U exponent, T modulus)
     static_assert(!(ut_numeric_limits<T>::is_signed), "");
     static_assert(ut_numeric_limits<U>::is_integer, "");
     static_assert(!(ut_numeric_limits<U>::is_signed), "");
-    HPBC_CLOCKWORK_PRECONDITION(modulus > 1);
+    HPBC_CLOCKWORK_API_PRECONDITION(modulus > 1);
 
     T result = detail::impl_modular_pow::call(base, exponent, modulus);
 
diff --git a/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_subtraction.h b/modular_arithmetic/include/hurchalla/modular_arithmetic/modular_subtraction.h
@@ -26,9 +26,9 @@ T modular_subtraction_prereduced_inputs(T a, T b, T modulus)
     static_assert(ut_numeric_limits<T>::is_integer, "");
     static_assert(std::is_same<PTAG,LowlatencyTag>::value ||
                   std::is_same<PTAG,LowuopsTag>::value, "");
-    HPBC_CLOCKWORK_PRECONDITION(modulus > 0);
-    HPBC_CLOCKWORK_PRECONDITION(0<=a && a<modulus);   // i.e. the input must be prereduced
-    HPBC_CLOCKWORK_PRECONDITION(0<=b && b<modulus);   // i.e. the input must be prereduced
+    HPBC_CLOCKWORK_API_PRECONDITION(modulus > 0);
+    HPBC_CLOCKWORK_API_PRECONDITION(0<=a && a<modulus);   // i.e. the input must be prereduced
+    HPBC_CLOCKWORK_API_PRECONDITION(0<=b && b<modulus);   // i.e. the input must be prereduced
 
     T result = detail::impl_modular_subtraction<T,PTAG>::call(a, b, modulus);
 
diff --git a/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/MontgomeryForm.h b/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/MontgomeryForm.h
@@ -84,8 +84,8 @@ class MontgomeryForm final {
         // type doesn't actually do Montgomery arithmetic.  However, to maintain
         // compatibility with the normal MontyTypes, it's recommended to always
         // use an odd modulus even in that case.]
-        //HPBC_CLOCKWORK_PRECONDITION(modulus % 2 == 1);
-        HPBC_CLOCKWORK_PRECONDITION(modulus > 1);
+        //HPBC_CLOCKWORK_API_PRECONDITION(modulus % 2 == 1);
+        HPBC_CLOCKWORK_API_PRECONDITION(modulus > 1);
     }
 
     // Returns the largest valid modulus allowed for the constructor.
@@ -113,7 +113,7 @@ class MontgomeryForm final {
     HURCHALLA_FORCE_INLINE
     MontgomeryValue convertIn(T a) const
     {
-        HPBC_CLOCKWORK_PRECONDITION(a >= 0);
+        HPBC_CLOCKWORK_API_PRECONDITION(a >= 0);
         return impl.convertIn(a);
     }
 
@@ -480,7 +480,7 @@ class MontgomeryForm final {
     HURCHALLA_FORCE_INLINE
     MontgomeryValue pow(MontgomeryValue base, T exponent) const
     {
-        HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);
+        HPBC_CLOCKWORK_API_PRECONDITION(exponent >= 0);
         std::array<MontgomeryValue, 1> bases = {{ base }};
         std::array<MontgomeryValue, 1> result =
                 detail::montgomery_array_pow<MontyTag,
@@ -495,7 +495,7 @@ class MontgomeryForm final {
     HURCHALLA_FORCE_INLINE
     MontgomeryValue two_pow(T exponent) const
     {
-        HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);
+        HPBC_CLOCKWORK_API_PRECONDITION(exponent >= 0);
         MontgomeryValue result =
                               detail::montgomery_two_pow::call(*this, exponent);
         HPBC_CLOCKWORK_POSTCONDITION(getCanonicalValue(result) ==
@@ -528,7 +528,7 @@ class MontgomeryForm final {
     std::array<MontgomeryValue, NUM_BASES>
     pow(const std::array<MontgomeryValue, NUM_BASES>& bases, T exponent) const
     {
-        HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);
+        HPBC_CLOCKWORK_API_PRECONDITION(exponent >= 0);
         return detail::montgomery_array_pow<MontyTag,
                                    MontgomeryForm>::pow(*this, bases, exponent);
     }
@@ -557,7 +557,7 @@ class MontgomeryForm final {
     // even if your CPU has extremely fast division (like many new CPUs).
     HURCHALLA_FORCE_INLINE T remainder(T a) const
     {
-        HPBC_CLOCKWORK_PRECONDITION(a >= 0);
+        HPBC_CLOCKWORK_API_PRECONDITION(a >= 0);
         return impl.remainder(a);
     }
 
diff --git a/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/ImplMontgomeryForm.contents b/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/ImplMontgomeryForm.contents
@@ -236,7 +236,7 @@ public:
     HURCHALLA_IMF_MAYBE_FORCE_INLINE
     T remainder(T a) const
     {
-        HPBC_CLOCKWORK_PRECONDITION1(a >= 0);
+        HPBC_CLOCKWORK_PRECONDITION(a >= 0);
         return static_cast<T>(impl.remainder(static_cast<U>(a)));
     }
 
diff --git a/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/MontgomeryFormExtensions.h b/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/MontgomeryFormExtensions.h
@@ -49,7 +49,7 @@ struct MontgomeryFormExtensions final {
     static MontgomeryValue
     convertInExtended_aTimesR(const MF& mf, RU a, RU magicValue)
     {
-        HPBC_CLOCKWORK_PRECONDITION1(magicValue == getMagicValue(mf));
+        HPBC_CLOCKWORK_PRECONDITION(magicValue == getMagicValue(mf));
         return mf.impl.template convertInExtended_aTimesR<PTAG>(a, magicValue);
     }
 
@@ -61,7 +61,7 @@ struct MontgomeryFormExtensions final {
     HURCHALLA_FORCE_INLINE
     static MontgomeryValue twoPowLimited(const MF& mf, size_t exponent)
     {
-        HPBC_CLOCKWORK_PRECONDITION1(exponent < ut_numeric_limits<RU>::digits);
+        HPBC_CLOCKWORK_PRECONDITION(exponent < ut_numeric_limits<RU>::digits);
         return mf.impl.template twoPowLimited<PTAG>(exponent);
     }
 
@@ -73,7 +73,7 @@ struct MontgomeryFormExtensions final {
     static MontgomeryValue
     RTimesTwoPowLimited(const MF& mf, size_t exponent, RU magicValue)
     {
-        HPBC_CLOCKWORK_PRECONDITION1(exponent < ut_numeric_limits<RU>::digits);
+        HPBC_CLOCKWORK_PRECONDITION(exponent < ut_numeric_limits<RU>::digits);
         return mf.impl.template RTimesTwoPowLimited<PTAG>(exponent, magicValue);
     }
 };
diff --git a/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/MontyCommonBase.h b/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/MontyCommonBase.h
@@ -58,7 +58,7 @@ class MontyCommonBase {
             <T, std::is_same<typename D::MontyTag,TagMontyQuarterrange>::value>
             (n_,inv_n_,r_mod_n_))
     {
-        HPBC_CLOCKWORK_PRECONDITION1(modulus % 2 == 1);
+        HPBC_CLOCKWORK_PRECONDITION(modulus % 2 == 1);
         HPBC_CLOCKWORK_PRECONDITION2(modulus > 1);
         // Note: unityValue == (the montgomery form of 1)==(1*R)%n_ == r_mod_n_.
         //
diff --git a/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/experimental/montgomery_pow_2kary.h b/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/experimental/montgomery_pow_2kary.h
@@ -57,7 +57,7 @@ struct impl_montgomery_pow_2kary {
         "above 9 is probably a very bad idea even if it works (9+ would cause "
         "the beginning of this function to calculate 1024+ table entries!)");
 
-    HPBC_CLOCKWORK_PRECONDITION1(nexp >= 0);
+    HPBC_CLOCKWORK_PRECONDITION(nexp >= 0);
 
     using V = typename MF::MontgomeryValue;
     using std::size_t;
diff --git a/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/platform_specific/montgomery_pow.h b/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/platform_specific/montgomery_pow.h
@@ -36,7 +36,7 @@ struct montgomery_pow {
 
   static HURCHALLA_FORCE_INLINE V scalarpow(const MF& mf, V base, T exponent)
   {
-    HPBC_CLOCKWORK_PRECONDITION1(exponent >= 0);
+    HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);
     // This is an optimized version of Algorithm 14.76, from
     // Applied Handbook of Cryptography- http://cacr.uwaterloo.ca/hac/
     // See also: hurchalla/modular_arithmetic/detail/impl_modular_pow.h
@@ -85,7 +85,7 @@ struct montgomery_pow {
   static HURCHALLA_FORCE_INLINE std::array<V, NUM_BASES>
   arraypow_cond_branch(const MF& mf, std::array<V, NUM_BASES> bases, T exponent)
   {
-    HPBC_CLOCKWORK_PRECONDITION1(exponent >= 0);
+    HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);
     std::array<V, NUM_BASES> result;
     if (exponent & static_cast<T>(1)) {
         for (std::size_t i=0; i<NUM_BASES; ++i)
@@ -112,7 +112,7 @@ struct montgomery_pow {
   arraypow_cond_branch_unrolled(const MF& mf, std::array<V, NUM_BASES> bases,
                                                                      T exponent)
   {
-    HPBC_CLOCKWORK_PRECONDITION1(exponent >= 0);
+    HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);
     std::array<V, NUM_BASES> result;
     if (exponent & static_cast<T>(1)) {
         Unroll<NUM_BASES>::call([&](std::size_t i) HURCHALLA_INLINE_LAMBDA {
@@ -142,7 +142,7 @@ struct montgomery_pow {
   static HURCHALLA_FORCE_INLINE std::array<V, NUM_BASES>
   arraypow_cmov(const MF& mf, std::array<V, NUM_BASES> bases, T exponent)
   {
-    HPBC_CLOCKWORK_PRECONDITION1(exponent >= 0);
+    HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);
     std::array<V, NUM_BASES> result;
     if (exponent & static_cast<T>(1)) {
         Unroll<NUM_BASES>::call([&](std::size_t i) HURCHALLA_INLINE_LAMBDA {
@@ -172,7 +172,7 @@ struct montgomery_pow {
   static HURCHALLA_FORCE_INLINE std::array<V, NUM_BASES>
   arraypow_masked(const MF& mf, std::array<V, NUM_BASES> bases, T exponent)
   {
-    HPBC_CLOCKWORK_PRECONDITION1(exponent >= 0);
+    HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);
     std::array<V, NUM_BASES> result;
     if (exponent & static_cast<T>(1)) {
         Unroll<NUM_BASES>::call([&](std::size_t i) HURCHALLA_INLINE_LAMBDA {
diff --git a/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/platform_specific/montgomery_two_pow.h b/montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/platform_specific/montgomery_two_pow.h
@@ -147,7 +147,7 @@ struct montgomery_two_pow {
   template <class MF, typename T>
   static typename MF::MontgomeryValue call(const MF& mf, T nt)
   {
-    HPBC_CLOCKWORK_PRECONDITION1(nt >= 0);
+    HPBC_CLOCKWORK_PRECONDITION(nt >= 0);
     using U = typename extensible_make_unsigned<T>::type;
     U n = static_cast<U>(nt);
 
@@ -214,7 +214,7 @@ struct montgomery_two_pow {
       using U = typename extensible_make_unsigned<T>::type;
       std::array<U, ARRAY_SIZE> n;
       HURCHALLA_REQUEST_UNROLL_LOOP for (int i=0; i<ARRAY_SIZE; ++i) {
-        HPBC_CLOCKWORK_PRECONDITION1(nt[i] >= 0);
+        HPBC_CLOCKWORK_PRECONDITION(nt[i] >= 0);
         n[i] = static_cast<U>(nt[i]);
       }
       return helper<MF, U, ARRAY_SIZE>(mf, n);
diff --git a/test/modular_arithmetic/test_modular_multiplicative_inverse.cpp b/test/modular_arithmetic/test_modular_multiplicative_inverse.cpp
@@ -44,8 +44,8 @@ namespace testmmi {
     T gcd(T a, T b)
     {
         static_assert(hc::ut_numeric_limits<T>::is_integer, "");
-        HPBC_CLOCKWORK_PRECONDITION1(a >= 0);
-        HPBC_CLOCKWORK_PRECONDITION1(b >= 0);
+        HPBC_CLOCKWORK_PRECONDITION(a >= 0);
+        HPBC_CLOCKWORK_PRECONDITION(b >= 0);
 
         while (a != 0) {
             T tmp = a;
diff --git a/test/montgomery_arithmetic/test_MontgomeryForm.h b/test/montgomery_arithmetic/test_MontgomeryForm.h
@@ -60,9 +60,9 @@ namespace testmf_adapters {
     T modadd(T a, T b, T modulus)
     {
         static_assert(hc::ut_numeric_limits<T>::is_integer, "");
-        HPBC_CLOCKWORK_PRECONDITION1(0 <= a && a < modulus);
-        HPBC_CLOCKWORK_PRECONDITION1(0 <= b && b < modulus);
-        HPBC_CLOCKWORK_PRECONDITION1(modulus > 1);
+        HPBC_CLOCKWORK_PRECONDITION(0 <= a && a < modulus);
+        HPBC_CLOCKWORK_PRECONDITION(0 <= b && b < modulus);
+        HPBC_CLOCKWORK_PRECONDITION(modulus > 1);
 
         using U = typename hc::extensible_make_unsigned<T>::type;
         T result = static_cast<T>(hc::modular_addition_prereduced_inputs(
@@ -76,9 +76,9 @@ namespace testmf_adapters {
     T modsub(T a, T b, T modulus)
     {
         static_assert(hc::ut_numeric_limits<T>::is_integer, "");
-        HPBC_CLOCKWORK_PRECONDITION1(0 <= a && a < modulus);
-        HPBC_CLOCKWORK_PRECONDITION1(0 <= b && b < modulus);
-        HPBC_CLOCKWORK_PRECONDITION1(modulus > 1);
+        HPBC_CLOCKWORK_PRECONDITION(0 <= a && a < modulus);
+        HPBC_CLOCKWORK_PRECONDITION(0 <= b && b < modulus);
+        HPBC_CLOCKWORK_PRECONDITION(modulus > 1);
 
         using U = typename hc::extensible_make_unsigned<T>::type;
         T result = static_cast<T>(hc::modular_subtraction_prereduced_inputs(
@@ -92,9 +92,9 @@ namespace testmf_adapters {
     T modmul(T a, T b, T modulus)
     {
         static_assert(hc::ut_numeric_limits<T>::is_integer, "");
-        HPBC_CLOCKWORK_PRECONDITION1(0 <= a && a < modulus);
-        HPBC_CLOCKWORK_PRECONDITION1(0 <= b && b < modulus);
-        HPBC_CLOCKWORK_PRECONDITION1(modulus > 1);
+        HPBC_CLOCKWORK_PRECONDITION(0 <= a && a < modulus);
+        HPBC_CLOCKWORK_PRECONDITION(0 <= b && b < modulus);
+        HPBC_CLOCKWORK_PRECONDITION(modulus > 1);
 
         using U = typename hc::extensible_make_unsigned<T>::type;
         T result = static_cast<T>(hc::modular_multiplication_prereduced_inputs(
@@ -108,9 +108,9 @@ namespace testmf_adapters {
     T modpow(T base, T exponent, T modulus)
     {
         static_assert(hc::ut_numeric_limits<T>::is_integer, "");
-        HPBC_CLOCKWORK_PRECONDITION1(base >= 0);
-        HPBC_CLOCKWORK_PRECONDITION1(exponent >= 0);
-        HPBC_CLOCKWORK_PRECONDITION1(modulus > 1);
+        HPBC_CLOCKWORK_PRECONDITION(base >= 0);
+        HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);
+        HPBC_CLOCKWORK_PRECONDITION(modulus > 1);
 
         using U = typename hc::extensible_make_unsigned<T>::type;
         T result = static_cast<T>(hc::modular_pow(static_cast<U>(base),
diff --git a/test/montgomery_arithmetic/test_montgomery_two_pow.cpp b/test/montgomery_arithmetic/test_montgomery_two_pow.cpp

Original file line number	Diff line number	Diff line change
`@@ -24,8 +24,8 @@ template <typename T> HURCHALLA_FORCE_INLINE`
`24`	`24`	`T absolute_value_difference(T a, T b)`
`25`	`25`	`{`
`26`	`26`	`static_assert(ut_numeric_limits<T>::is_integer, "");`
`27`		`- HPBC_CLOCKWORK_PRECONDITION(a >= 0);`
`28`		`- HPBC_CLOCKWORK_PRECONDITION(b >= 0);`
	`27`	`+ HPBC_CLOCKWORK_API_PRECONDITION(a >= 0);`
	`28`	`+ HPBC_CLOCKWORK_API_PRECONDITION(b >= 0);`
`29`	`29`
`30`	`30`	`T result = detail::impl_absolute_value_difference<T>::call(a, b);`
`31`	`31`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ T modular_multiplicative_inverse(T a, T modulus, T& gcd)`
`30`	`30`	`{`
`31`	`31`	`static_assert(ut_numeric_limits<T>::is_integer, "");`
`32`	`32`	`static_assert(!(ut_numeric_limits<T>::is_signed), "");`
`33`		`- HPBC_CLOCKWORK_PRECONDITION(modulus > 1);`
	`33`	`+ HPBC_CLOCKWORK_API_PRECONDITION(modulus > 1);`
`34`	`34`
`35`	`35`	`T inv = detail::impl_modular_multiplicative_inverse::call(a, modulus, gcd);`
`36`	`36`
Original file line number	Diff line number	Diff line change
`@@ -84,8 +84,8 @@ class MontgomeryForm final {`
`84`	`84`	`// type doesn't actually do Montgomery arithmetic. However, to maintain`
`85`	`85`	`// compatibility with the normal MontyTypes, it's recommended to always`
`86`	`86`	`// use an odd modulus even in that case.]`
`87`		`- //HPBC_CLOCKWORK_PRECONDITION(modulus % 2 == 1);`
`88`		`- HPBC_CLOCKWORK_PRECONDITION(modulus > 1);`
	`87`	`+ //HPBC_CLOCKWORK_API_PRECONDITION(modulus % 2 == 1);`
	`88`	`+ HPBC_CLOCKWORK_API_PRECONDITION(modulus > 1);`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`// Returns the largest valid modulus allowed for the constructor.`
`@@ -113,7 +113,7 @@ class MontgomeryForm final {`
`113`	`113`	`HURCHALLA_FORCE_INLINE`
`114`	`114`	`MontgomeryValue convertIn(T a) const`
`115`	`115`	`{`
`116`		`- HPBC_CLOCKWORK_PRECONDITION(a >= 0);`
	`116`	`+ HPBC_CLOCKWORK_API_PRECONDITION(a >= 0);`
`117`	`117`	`return impl.convertIn(a);`
`118`	`118`	`}`
`119`	`119`
`@@ -480,7 +480,7 @@ class MontgomeryForm final {`
`480`	`480`	`HURCHALLA_FORCE_INLINE`
`481`	`481`	`MontgomeryValue pow(MontgomeryValue base, T exponent) const`
`482`	`482`	`{`
`483`		`- HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);`
	`483`	`+ HPBC_CLOCKWORK_API_PRECONDITION(exponent >= 0);`
`484`	`484`	`std::array<MontgomeryValue, 1> bases = {{ base }};`
`485`	`485`	`std::array<MontgomeryValue, 1> result =`
`486`	`486`	`detail::montgomery_array_pow<MontyTag,`
`@@ -495,7 +495,7 @@ class MontgomeryForm final {`
`495`	`495`	`HURCHALLA_FORCE_INLINE`
`496`	`496`	`MontgomeryValue two_pow(T exponent) const`
`497`	`497`	`{`
`498`		`- HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);`
	`498`	`+ HPBC_CLOCKWORK_API_PRECONDITION(exponent >= 0);`
`499`	`499`	`MontgomeryValue result =`
`500`	`500`	`detail::montgomery_two_pow::call(*this, exponent);`
`501`	`501`	`HPBC_CLOCKWORK_POSTCONDITION(getCanonicalValue(result) ==`
`@@ -528,7 +528,7 @@ class MontgomeryForm final {`
`528`	`528`	`std::array<MontgomeryValue, NUM_BASES>`
`529`	`529`	`pow(const std::array<MontgomeryValue, NUM_BASES>& bases, T exponent) const`
`530`	`530`	`{`
`531`		`- HPBC_CLOCKWORK_PRECONDITION(exponent >= 0);`
	`531`	`+ HPBC_CLOCKWORK_API_PRECONDITION(exponent >= 0);`
`532`	`532`	`return detail::montgomery_array_pow<MontyTag,`
`533`	`533`	`MontgomeryForm>::pow(*this, bases, exponent);`
`534`	`534`	`}`
`@@ -557,7 +557,7 @@ class MontgomeryForm final {`
`557`	`557`	`// even if your CPU has extremely fast division (like many new CPUs).`
`558`	`558`	`HURCHALLA_FORCE_INLINE T remainder(T a) const`
`559`	`559`	`{`
`560`		`- HPBC_CLOCKWORK_PRECONDITION(a >= 0);`
	`560`	`+ HPBC_CLOCKWORK_API_PRECONDITION(a >= 0);`
`561`	`561`	`return impl.remainder(a);`
`562`	`562`	`}`
`563`	`563`
Original file line number	Diff line number	Diff line change
`@@ -236,7 +236,7 @@ public:`
`236`	`236`	`HURCHALLA_IMF_MAYBE_FORCE_INLINE`
`237`	`237`	`T remainder(T a) const`
`238`	`238`	`{`
`239`		`- HPBC_CLOCKWORK_PRECONDITION1(a >= 0);`
	`239`	`+ HPBC_CLOCKWORK_PRECONDITION(a >= 0);`
`240`	`240`	`return static_cast<T>(impl.remainder(static_cast<U>(a)));`
`241`	`241`	`}`
`242`	`242`
Original file line number	Diff line number	Diff line change
`@@ -49,7 +49,7 @@ struct MontgomeryFormExtensions final {`
`49`	`49`	`static MontgomeryValue`
`50`	`50`	`convertInExtended_aTimesR(const MF& mf, RU a, RU magicValue)`
`51`	`51`	`{`
`52`		`- HPBC_CLOCKWORK_PRECONDITION1(magicValue == getMagicValue(mf));`
	`52`	`+ HPBC_CLOCKWORK_PRECONDITION(magicValue == getMagicValue(mf));`
`53`	`53`	`return mf.impl.template convertInExtended_aTimesR<PTAG>(a, magicValue);`
`54`	`54`	`}`
`55`	`55`
`@@ -61,7 +61,7 @@ struct MontgomeryFormExtensions final {`
`61`	`61`	`HURCHALLA_FORCE_INLINE`
`62`	`62`	`static MontgomeryValue twoPowLimited(const MF& mf, size_t exponent)`
`63`	`63`	`{`
`64`		`- HPBC_CLOCKWORK_PRECONDITION1(exponent < ut_numeric_limits<RU>::digits);`
	`64`	`+ HPBC_CLOCKWORK_PRECONDITION(exponent < ut_numeric_limits<RU>::digits);`
`65`	`65`	`return mf.impl.template twoPowLimited<PTAG>(exponent);`
`66`	`66`	`}`
`67`	`67`
`@@ -73,7 +73,7 @@ struct MontgomeryFormExtensions final {`
`73`	`73`	`static MontgomeryValue`
`74`	`74`	`RTimesTwoPowLimited(const MF& mf, size_t exponent, RU magicValue)`
`75`	`75`	`{`
`76`		`- HPBC_CLOCKWORK_PRECONDITION1(exponent < ut_numeric_limits<RU>::digits);`
	`76`	`+ HPBC_CLOCKWORK_PRECONDITION(exponent < ut_numeric_limits<RU>::digits);`
`77`	`77`	`return mf.impl.template RTimesTwoPowLimited<PTAG>(exponent, magicValue);`
`78`	`78`	`}`
`79`	`79`	`};`