multiexp.hpp

Go to the documentation of this file.

 
#ifndef MULTIEXP_HPP_
#define MULTIEXP_HPP_
 
#include <cstddef>
#include <vector>
 
namespace libff {
 
enum multi_exp_method {
 multi_exp_method_naive,
 multi_exp_method_naive_plain,
 multi_exp_method_bos_coster,
 multi_exp_method_BDLO12
};
 
template<typename T, typename FieldT, multi_exp_method Method>
T multi_exp(typename std::vector<T>::const_iterator vec_start,
            typename std::vector<T>::const_iterator vec_end,
            typename std::vector<FieldT>::const_iterator scalar_start,
            typename std::vector<FieldT>::const_iterator scalar_end,
            const size_t chunks);
 
 
template<typename T, typename FieldT, multi_exp_method Method>
T multi_exp_with_mixed_addition(typename std::vector<T>::const_iterator vec_start,
                                typename std::vector<T>::const_iterator vec_end,
                                typename std::vector<FieldT>::const_iterator scalar_start,
                                typename std::vector<FieldT>::const_iterator scalar_end,
                                const size_t chunks);
 
template <typename T>
T inner_product(typename std::vector<T>::const_iterator a_start,
                typename std::vector<T>::const_iterator a_end,
                typename std::vector<T>::const_iterator b_start,
                typename std::vector<T>::const_iterator b_end);
 
template<typename T>
using window_table = std::vector<std::vector<T> >;
 
template<typename T>
size_t get_exp_window_size(const size_t num_scalars);
 
template<typename T>
window_table<T> get_window_table(const size_t scalar_size,
                                 const size_t window,
                                 const T &g);
 
template<typename T, typename FieldT>
T windowed_exp(const size_t scalar_size,
               const size_t window,
               const window_table<T> &powers_of_g,
               const FieldT &pow);
 
template<typename T, typename FieldT>
std::vector<T> batch_exp(const size_t scalar_size,
                         const size_t window,
                         const window_table<T> &table,
                         const std::vector<FieldT> &v);
 
template<typename T, typename FieldT>
std::vector<T> batch_exp_with_coeff(const size_t scalar_size,
                                    const size_t window,
                                    const window_table<T> &table,
                                    const FieldT &coeff,
                                    const std::vector<FieldT> &v);
 
template<typename T>
void batch_to_special(std::vector<T> &vec);
 
} // libff
 
#include <libff/algebra/scalar_multiplication/multiexp.tcc>
 
#endif // MULTIEXP_HPP_