From c3a813af4b1a4b52f35cbfad10e6813330d3797a Mon Sep 17 00:00:00 2001
From: HarryR <HarryR@noreply.users.github.com>
Date: Sun, 21 Jul 2019 18:46:08 +0100
Subject: [PATCH 1/6] Do not use try/catch for control flow in
 get_evaluation_domain

---
 .../domains/arithmetic_sequence_domain.hpp    |  2 ++
 .../domains/arithmetic_sequence_domain.tcc    | 12 ++++++++
 .../domains/basic_radix2_domain.hpp           |  2 ++
 .../domains/basic_radix2_domain.tcc           | 21 +++++++++++++
 .../domains/extended_radix2_domain.hpp        |  2 ++
 .../domains/extended_radix2_domain.tcc        | 26 ++++++++++++++++
 .../domains/geometric_sequence_domain.hpp     |  2 ++
 .../domains/geometric_sequence_domain.tcc     | 12 ++++++++
 .../domains/step_radix2_domain.hpp            |  2 ++
 .../domains/step_radix2_domain.tcc            | 27 +++++++++++++++++
 .../get_evaluation_domain.tcc                 | 30 +++++++++++++++++++
 11 files changed, 138 insertions(+)

diff --git a/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.hpp b/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.hpp
index e3f42ba..26304c2 100755
--- a/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.hpp
+++ b/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.hpp
@@ -28,6 +28,8 @@ namespace libfqfft {
     FieldT arithmetic_generator;
     void do_precomputation();
 
+    static bool valid_for_size(const size_t m);
+
     arithmetic_sequence_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);
