replace remaining ternary operations with conditional_select calls

Author: hurchalla

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/MontyFullRange.h

@@ -18,6 +18,7 @@
 #include "hurchalla/modular_arithmetic/absolute_value_difference.h"
 #include "hurchalla/util/traits/ut_numeric_limits.h"
 #include "hurchalla/util/unsigned_multiply_to_hilo_product.h"
+#include "hurchalla/util/conditional_select.h"
 #include "hurchalla/util/compiler_macros.h"
 #include "hurchalla/modular_arithmetic/detail/clockwork_programming_by_contract.h"
 #include <type_traits>
@@ -233,7 +234,8 @@ class MontyFullRange final :
         T minu, subt;
         hc::REDC_incomplete(minu, subt, u_hi, u_lo, n_, BC::inv_n_, PTAG());
         T res = static_cast<T>(minu - subt);
-        T subtrahend = (minu < subt) ? res : static_cast<T>(0);
+          // T subtrahend = (minu < subt) ? res : static_cast<T>(0);
+        T subtrahend = hc::conditional_select((minu < subt), res, static_cast<T>(0));
         SV result(res, subtrahend);
         return result;
     }
@@ -261,7 +263,9 @@ class MontyFullRange final :
     // via squareToMontgomeryValue
     HURCHALLA_FORCE_INLINE V getMontgomeryValue(SV sv) const
     {
-        T nonneg_value = sv.get_subtrahend() != 0 ? sv.get() + n_ : sv.get();
+         //T nonneg_value = sv.get_subtrahend() != 0 ? sv.get() + n_ : sv.get();
+        T nonneg_value = ::hurchalla::conditional_select(
+                           (sv.get_subtrahend() != 0), sv.get() + n_, sv.get());
         return V(nonneg_value);
     }
 

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/experimental/montgomery_pow_2kary/experimental_montgomery_pow_2kary.h

@@ -1059,12 +1059,14 @@ if HURCHALLA_CPP17_CONSTEXPR (CODE_SECTION == 0) {
         index = static_cast<size_t>(branchless_shift_right(n, shift)) & MASK;
 
         HURCHALLA_REQUEST_UNROLL_LOOP for (size_t j=0; j<ARRAY_SIZE; ++j) {
-            V tmp = (index % 2 == 0) ? table[index/2][j] : result[j];
+            V tmp = result[j];
+            tmp.cmov((index % 2 == 0), table[index/2][j]);
             result[j] = mf.template multiply<LowuopsTag>(tmp, result[j]);
         }
 
         HURCHALLA_REQUEST_UNROLL_LOOP for (size_t j=0; j<ARRAY_SIZE; ++j) {
-            V tmp = (index % 2 == 0) ? result[j] : table[index][j];
+            V tmp = table[index][j];
+            tmp.cmov((index % 2 == 0), result[j]);
             result[j] = mf.template multiply<LowuopsTag>(tmp, result[j]);
         }
     }

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/experimental/montgomery_two_pow/experimental_montgomery_two_pow.h

@@ -2465,8 +2465,7 @@ if HURCHALLA_CPP17_CONSTEXPR (CODE_SECTION == 0) {
 
     U n_max = n[0];
     HURCHALLA_REQUEST_UNROLL_LOOP for (size_t j=1; j<ARRAY_SIZE; ++j) {
-        if (n_max < n[j])
-            n_max = n[j];
+        n_max = (n_max < n[j]) ? n[j] : n_max;
     }
 
 

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/detail/platform_specific/montgomery_pow.h

@@ -41,7 +41,8 @@ struct montgomery_pow {
     // Applied Handbook of Cryptography- http://cacr.uwaterloo.ca/hac/
     // See also: hurchalla/modular_arithmetic/detail/impl_modular_pow.h
     V mont_one = mf.getUnityValue();
-    V result = (exponent & static_cast<T>(1)) ? base : mont_one;
+    V result = mont_one;
+    result.cmov((exponent & static_cast<T>(1)), base);
     while (exponent > static_cast<T>(1)) {
         exponent = static_cast<T>(exponent >> static_cast<T>(1));
         base = mf.template square<LowlatencyTag>(base);

montgomery_arithmetic/include/hurchalla/montgomery_arithmetic/low_level_api/detail/platform_specific/ImplRedc.h

@@ -289,7 +289,8 @@ struct RedcIncomplete {
     T v_mid = u_mid - mn_mid;
     TH u_hi_hi = static_cast<TH>(u_hi >> HALF_BITS);
     TH v_hi_hi = u_hi_hi - (u_mid < mn_mid);
-    T moz = (u_hi_hi < (u_mid < mn_mid)) ? n : 0;
+        // T moz = (u_hi_hi < (u_mid < mn_mid)) ? n : 0;
+    T moz = ::hurchalla::conditional_select((u_hi_hi < (u_mid < mn_mid)), n, 0);
 
     T v_hi = (static_cast<T>(v_hi_hi) << HALF_BITS) | (v_mid >> HALF_BITS);
     v_hi = v_hi + moz;
@@ -807,7 +808,8 @@ struct RedcStandard
     // By RedcIncomplete::call()'s Postcondition #1, we would have:
     T difference = static_cast<T>(minuend - subtrahend);
     bool ovf = (minuend < subtrahend);
-    T result = (ovf) ? static_cast<T>(difference + n) : difference;
+        // T result = (ovf) ? static_cast<T>(difference + n) : difference;
+    T result = hc::conditional_select((ovf), static_cast<T>(difference + n), difference);
 #else
     // The #if section above is just a modular subtraction...
     // The most efficient way to compute it is to call our dedicated function: