Deduplicate/move libff util functions

.gitignore

@@ -37,3 +37,6 @@ gtest_main.pc
 gtest.pc
 DartConfiguration.tcl
 .DartConfiguration.tcl.swp
+.ninja_deps
+.ninja_log
+build.ninja

libiop/CMakeLists.txt

@@ -2,7 +2,6 @@ add_library(
   iop
 
   common/common.cpp
-  common/profiling.cpp
 
   bcs/hashing/blake2b.cpp
   protocols/ldt/ldt_reducer.cpp
@@ -97,9 +96,6 @@ target_link_libraries(instrument_algebra iop ${Boost_LIBRARIES})
 include(CTest)
 
 # algebra
-add_executable(test_common tests/algebra/test_common.cpp)
-target_link_libraries(test_common iop gtest_main)
-
 add_executable(test_exponentiation tests/algebra/test_exponentiation.cpp)
 target_link_libraries(test_exponentiation iop gtest_main)
 
@@ -130,10 +126,6 @@ target_link_libraries(test_successor_ordering iop gtest_main)
 add_executable(test_algebra_utils tests/algebra/test_algebra_utils.cpp)
 target_link_libraries(test_algebra_utils iop gtest_main)
 
-add_test(
-  NAME test_common
-  COMMAND test_common
-)
 add_test(
   NAME test_exponentiation
   COMMAND test_exponentiation

libiop/algebra/exponentiation.hpp

@@ -14,12 +14,6 @@
 
 namespace libiop {
 
-template<typename FieldT>
-FieldT power(const FieldT &base, const std::size_t exponent);
-
-template<typename FieldT>
-FieldT power(const FieldT &base, const std::vector<std::size_t> exponent);
-
 template<typename FieldT>
 std::vector<FieldT> subset_element_powers(const field_subset<FieldT> &S,
                                           const std::size_t exponent);

libiop/algebra/exponentiation.tcc

@@ -1,57 +1,5 @@
 namespace libiop {
 
-template<typename FieldT>
-FieldT power(const FieldT &base, const std::size_t exponent)
-{
-    FieldT result = FieldT::one();
-
-    bool found_one = false;
-
-    for (long i = 8 * sizeof(exponent) - 1; i >= 0; --i)
-    {
-        if (found_one)
-        {
-            result = result.squared();
-        }
-
-        if (exponent & (1ull << i))
-        {
-            found_one = true;
-            result *= base;
-        }
-    }
-
-    return result;
-}
-
-template<typename FieldT>
-FieldT power(const FieldT &base, const std::vector<std::size_t> exponent)
-{
-    FieldT result = FieldT::one();
-
-    bool found_one = false;
-
-    for (size_t j = 0; j < exponent.size(); j++)
-    {
-        size_t cur_exp = exponent[j];
-        for (long i = 8 * sizeof(cur_exp) - 1; i >= 0; --i)
-        {
-            if (found_one)
-            {
-                result = result.squared();
-            }
-
-            if (cur_exp & (1ull << i))
-            {
-                found_one = true;
-                result *= base;
-            }
-        }
-    }
-
-    return result;
-}
-
 template<typename FieldT>
 std::vector<FieldT> subspace_to_power_of_two(const affine_subspace<FieldT> &S,
                                              const size_t power_of_two)
@@ -81,7 +29,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/fft.hpp

@@ -15,7 +15,7 @@
 #include "libiop/algebra/field_subset/field_subset.hpp"
 #include "libiop/algebra/field_subset/subspace.hpp"
 #include "libiop/algebra/field_subset/subgroup.hpp"
-#include "libiop/common/common.hpp"
+#include <libff/common/utils.hpp>
 
 namespace libiop {
 
@@ -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.tcc

@@ -3,9 +3,9 @@
 #include <libfqfft/evaluation_domain/domains/basic_radix2_domain.hpp>
 #include <libfqfft/evaluation_domain/domains/basic_radix2_domain_aux.hpp>
 
-#include "libiop/algebra/field_utils.hpp"
+#include <libff/common/profiling.hpp>
+#include <libff/algebra/field_utils/field_utils.hpp>
 #include "libiop/algebra/utils.hpp"
-#include "libiop/common/profiling.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)
 {
-    libiop::enter_block("Call to additive_FFT_wrapper");
-    libiop::print_indent(); printf("* Vector size: %zu\n", v.size());
-    libiop::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);
-    libiop::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)
 {
-    libiop::enter_block("Call to additive_IFFT_wrapper");
-    libiop::print_indent(); printf("* Vector size: %zu\n", v.size());
-    libiop::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);
-    libiop::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 = libiop::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 = libiop::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)
 {
-    libiop::enter_block("Call to multiplicative_FFT_wrapper");
-    libiop::print_indent(); printf("* Vector size: %zu\n", v.size());
-    libiop::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);
-    libiop::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)
 {
-    libiop::enter_block("Call to multiplicative_IFFT_wrapper");
-    libiop::print_indent(); printf("* Vector size: %zu\n", v.size());
-    libiop::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)
     {
-        libiop::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);
-    libiop::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/field_subset/basis_utils.hpp

@@ -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/field_subset.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