diff --git a/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc b/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc
index 3b59ae2..8ae9431 100755
--- a/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc
@@ -23,6 +23,18 @@
 
 namespace libfqfft {
 
+template<typename FieldT>
+bool arithmetic_sequence_domain<FieldT>::valid_for_size(const size_t m)
+{
+  if (m <=1)
+      return false;
+
+  if (FieldT::arithmetic_generator() == FieldT::zero())
+      return false;
+
+  return true;
+}
+
 template<typename FieldT>
 arithmetic_sequence_domain<FieldT>::arithmetic_sequence_domain(const size_t m) : evaluation_domain<FieldT>(m)
 {
diff --git a/libfqfft/evaluation_domain/domains/basic_radix2_domain.hpp b/libfqfft/evaluation_domain/domains/basic_radix2_domain.hpp
index 7b77b29..2ce3dc1 100755
--- a/libfqfft/evaluation_domain/domains/basic_radix2_domain.hpp
+++ b/libfqfft/evaluation_domain/domains/basic_radix2_domain.hpp
@@ -26,6 +26,8 @@ class basic_radix2_domain : public evaluation_domain<FieldT> {
 
     FieldT omega;
 
+    static bool valid_for_size(const size_t m);
+
     basic_radix2_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);
diff --git a/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
index 2486f7a..e0a48ff 100755
--- a/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
@@ -22,6 +22,27 @@
 
 namespace libfqfft {
 
+template<typename FieldT>
+bool basic_radix2_domain<FieldT>::valid_for_size(const size_t m)
+{
+    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 (m != 1u << logm)
+            return false;
+    }
+
+    return true;
+}
+
 template<typename FieldT>
 basic_radix2_domain<FieldT>::basic_radix2_domain(const size_t m) : evaluation_domain<FieldT>(m)
 {
diff --git a/libfqfft/evaluation_domain/domains/extended_radix2_domain.hpp b/libfqfft/evaluation_domain/domains/extended_radix2_domain.hpp
index 7637925..53e9c11 100755
--- a/libfqfft/evaluation_domain/domains/extended_radix2_domain.hpp
+++ b/libfqfft/evaluation_domain/domains/extended_radix2_domain.hpp
@@ -27,6 +27,8 @@ class extended_radix2_domain : public evaluation_domain<FieldT> {
     FieldT omega;
     FieldT shift;
 
+    static bool valid_for_size(const size_t m);
+
     extended_radix2_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);
diff --git a/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
index b6a31fa..25dcc19 100755
--- a/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
@@ -17,6 +17,32 @@
 
 namespace libfqfft {
 
+template<typename FieldT>
+bool extended_radix2_domain<FieldT>::valid_for_size(const size_t m)
+{
+    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 + 1))
+            return false;
+
+        size_t small_m = m / 2;
+
+        if (small_m > FieldT::s)
+            return false;
+
+        if (m != (1u << small_m))
+            return false;
+    }
+
+    return true;
+}
+
 template<typename FieldT>
 extended_radix2_domain<FieldT>::extended_radix2_domain(const size_t m) : evaluation_domain<FieldT>(m)
 {
diff --git a/libfqfft/evaluation_domain/domains/geometric_sequence_domain.hpp b/libfqfft/evaluation_domain/domains/geometric_sequence_domain.hpp
index 22bd783..70a2da2 100755
--- a/libfqfft/evaluation_domain/domains/geometric_sequence_domain.hpp
+++ b/libfqfft/evaluation_domain/domains/geometric_sequence_domain.hpp
@@ -27,6 +27,8 @@ namespace libfqfft {
     std::vector<FieldT> geometric_triangular_sequence;
     void do_precomputation();
 
+    static bool valid_for_size(const size_t m);
+
     geometric_sequence_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);
diff --git a/libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc b/libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc
index 1535810..fe5bdaa 100755
--- a/libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc
@@ -23,6 +23,18 @@
 
 namespace libfqfft {
 
+template<typename FieldT>
+bool geometric_sequence_domain<FieldT>::valid_for_size(const size_t m)
+{
+    if ( m <= 1 )
+        return false;
+
+    if (FieldT::geometric_generator() == FieldT::zero())
+        return false;
+
+    return true;
+}
+
 template<typename FieldT>
 geometric_sequence_domain<FieldT>::geometric_sequence_domain(const size_t m) : evaluation_domain<FieldT>(m)
 {
diff --git a/libfqfft/evaluation_domain/domains/step_radix2_domain.hpp b/libfqfft/evaluation_domain/domains/step_radix2_domain.hpp
index 33ba7f4..72fc090 100755
--- a/libfqfft/evaluation_domain/domains/step_radix2_domain.hpp
+++ b/libfqfft/evaluation_domain/domains/step_radix2_domain.hpp
@@ -29,6 +29,8 @@ class step_radix2_domain : public evaluation_domain<FieldT> {
     FieldT big_omega;
     FieldT small_omega;
 
+    static bool valid_for_size(const size_t m);
+
     step_radix2_domain(const size_t m);
 
     void FFT(std::vector<FieldT> &a);
diff --git a/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
index e9a984e..ece95e1 100755
--- a/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
@@ -17,6 +17,33 @@
 
 namespace libfqfft {
 
+template<typename FieldT>
+bool step_radix2_domain<FieldT>::valid_for_size(const size_t m)
+{
+    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))
+        return false;
+
+    // Will `get_root_of_unity` throw?
+    if (!std::is_same<FieldT, libff::Double>::value)
+    {
+        const size_t logm = libff::log2(m);
+
+        if (m != (1u << logm))
+            return false;
+
+        if (logm > FieldT::s)
+            return false;
+    }
+
+    return true;
+}
+
 template<typename FieldT>
 step_radix2_domain<FieldT>::step_radix2_domain(const size_t m) : evaluation_domain<FieldT>(m)
 {
diff --git a/libfqfft/evaluation_domain/get_evaluation_domain.tcc b/libfqfft/evaluation_domain/get_evaluation_domain.tcc
index 299537c..d60be30 100755
--- a/libfqfft/evaluation_domain/get_evaluation_domain.tcc
+++ b/libfqfft/evaluation_domain/get_evaluation_domain.tcc
@@ -38,6 +38,35 @@ std::shared_ptr<evaluation_domain<FieldT> > get_evaluation_domain(const size_t m
     const size_t small = min_size - big;
     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));        
+    }
+    else if ( extended_radix2_domain<FieldT>::valid_for_size(min_size) ) {
+        result.reset(new extended_radix2_domain<FieldT>(min_size));
+    }
+    else if ( step_radix2_domain<FieldT>::valid_for_size(min_size) ) {
+        result.reset(new step_radix2_domain<FieldT>(min_size));
+    }
+    else if ( basic_radix2_domain<FieldT>::valid_for_size(big + rounded_small) ) {
+        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));        
+    }
+    else if ( step_radix2_domain<FieldT>::valid_for_size(big + rounded_small) ) {
+        result.reset(new step_radix2_domain<FieldT>(big + rounded_small));
+    }
+    else if ( geometric_sequence_domain<FieldT>::valid_for_size(min_size) ) {
+        result.reset(new geometric_sequence_domain<FieldT>(min_size));
+    }
+    else if ( arithmetic_sequence_domain<FieldT>::valid_for_size(min_size) ) {
+        result.reset(new arithmetic_sequence_domain<FieldT>(min_size));
+    }
+    else {
+        throw DomainSizeException("get_evaluation_domain: no matching domain");
+    }
+
+    /*
     try { result.reset(new basic_radix2_domain<FieldT>(min_size)); }
     catch(...) { try { result.reset(new extended_radix2_domain<FieldT>(min_size)); }
     catch(...) { try { result.reset(new step_radix2_domain<FieldT>(min_size)); }
@@ -47,6 +76,7 @@ std::shared_ptr<evaluation_domain<FieldT> > get_evaluation_domain(const size_t m
     catch(...) { try { result.reset(new geometric_sequence_domain<FieldT>(min_size)); }
     catch(...) { try { result.reset(new arithmetic_sequence_domain<FieldT>(min_size)); }
     catch(...) { throw DomainSizeException("get_evaluation_domain: no matching domain"); }}}}}}}}
+    */
 
     return result;
 }

