Move most field utils to libff

Author: alexander-zw

depends/libff

@@ -81,7 +81,7 @@ std::vector<FieldT> subspace_element_powers(const affine_subspace<FieldT> &S,
      *
      *  In the case where the exponent is a power of two, we skip the multiplications.
      */
-    if (is_power_of_2(exponent))
+    if (libff::is_power_of_2(exponent))
     {
         return subspace_to_power_of_two(S, exponent);
     }

libiop/algebra/exponentiation.tcc

@@ -60,30 +60,30 @@ std::vector<FieldT> multiplicative_IFFT_wrapper(const std::vector<FieldT> &v,
                                                 const multiplicative_coset<FieldT> &H);
 
 template<typename FieldT>
-std::vector<FieldT> FFT_over_field_subset(const std::vector<typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type> coeffs,
+std::vector<FieldT> FFT_over_field_subset(const std::vector<typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type> coeffs,
                                             field_subset<FieldT> domain);
 
 template<typename FieldT>
-std::vector<FieldT> FFT_over_field_subset(const std::vector<typename enable_if<is_additive<FieldT>::value, FieldT>::type> coeffs,
+std::vector<FieldT> FFT_over_field_subset(const std::vector<typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type> coeffs,
                                             field_subset<FieldT> domain);
 
 template<typename FieldT>
-std::vector<FieldT> IFFT_over_field_subset(const std::vector<typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type> evals,
+std::vector<FieldT> IFFT_over_field_subset(const std::vector<typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type> evals,
                                              field_subset<FieldT> domain);
 
 template<typename FieldT>
-std::vector<FieldT> IFFT_over_field_subset(const std::vector<typename enable_if<is_additive<FieldT>::value, FieldT>::type> evals,
+std::vector<FieldT> IFFT_over_field_subset(const std::vector<typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type> evals,
                                              field_subset<FieldT> domain);
 
 template<typename FieldT>
 std::vector<FieldT> IFFT_of_known_degree_over_field_subset(
-    const std::vector<typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type> evals,
+    const std::vector<typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type> evals,
     size_t degree_bound,
     field_subset<FieldT> domain);
 
 template<typename FieldT>
 std::vector<FieldT> IFFT_of_known_degree_over_field_subset(
-    const std::vector<typename enable_if<is_additive<FieldT>::value, FieldT>::type> evals,
+    const std::vector<typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type> evals,
     size_t degree_bound,
     field_subset<FieldT> domain);
 

libiop/algebra/fft.hpp

@@ -4,7 +4,7 @@
 #include <libfqfft/evaluation_domain/domains/basic_radix2_domain_aux.hpp>
 
 #include <libff/common/profiling.hpp>
-#include "libiop/algebra/field_utils.hpp"
+#include <libff/algebra/field_utils/field_utils.hpp>
 #include "libiop/algebra/utils.hpp"
 
 namespace libiop {
@@ -207,23 +207,23 @@ template<typename FieldT>
 std::vector<FieldT> additive_FFT_wrapper(const std::vector<FieldT> &v,
                                          const affine_subspace<FieldT> &H)
 {
-    enter_block("Call to additive_FFT_wrapper");
-    print_indent(); printf("* Vector size: %zu\n", v.size());
-    print_indent(); printf("* Subspace size: %zu\n", H.num_elements());
+    libff::enter_block("Call to additive_FFT_wrapper");
+    libff::print_indent(); printf("* Vector size: %zu\n", v.size());
+    libff::print_indent(); printf("* Subspace size: %zu\n", H.num_elements());
     const std::vector<FieldT> result = additive_FFT(v, H);
-    leave_block("Call to additive_FFT_wrapper");
+    libff::leave_block("Call to additive_FFT_wrapper");
     return result;
 }
 
 template<typename FieldT>
 std::vector<FieldT> additive_IFFT_wrapper(const std::vector<FieldT> &v,
                                           const affine_subspace<FieldT> &H)
 {
-    enter_block("Call to additive_IFFT_wrapper");
-    print_indent(); printf("* Vector size: %zu\n", v.size());
-    print_indent(); printf("* Subspace size: %zu\n", H.num_elements());
+    libff::enter_block("Call to additive_IFFT_wrapper");
+    libff::print_indent(); printf("* Vector size: %zu\n", v.size());
+    libff::print_indent(); printf("* Subspace size: %zu\n", H.num_elements());
     const std::vector<FieldT> result = additive_IFFT(v, H);
-    leave_block("Call to additive_IFFT_wrapper");
+    libff::leave_block("Call to additive_IFFT_wrapper");
     return result;
 }
 
@@ -239,7 +239,7 @@ std::vector<FieldT> multiplicative_FFT_degree_aware(const std::vector<FieldT> &p
                                                     const FieldT &shift)
 {
     assert(poly_coeffs.size() <= coset.num_elements());
-    const size_t n = coset.num_elements(), logn = log2(n);
+    const size_t n = coset.num_elements(), logn = libff::log2(n);
 
     std::vector<FieldT> a(poly_coeffs);
     /** If there is a coset shift x, the degree i term of the polynomial is multiplied by x^i */
@@ -249,7 +249,7 @@ std::vector<FieldT> multiplicative_FFT_degree_aware(const std::vector<FieldT> &p
     }
     a.resize(n, FieldT::zero());
 
-    const size_t poly_dimension = log2(poly_coeffs.size());
+    const size_t poly_dimension = libff::log2(poly_coeffs.size());
     const size_t poly_size = poly_coeffs.size();
     /** When the polynomial is of size k*|coset|, for k < 2^i,
      *  the first i iterations of Cooley Tukey are easily predictable.
@@ -318,7 +318,7 @@ std::vector<FieldT> multiplicative_FFT_degree_aware(const std::vector<FieldT> &p
 
 template<typename FieldT>
 std::vector<FieldT> multiplicative_FFT_internal(
-    const std::vector<typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type> &poly_coeffs,
+    const std::vector<typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type> &poly_coeffs,
     const multiplicative_subgroup_base<FieldT> &domain, const FieldT shift)
 {
     assert(poly_coeffs.size() <= domain.num_elements());
@@ -327,7 +327,7 @@ std::vector<FieldT> multiplicative_FFT_internal(
 
 template<typename FieldT>
 std::vector<FieldT> multiplicative_FFT_internal(
-    const std::vector<typename enable_if<is_additive<FieldT>::value, FieldT>::type> &poly_coeffs,
+    const std::vector<typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type> &poly_coeffs,
     const multiplicative_subgroup_base<FieldT> &domain, const FieldT shift)
 {
     throw std::invalid_argument("attempting to perform multiplicative IFFT with non-multiplicative field type");
@@ -342,7 +342,7 @@ std::vector<FieldT> multiplicative_FFT(const std::vector<FieldT> &poly_coeffs,
 
 template<typename FieldT>
 std::vector<FieldT> multiplicative_IFFT_internal(
-    const std::vector<typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type> &evals,
+    const std::vector<typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type> &evals,
     const multiplicative_subgroup_base<FieldT> &domain, const FieldT shift)
 {
     assert(domain.num_elements() == evals.size());
@@ -362,7 +362,7 @@ std::vector<FieldT> multiplicative_IFFT_internal(
 
 template<typename FieldT>
 std::vector<FieldT> multiplicative_IFFT_internal(
-    const std::vector<typename enable_if<is_additive<FieldT>::value, FieldT>::type> &evals,
+    const std::vector<typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type> &evals,
     const multiplicative_subgroup_base<FieldT> &domain, const FieldT shift)
 {
     throw std::invalid_argument("attempting to perform multiplicative IFFT with non-multiplicative field type");
@@ -379,62 +379,62 @@ template<typename FieldT>
 std::vector<FieldT> multiplicative_FFT_wrapper(const std::vector<FieldT> &v,
                                                const multiplicative_coset<FieldT> &H)
 {
-    enter_block("Call to multiplicative_FFT_wrapper");
-    print_indent(); printf("* Vector size: %zu\n", v.size());
-    print_indent(); printf("* Subgroup size: %zu\n", H.num_elements());
+    libff::enter_block("Call to multiplicative_FFT_wrapper");
+    libff::print_indent(); printf("* Vector size: %zu\n", v.size());
+    libff::print_indent(); printf("* Subgroup size: %zu\n", H.num_elements());
     const std::vector<FieldT> result = multiplicative_FFT(v, H);
-    leave_block("Call to multiplicative_FFT_wrapper");
+    libff::leave_block("Call to multiplicative_FFT_wrapper");
     return result;
 }
 
 template<typename FieldT>
 std::vector<FieldT> multiplicative_IFFT_wrapper(const std::vector<FieldT> &v,
                                                 const multiplicative_coset<FieldT> &H)
 {
-    enter_block("Call to multiplicative_IFFT_wrapper");
-    print_indent(); printf("* Vector size: %zu\n", v.size());
-    print_indent(); printf("* Coset size: %zu\n", H.num_elements());
+    libff::enter_block("Call to multiplicative_IFFT_wrapper");
+    libff::print_indent(); printf("* Vector size: %zu\n", v.size());
+    libff::print_indent(); printf("* Coset size: %zu\n", H.num_elements());
     if (v.size() == 1)
     {
-        leave_block("Call to multiplicative_IFFT_wrapper");
+        libff::leave_block("Call to multiplicative_IFFT_wrapper");
         return {v[0]};
     }
     const std::vector<FieldT> result = multiplicative_IFFT(v, H);
-    leave_block("Call to multiplicative_IFFT_wrapper");
+    libff::leave_block("Call to multiplicative_IFFT_wrapper");
     return result;
 }
 
 template<typename FieldT>
-std::vector<FieldT> FFT_over_field_subset(const std::vector<typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type> coeffs,
+std::vector<FieldT> FFT_over_field_subset(const std::vector<typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type> coeffs,
                                           field_subset<FieldT> domain)
 {
     return multiplicative_FFT_wrapper<FieldT>(coeffs, domain.coset());
 }
 
 template<typename FieldT>
-std::vector<FieldT> FFT_over_field_subset(const std::vector<typename enable_if<is_additive<FieldT>::value, FieldT>::type> coeffs,
+std::vector<FieldT> FFT_over_field_subset(const std::vector<typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type> coeffs,
                                           field_subset<FieldT> domain)
 {
     return additive_FFT_wrapper<FieldT>(coeffs, domain.subspace());
 }
 
 template<typename FieldT>
-std::vector<FieldT> IFFT_over_field_subset(const std::vector<typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type> evals,
+std::vector<FieldT> IFFT_over_field_subset(const std::vector<typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type> evals,
                                            field_subset<FieldT> domain)
 {
     return multiplicative_IFFT_wrapper<FieldT>(evals, domain.coset());
 }
 
 template<typename FieldT>
-std::vector<FieldT> IFFT_over_field_subset(const std::vector<typename enable_if<is_additive<FieldT>::value, FieldT>::type> evals,
+std::vector<FieldT> IFFT_over_field_subset(const std::vector<typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type> evals,
                                            field_subset<FieldT> domain)
 {
     return additive_IFFT_wrapper<FieldT>(evals, domain.subspace());
 }
 
 template<typename FieldT>
 std::vector<FieldT> IFFT_of_known_degree_over_field_subset(
-    const std::vector<typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type> evals,
+    const std::vector<typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type> evals,
     size_t degree,
     field_subset<FieldT> domain)
 {
@@ -443,7 +443,7 @@ std::vector<FieldT> IFFT_of_known_degree_over_field_subset(
      *  The evaluations in this coset are every nth element of the evaluations
      *  over the entire domain, where n = |domain| / |degree|
      */
-    const size_t closest_power_of_two = round_to_next_power_of_2(degree);
+    const size_t closest_power_of_two = libff::round_to_next_power_of_2(degree);
     field_subset<FieldT> minimal_coset = domain.get_subset_of_order(closest_power_of_two);
     std::vector<FieldT> evals_in_minimal_coset;
     evals_in_minimal_coset.reserve(closest_power_of_two);
@@ -457,7 +457,7 @@ std::vector<FieldT> IFFT_of_known_degree_over_field_subset(
 
 template<typename FieldT>
 std::vector<FieldT> IFFT_of_known_degree_over_field_subset(
-    const std::vector<typename enable_if<is_additive<FieldT>::value, FieldT>::type> evals,
+    const std::vector<typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type> evals,
     size_t degree,
     field_subset<FieldT> domain)
 {
@@ -466,7 +466,7 @@ std::vector<FieldT> IFFT_of_known_degree_over_field_subset(
      *  therefore the evaluations are the first elements of the evaluations
      *  over the entire domain.
      */
-    const size_t closest_power_of_two = round_to_next_power_of_2(degree);
+    const size_t closest_power_of_two = libff::round_to_next_power_of_2(degree);
     field_subset<FieldT> minimal_subspace = domain.get_subset_of_order(closest_power_of_two);
     std::vector<FieldT> evals_in_minimal_subspace;
     evals_in_minimal_subspace.insert(

libiop/algebra/fft.tcc

@@ -10,7 +10,7 @@
 
 #include <cstddef>
 #include <vector>
-#include "libiop/algebra/field_utils.hpp"
+#include <libff/algebra/field_utils/field_utils.hpp>
 #include "libiop/algebra/polynomials/polynomial.hpp"
 
 namespace libiop {

libiop/algebra/field_subset/basis_utils.hpp

@@ -71,9 +71,9 @@ class field_subset {
     bool operator!=(const field_subset<FieldT> &other) const;
 protected:
     void construct_internal(const std::size_t num_elements,
-                            const typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type coset_shift);
+                            const typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type coset_shift);
     void construct_internal(const std::size_t num_elements,
-                            const typename enable_if<is_additive<FieldT>::value, FieldT>::type coset_shift);
+                            const typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type coset_shift);
 };
 
 } // namespace libiop

libiop/algebra/field_subset/field_subset.hpp

@@ -3,7 +3,7 @@ namespace libiop {
 template<typename FieldT>
 field_subset<FieldT>::field_subset(const std::size_t num_elements)
 {
-    if (is_multiplicative<FieldT>::value) {
+    if (libff::is_multiplicative<FieldT>::value) {
         this->construct_internal(num_elements, FieldT::one());
     } else {
         this->construct_internal(num_elements, FieldT::zero());
@@ -31,7 +31,7 @@ field_subset<FieldT>::field_subset(const multiplicative_coset<FieldT> coset) :
 
 template<typename FieldT>
 void field_subset<FieldT>::construct_internal(const std::size_t num_elements,
-                                              const typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type coset_shift)
+                                              const typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type coset_shift)
 {
     if (coset_shift == FieldT::zero()) {
         throw std::invalid_argument("coset_shift was supplied as 0, it was likely intended to be 1");
@@ -43,10 +43,10 @@ void field_subset<FieldT>::construct_internal(const std::size_t num_elements,
 
 template<typename FieldT>
 void field_subset<FieldT>::construct_internal(const std::size_t num_elements,
-                                              const typename enable_if<is_additive<FieldT>::value, FieldT>::type coset_shift)
+                                              const typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type coset_shift)
 {
-    assert(is_power_of_2(num_elements));
-    const std::size_t dimension = log2(num_elements);
+    assert(libff::is_power_of_2(num_elements));
+    const std::size_t dimension = libff::log2(num_elements);
 
     if (coset_shift != FieldT(0))
     {
@@ -221,7 +221,7 @@ field_subset<FieldT> field_subset<FieldT>::get_subset_of_order(const std::size_t
     {
         case affine_subspace_type:
         {
-            const std::size_t subset_dim = log2(order);
+            const std::size_t subset_dim = libff::log2(order);
             std::vector<FieldT> input_subspace_basis = this->subspace_->basis();
             input_subspace_basis.resize(subset_dim);
             return field_subset<FieldT>(

libiop/algebra/field_subset/field_subset.tcc

@@ -14,7 +14,7 @@
 #include <libfqfft/evaluation_domain/get_evaluation_domain.hpp>
 #include <libfqfft/evaluation_domain/domains/basic_radix2_domain.hpp>
 
-#include "libiop/algebra/field_utils.hpp"
+#include <libff/algebra/field_utils/field_utils.hpp>
 
 namespace libiop {
 
@@ -61,9 +61,9 @@ class multiplicative_subgroup_base {
     bool operator!=(const multiplicative_subgroup_base<FieldT> &other) const;
 
 protected:
-    void construct_internal(typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type order,
+    void construct_internal(typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type order,
         const FieldT generator = FieldT::zero());
-    void construct_internal(typename enable_if<is_additive<FieldT>::value, FieldT>::type order,
+    void construct_internal(typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type order,
         const FieldT generator = FieldT::zero());
 };
 

libiop/algebra/field_subset/subgroup.hpp

@@ -32,7 +32,7 @@ multiplicative_subgroup_base<FieldT>::multiplicative_subgroup_base(size_t order,
 
 template<typename FieldT>
 void multiplicative_subgroup_base<FieldT>::construct_internal(
-    typename enable_if<is_multiplicative<FieldT>::value, FieldT>::type order, const FieldT generator)
+    typename libff::enable_if<libff::is_multiplicative<FieldT>::value, FieldT>::type order, const FieldT generator)
 {
     FieldT F_order = FieldT(FieldT::mod) - 1;
     // In debug mode, check that subgroup order divides the order of the field.
@@ -68,15 +68,15 @@ void multiplicative_subgroup_base<FieldT>::construct_internal(
     this->fft_cache_ = std::make_shared<std::vector<FieldT> >();
     this->order_ = order.as_ulong();
 
-    if (is_power_of_2(this->order_) && this->order_ > 1)
+    if (libff::is_power_of_2(this->order_) && this->order_ > 1)
     {
         this->FFT_eval_domain_ = std::make_shared<libfqfft::basic_radix2_domain<FieldT>>(this->order_);
     }
 }
 
 template<typename FieldT>
 void multiplicative_subgroup_base<FieldT>::construct_internal(
-    typename enable_if<is_additive<FieldT>::value, FieldT>::type order, const FieldT generator)
+    typename libff::enable_if<libff::is_additive<FieldT>::value, FieldT>::type order, const FieldT generator)
 {
     throw std::invalid_argument("cannot create multiplicative subgroup of this field type");
 }
@@ -100,9 +100,9 @@ std::size_t multiplicative_subgroup_base<FieldT>::dimension() const
 
     /* dimension for a subgroup is only defined when the number of elements
        is a power of 2 */
-    assert(is_power_of_2(num_elems));
+    assert(libff::is_power_of_2(num_elems));
 
-    return log2(num_elems);
+    return libff::log2(num_elems);
 }
 
 template<typename FieldT>
@@ -199,7 +199,7 @@ std::size_t multiplicative_subgroup_base<FieldT>::position_by_coset_indices(
 template<typename FieldT>
 libfqfft::basic_radix2_domain<FieldT> multiplicative_subgroup_base<FieldT>::FFT_eval_domain() const
 {
-    assert(is_power_of_2(this->order_));
+    assert(libff::is_power_of_2(this->order_));
     return *(this->FFT_eval_domain_);
 }
 

libiop/algebra/field_subset/subgroup.tcc

@@ -10,7 +10,7 @@
 
 #include <cstddef>
 #include <vector>
-#include "libiop/algebra/field_utils.hpp"
+#include <libff/algebra/field_utils/field_utils.hpp>
 
 namespace libiop {