fp2.hpp

Go to the documentation of this file.

 
#ifndef FP2_HPP_
#define FP2_HPP_
#include <libff/algebra/fields/fp.hpp>
#include <vector>
 
namespace libff
{
 
template<mp_size_t n, const bigint<n> &modulus> class Fp2_model;
 
template<mp_size_t n, const bigint<n> &modulus>
std::ostream &operator<<(std::ostream &, const Fp2_model<n, modulus> &);
 
template<mp_size_t n, const bigint<n> &modulus>
std::istream &operator>>(std::istream &, Fp2_model<n, modulus> &);
 
template<mp_size_t n, const bigint<n> &modulus> class Fp2_model
{
public:
    typedef Fp_model<n, modulus> my_Fp;
 
    // Exposing the field extension degree via a static member
    // allows to retrieve the value from the type. This can be useful.
    // Note that, the degree can be retrieved from a Fp2_model value
    // by invoking the `size()` method on the `coeffs` container.
    static const size_t tower_extension_degree = 2;
 
    static void static_init();
 
    static bigint<2 * n> euler;
    static size_t s;
    static bigint<2 * n> t;
    static bigint<2 * n> t_minus_1_over_2;
    static my_Fp non_residue;
    static Fp2_model<n, modulus> nqr;
    static Fp2_model<n, modulus> nqr_to_t;
    static my_Fp Frobenius_coeffs_c1[2];
 
    my_Fp coeffs[2];
    Fp2_model(){};
    // Fp2_model(const my_Fp& c0, const my_Fp& c1) : coeffs(c0, c1) {};
    Fp2_model(const my_Fp &c0, const my_Fp &c1)
    {
        this->coeffs[0] = c0;
        this->coeffs[1] = c1;
        return;
    };
 
    void clear()
    {
        coeffs[0].clear();
        coeffs[1].clear();
    }
    void print() const
    {
        printf("c0/c1:\n");
        coeffs[0].print();
        coeffs[1].print();
    }
 
    static const Fp2_model<n, modulus> &zero();
    static const Fp2_model<n, modulus> &one();
    static Fp2_model<n, modulus> random_element();
 
    bool is_zero() const { return coeffs[0].is_zero() && coeffs[1].is_zero(); }
    bool operator==(const Fp2_model &other) const;
    bool operator!=(const Fp2_model &other) const;
 
    Fp2_model operator+(const Fp2_model &other) const;
    Fp2_model operator-(const Fp2_model &other) const;
    Fp2_model operator*(const Fp2_model &other) const;
    Fp2_model operator-() const;
    Fp2_model squared() const;
    Fp2_model inverse() const;
    Fp2_model Frobenius_map(unsigned long power) const;
    Fp2_model sqrt() const;
    Fp2_model squared_karatsuba() const;
    Fp2_model squared_complex() const;
 
    template<mp_size_t m> Fp2_model operator^(const bigint<m> &other) const;
 
    static size_t size_in_bits() { return 2 * my_Fp::size_in_bits(); }
    static bigint<n> base_field_char() { return modulus; }
    static constexpr size_t extension_degree() { return 2; }
 
protected:
    static bool s_initialized;
    static Fp2_model<n, modulus> s_zero;
    static Fp2_model<n, modulus> s_one;
 
    friend std::ostream &operator<<<n, modulus>(
        std::ostream &out, const Fp2_model<n, modulus> &el);
    friend std::istream &operator>>
        <n, modulus>(std::istream &in, Fp2_model<n, modulus> &el);
};
 
template<mp_size_t n, const bigint<n> &modulus>
std::ostream &operator<<(
    std::ostream &out, const std::vector<Fp2_model<n, modulus>> &v);
 
template<mp_size_t n, const bigint<n> &modulus>
std::istream &operator>>(
    std::istream &in, std::vector<Fp2_model<n, modulus>> &v);
 
template<mp_size_t n, const bigint<n> &modulus>
Fp2_model<n, modulus> operator*(
    const Fp_model<n, modulus> &lhs, const Fp2_model<n, modulus> &rhs);
 
template<mp_size_t n, const bigint<n> &modulus>
bigint<2 * n> Fp2_model<n, modulus>::euler;
 
template<mp_size_t n, const bigint<n> &modulus> size_t Fp2_model<n, modulus>::s;
 
template<mp_size_t n, const bigint<n> &modulus>
bigint<2 * n> Fp2_model<n, modulus>::t;
 
template<mp_size_t n, const bigint<n> &modulus>
bigint<2 * n> Fp2_model<n, modulus>::t_minus_1_over_2;
 
template<mp_size_t n, const bigint<n> &modulus>
Fp_model<n, modulus> Fp2_model<n, modulus>::non_residue;
 
template<mp_size_t n, const bigint<n> &modulus>
Fp2_model<n, modulus> Fp2_model<n, modulus>::nqr;
 
template<mp_size_t n, const bigint<n> &modulus>
Fp2_model<n, modulus> Fp2_model<n, modulus>::nqr_to_t;
 
template<mp_size_t n, const bigint<n> &modulus>
Fp_model<n, modulus> Fp2_model<n, modulus>::Frobenius_coeffs_c1[2];
 
} // namespace libff
#include <libff/algebra/fields/fp2.tcc>
 
#endif // FP2_HPP_