From 43a03a4e35362fb475b87a4013a54d6421bd6f3c Mon Sep 17 00:00:00 2001
From: HarryR <HarryR@noreply.users.github.com>
Date: Fri, 2 Aug 2019 23:22:33 +0100
Subject: [PATCH 2/6] Removed unnecessary comments

---
 libfqfft/evaluation_domain/get_evaluation_domain.tcc | 12 ------------
 1 file changed, 12 deletions(-)

diff --git a/libfqfft/evaluation_domain/get_evaluation_domain.tcc b/libfqfft/evaluation_domain/get_evaluation_domain.tcc
index d60be30..282b2f3 100755
--- a/libfqfft/evaluation_domain/get_evaluation_domain.tcc
+++ b/libfqfft/evaluation_domain/get_evaluation_domain.tcc
@@ -66,18 +66,6 @@ std::shared_ptr<evaluation_domain<FieldT> > get_evaluation_domain(const size_t m
         throw DomainSizeException("get_evaluation_domain: no matching domain");
     }
 
-    /*
-    try { result.reset(new basic_radix2_domain<FieldT>(min_size)); }
-    catch(...) { try { result.reset(new extended_radix2_domain<FieldT>(min_size)); }
-    catch(...) { try { result.reset(new step_radix2_domain<FieldT>(min_size)); }
-    catch(...) { try { result.reset(new basic_radix2_domain<FieldT>(big + rounded_small)); }
-    catch(...) { try { result.reset(new extended_radix2_domain<FieldT>(big + rounded_small)); }
-    catch(...) { try { result.reset(new step_radix2_domain<FieldT>(big + rounded_small)); }
-    catch(...) { try { result.reset(new geometric_sequence_domain<FieldT>(min_size)); }
-    catch(...) { try { result.reset(new arithmetic_sequence_domain<FieldT>(min_size)); }
-    catch(...) { throw DomainSizeException("get_evaluation_domain: no matching domain"); }}}}}}}}
-    */
-
     return result;
 }
 

From 6f2c0819850fc9b909b798942092918319bdd089 Mon Sep 17 00:00:00 2001
From: HarryR <HarryR@noreply.users.github.com>
Date: Sun, 21 Jul 2019 21:44:13 +0100
Subject: [PATCH 3/6] Fixed tests to get evaluation domain

---
 .../domains/basic_radix2_domain.tcc           |  6 ++---
 .../domains/extended_radix2_domain.tcc        | 11 +++-----
 .../domains/step_radix2_domain.tcc            | 16 +++++-------
 .../evaluation_domain/evaluation_domain.hpp   | 25 +++++++++++++++++++
 4 files changed, 38 insertions(+), 20 deletions(-)

diff --git a/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
index e0a48ff..7365ca6 100755
--- a/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
@@ -35,11 +35,11 @@ bool basic_radix2_domain<FieldT>::valid_for_size(const size_t m)
 
         if (logm > FieldT::s)
             return false;
-
-        if (m != 1u << logm)
-            return false;
     }
 
+    if( get_root_of_unity_will_throw<FieldT>(m) )
+        return false;
+
     return true;
 }
 
diff --git a/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
index 25dcc19..50dfea0 100755
--- a/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
@@ -30,15 +30,12 @@ bool extended_radix2_domain<FieldT>::valid_for_size(const size_t m)
 
         if (logm != (FieldT::s + 1))
             return false;
