tweaks to avoiding exceptions in get_evaluation_domain logic

Author: dtebbs

libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc

@@ -25,20 +25,13 @@ namespace libfqfft {
 template<typename FieldT>
 bool basic_radix2_domain<FieldT>::valid_for_size(const size_t m)
 {
-    if ( m <= 1 )
+    if (m <= 1) {
         return false;
-
-    // Will `get_root_of_unity` throw?
-    if (!std::is_same<FieldT, libff::Double>::value)
-    {
-        const size_t logm = libff::log2(m);
-
-        if (logm > FieldT::s)
-            return false;
     }
 
-    if (get_root_of_unity_will_throw<FieldT>(m))
+    if (!libff::has_root_of_unity<FieldT>(m)) {
         return false;
+    }
 
     return true;
 }

libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc

@@ -34,8 +34,9 @@ bool extended_radix2_domain<FieldT>::valid_for_size(const size_t m)
 
     size_t small_m = m / 2;
 
-    if (get_root_of_unity_will_throw<FieldT>(small_m))
+    if (!libff::has_root_of_unity<FieldT>(small_m)) {
         return false;
+    }
 
     return true;
 }

libfqfft/evaluation_domain/domains/step_radix2_domain.tcc

@@ -20,22 +20,26 @@ namespace libfqfft {
 template<typename FieldT>
 bool step_radix2_domain<FieldT>::valid_for_size(const size_t m)
 {
-    if (m <= 1)
+    if (m <= 1) {
         return false;
+    }
 
     const size_t big_m = 1ul<<(libff::log2(m)-1);
     const size_t small_m = m - big_m;
 
-    if (small_m != 1ul<<libff::log2(small_m))
+    if (small_m != 1ul<<libff::log2(small_m)) {
         return false;
+    }
 
     // omega
-    if (get_root_of_unity_will_throw<FieldT>(1ul<<libff::log2(m)))
+    if (!libff::has_root_of_unity<FieldT>(1ul<<libff::log2(m))) {
         return false;
+    }
 
     // small_omega
-    if (get_root_of_unity_will_throw<FieldT>(1ul<<libff::log2(small_m)))
+    if (!libff::has_root_of_unity<FieldT>(1ul<<libff::log2(small_m))) {
         return false;
+    }
 
     return true;
 }

libfqfft/evaluation_domain/evaluation_domain.hpp

@@ -31,30 +31,6 @@
 
 namespace libfqfft {
 
-template<typename FieldT>
-typename std::enable_if<std::is_same<FieldT, libff::Double>::value, bool>::type
-get_root_of_unity_will_throw(const size_t /*n*/)
-{
-    return false;
-}
-
-
-template<typename FieldT>
-typename std::enable_if<!std::is_same<FieldT, libff::Double>::value, bool>::type
-get_root_of_unity_will_throw(const size_t n)
-{
-    const size_t logn = libff::log2(n);
-
-    if (n != (1u << logn))
-        return true;
-
-    if (logn > FieldT::s)
-        return true;
-
-    return false;
-}
-
-
 /**
  * An evaluation domain.
  */

libfqfft/evaluation_domain/get_evaluation_domain.tcc

@@ -39,7 +39,7 @@ std::shared_ptr<evaluation_domain<FieldT> > get_evaluation_domain(const size_t m
     const size_t rounded_small = (1ul<<libff::log2(small));
 
     if ( basic_radix2_domain<FieldT>::valid_for_size(min_size) ) {
-        result.reset(new basic_radix2_domain<FieldT>(min_size));        
+        result.reset(new basic_radix2_domain<FieldT>(min_size));
     }
     else if ( extended_radix2_domain<FieldT>::valid_for_size(min_size) ) {
         result.reset(new extended_radix2_domain<FieldT>(min_size));
@@ -51,7 +51,7 @@ std::shared_ptr<evaluation_domain<FieldT> > get_evaluation_domain(const size_t m
         result.reset(new basic_radix2_domain<FieldT>(big + rounded_small));
     }
     else if ( extended_radix2_domain<FieldT>::valid_for_size(big + rounded_small) ) {
-        result.reset(new extended_radix2_domain<FieldT>(big + rounded_small));        
+        result.reset(new extended_radix2_domain<FieldT>(big + rounded_small));
     }
     else if ( step_radix2_domain<FieldT>::valid_for_size(big + rounded_small) ) {
         result.reset(new step_radix2_domain<FieldT>(big + rounded_small));