+    }
 
-        size_t small_m = m / 2;
-
-        if (small_m > FieldT::s)
-            return false;
+    size_t small_m = m / 2;
 
-        if (m != (1u << small_m))
-            return false;
-    }
+    if( get_root_of_unity_will_throw<FieldT>(small_m) )
+        return false;
 
     return true;
 }
diff --git a/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
index ece95e1..733975e 100755
--- a/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
@@ -29,17 +29,13 @@ bool step_radix2_domain<FieldT>::valid_for_size(const size_t m)
     if (small_m != 1ul<<libff::log2(small_m))
         return false;
 
-    // Will `get_root_of_unity` throw?
-    if (!std::is_same<FieldT, libff::Double>::value)
-    {
-        const size_t logm = libff::log2(m);
-
-        if (m != (1u << logm))
-            return false;
+    // omega
+    if( get_root_of_unity_will_throw<FieldT>(1ul<<libff::log2(m)) )
+        return false;
 
-        if (logm > FieldT::s)
-            return false;
-    }
+    // small_omega
+    if( get_root_of_unity_will_throw<FieldT>(1ul<<libff::log2(small_m)) )
+        return false;
 
     return true;
 }
diff --git a/libfqfft/evaluation_domain/evaluation_domain.hpp b/libfqfft/evaluation_domain/evaluation_domain.hpp
index 43c7498..55bf948 100755
--- a/libfqfft/evaluation_domain/evaluation_domain.hpp
+++ b/libfqfft/evaluation_domain/evaluation_domain.hpp
@@ -27,9 +27,34 @@
 #define EVALUATION_DOMAIN_HPP_
 
 #include <vector>
+#include <libff/common/double.hpp>
 
 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.
  */

From 5d1b6a6601f42997f01d5e0ccbaeab57bb6be8aa Mon Sep 17 00:00:00 2001
From: Duncan Tebbs <duncan.tebbs@gmail.com>
Date: Mon, 4 Oct 2021 11:09:32 +0100
Subject: [PATCH 4/6] Fix some compile warnings

---
 libfqfft/evaluation_domain/evaluation_domain.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/libfqfft/evaluation_domain/evaluation_domain.hpp b/libfqfft/evaluation_domain/evaluation_domain.hpp
index 55bf948..2c0c1e2 100755
--- a/libfqfft/evaluation_domain/evaluation_domain.hpp
+++ b/libfqfft/evaluation_domain/evaluation_domain.hpp
@@ -33,7 +33,7 @@ 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)
+get_root_of_unity_will_throw(const size_t /*n*/)
 {
     return false;
 }

From ab8a53e2f2da9abc7ca83e48548e560819872c3c Mon Sep 17 00:00:00 2001
From: Duncan Tebbs <duncan.tebbs@gmail.com>
Date: Mon, 4 Oct 2021 11:16:18 +0100
Subject: [PATCH 5/6] Style consistency

---
 .../domains/arithmetic_sequence_domain.tcc    | 16 ++++++++-------
 .../domains/basic_radix2_domain.tcc           |  2 +-
 .../domains/extended_radix2_domain.tcc        |  8 +++++---
 .../domains/geometric_sequence_domain.tcc     | 18 +++++++++--------
 .../domains/step_radix2_domain.tcc            |  8 ++++----
 .../get_evaluation_domain.tcc                 | 20 +++++++++----------
 6 files changed, 39 insertions(+), 33 deletions(-)

diff --git a/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc b/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc
index 8ae9431..74ce02c 100755
--- a/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/arithmetic_sequence_domain.tcc
@@ -26,11 +26,13 @@ namespace libfqfft {
 template<typename FieldT>
 bool arithmetic_sequence_domain<FieldT>::valid_for_size(const size_t m)
 {
-  if (m <=1)
-      return false;
+  if (m <= 1) {
+    return false;
+  }
 
-  if (FieldT::arithmetic_generator() == FieldT::zero())
-      return false;
+  if (FieldT::arithmetic_generator() == FieldT::zero()) {
+    return false;
+  }
 
   return true;
 }
@@ -54,7 +56,7 @@ void arithmetic_sequence_domain<FieldT>::FFT(std::vector<FieldT> &a)
 
   /* Monomial to Newton */
   monomial_to_newton_basis(a, this->subproduct_tree, this->m);
-  
+
   /* Newton to Evaluation */
   std::vector<FieldT> S(this->m); /* i! * arithmetic_generator */
   S[0] = FieldT::one();
@@ -82,7 +84,7 @@ template<typename FieldT>
 void arithmetic_sequence_domain<FieldT>::iFFT(std::vector<FieldT> &a)
 {
   if (a.size() != this->m) throw DomainSizeException("arithmetic: expected a.size() == this->m");
-  
+
   if (!this->precomputation_sentinel) do_precomputation();
 
   /* Interpolation to Newton */
@@ -164,7 +166,7 @@ std::vector<FieldT> arithmetic_sequence_domain<FieldT>::evaluate_all_lagrange_po
 
   std::vector<FieldT> w(this->m);
   w[0] = g_vanish.inverse() * (this->arithmetic_generator^(this->m-1));
-  
+
   l[0] = l_vanish * l[0].inverse() * w[0];
   for (size_t i = 1; i < this->m; i++)
   {
diff --git a/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
index 7365ca6..19cb659 100755
--- a/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
@@ -37,7 +37,7 @@ bool basic_radix2_domain<FieldT>::valid_for_size(const size_t m)
             return false;
     }
 
-    if( get_root_of_unity_will_throw<FieldT>(m) )
+    if (get_root_of_unity_will_throw<FieldT>(m))
         return false;
 
     return true;
diff --git a/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
index 50dfea0..b304f2f 100755
--- a/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
@@ -20,21 +20,23 @@ namespace libfqfft {
 template<typename FieldT>
 bool extended_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 + 1))
+        if (logm != (FieldT::s + 1)) {
             return false;
+        }
     }
 
     size_t small_m = m / 2;
 
-    if( get_root_of_unity_will_throw<FieldT>(small_m) )
+    if (get_root_of_unity_will_throw<FieldT>(small_m))
         return false;
 
     return true;
diff --git a/libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc b/libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc
index fe5bdaa..530f23f 100755
--- a/libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/geometric_sequence_domain.tcc
@@ -26,13 +26,15 @@ namespace libfqfft {
 template<typename FieldT>
 bool geometric_sequence_domain<FieldT>::valid_for_size(const size_t m)
 {
-    if ( m <= 1 )
-        return false;
+  if (m <= 1) {
+      return false;
+  }
 
-    if (FieldT::geometric_generator() == FieldT::zero())
-        return false;
+  if (FieldT::geometric_generator() == FieldT::zero()) {
+      return false;
+  }
 
-    return true;
+  return true;
 }
 
 template<typename FieldT>
@@ -41,13 +43,13 @@ geometric_sequence_domain<FieldT>::geometric_sequence_domain(const size_t m) : e
   if (m <= 1) throw InvalidSizeException("geometric(): expected m > 1");
   if (FieldT::geometric_generator() == FieldT::zero())
     throw InvalidSizeException("geometric(): expected FieldT::geometric_generator() != FieldT::zero()");
-  
+
   precomputation_sentinel = 0;
 }
 
 template<typename FieldT>
 void geometric_sequence_domain<FieldT>::FFT(std::vector<FieldT> &a)
-{ 
+{
   if (a.size() != this->m) throw DomainSizeException("geometric: expected a.size() == this->m");
 
   if (!this->precomputation_sentinel) do_precomputation();
@@ -83,7 +85,7 @@ template<typename FieldT>
 void geometric_sequence_domain<FieldT>::iFFT(std::vector<FieldT> &a)
 {
   if (a.size() != this->m) throw DomainSizeException("geometric: expected a.size() == this->m");
-  
+
   if (!this->precomputation_sentinel) do_precomputation();
 
   /* Interpolation to Newton */
diff --git a/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
index 733975e..28b260d 100755
--- a/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
@@ -20,7 +20,7 @@ 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);
@@ -30,11 +30,11 @@ bool step_radix2_domain<FieldT>::valid_for_size(const size_t m)
         return false;
 
     // omega
-    if( get_root_of_unity_will_throw<FieldT>(1ul<<libff::log2(m)) )
+    if (get_root_of_unity_will_throw<FieldT>(1ul<<libff::log2(m)))
         return false;
 
     // small_omega
-    if( get_root_of_unity_will_throw<FieldT>(1ul<<libff::log2(small_m)) )
+    if (get_root_of_unity_will_throw<FieldT>(1ul<<libff::log2(small_m)))
         return false;
 
     return true;
@@ -53,7 +53,7 @@ step_radix2_domain<FieldT>::step_radix2_domain(const size_t m) : evaluation_doma
 
     try { omega = libff::get_root_of_unity<FieldT>(1ul<<libff::log2(m)); }
     catch (const std::invalid_argument& e) { throw DomainSizeException(e.what()); }
-    
+
     big_omega = omega.squared();
     small_omega = libff::get_root_of_unity<FieldT>(small_m);
 }
diff --git a/libfqfft/evaluation_domain/get_evaluation_domain.tcc b/libfqfft/evaluation_domain/get_evaluation_domain.tcc
index 282b2f3..9ab4100 100755
--- a/libfqfft/evaluation_domain/get_evaluation_domain.tcc
+++ b/libfqfft/evaluation_domain/get_evaluation_domain.tcc
@@ -38,28 +38,28 @@ std::shared_ptr<evaluation_domain<FieldT> > get_evaluation_domain(const size_t m
     const size_t small = min_size - big;
     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));        
+    if (basic_radix2_domain<FieldT>::valid_for_size(min_size)) {
+        result.reset(new basic_radix2_domain<FieldT>(min_size));
     }
-    else if ( extended_radix2_domain<FieldT>::valid_for_size(min_size) ) {
+    else if (extended_radix2_domain<FieldT>::valid_for_size(min_size)) {
         result.reset(new extended_radix2_domain<FieldT>(min_size));
     }
-    else if ( step_radix2_domain<FieldT>::valid_for_size(min_size) ) {
+    else if (step_radix2_domain<FieldT>::valid_for_size(min_size)) {
         result.reset(new step_radix2_domain<FieldT>(min_size));
     }
-    else if ( basic_radix2_domain<FieldT>::valid_for_size(big + rounded_small) ) {
+    else if (basic_radix2_domain<FieldT>::valid_for_size(big + rounded_small)) {
         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));        
+    else if (extended_radix2_domain<FieldT>::valid_for_size(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) ) {
+    else if (step_radix2_domain<FieldT>::valid_for_size(big + rounded_small)) {
         result.reset(new step_radix2_domain<FieldT>(big + rounded_small));
     }
-    else if ( geometric_sequence_domain<FieldT>::valid_for_size(min_size) ) {
+    else if (geometric_sequence_domain<FieldT>::valid_for_size(min_size)) {
         result.reset(new geometric_sequence_domain<FieldT>(min_size));
     }
-    else if ( arithmetic_sequence_domain<FieldT>::valid_for_size(min_size) ) {
+    else if (arithmetic_sequence_domain<FieldT>::valid_for_size(min_size)) {
         result.reset(new arithmetic_sequence_domain<FieldT>(min_size));
     }
     else {

From 4877aedc1a119ecfb05300421c19d4616efac3f2 Mon Sep 17 00:00:00 2001
From: Duncan Tebbs <duncan.tebbs@gmail.com>
Date: Wed, 6 Oct 2021 16:08:43 +0100
Subject: [PATCH 6/6] tweaks to avoiding exceptions in get_evaluation_domain
 logic

---
 .../domains/basic_radix2_domain.tcc           | 13 +++-------
 .../domains/extended_radix2_domain.tcc        |  3 ++-
 .../domains/step_radix2_domain.tcc            | 12 ++++++----
 .../evaluation_domain/evaluation_domain.hpp   | 24 -------------------
 4 files changed, 13 insertions(+), 39 deletions(-)

diff --git a/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
index 19cb659..cf4a69c 100755
--- a/libfqfft/evaluation_domain/domains/basic_radix2_domain.tcc
+++ b/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;
 }
diff --git a/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
index b304f2f..de4a686 100755
--- a/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
+++ b/libfqfft/evaluation_domain/domains/extended_radix2_domain.tcc
@@ -36,8 +36,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;
 }
diff --git a/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc b/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
index 28b260d..b5aaac3 100755
--- a/libfqfft/evaluation_domain/domains/step_radix2_domain.tcc
+++ b/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;
 }
diff --git a/libfqfft/evaluation_domain/evaluation_domain.hpp b/libfqfft/evaluation_domain/evaluation_domain.hpp
index 2c0c1e2..2745330 100755
--- a/libfqfft/evaluation_domain/evaluation_domain.hpp
+++ b/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.
  */