Classes
struct	alt_bn128_ate_ell_coeffs

struct	alt_bn128_ate_G1_precomp

struct	alt_bn128_ate_G2_precomp

class	alt_bn128_G1

class	alt_bn128_G2

class	alt_bn128_pp

class	bigint

struct	bn128_ate_G1_precomp

struct	bn128_ate_G2_precomp

class	bn128_G1

class	bn128_G2

class	bn128_GT

class	bn128_pp

class	Double

struct	edwards_ate_G1_precomp

struct	edwards_Fq3_conic_coefficients

struct	edwards_Fq_conic_coefficients

class	edwards_G1

class	edwards_G2

class	edwards_pp

struct	edwards_tate_G2_precomp

struct	extended_edwards_G1_projective

struct	extended_edwards_G2_projective

struct	extended_mnt4_G2_projective

struct	extended_mnt6_G2_projective

class	Fp12_2over3over2_model

class	Fp2_model

class	Fp3_model

class	Fp4_model

class	Fp6_2over3_model

class	Fp6_3over2_model

class	Fp_model

struct	mnt4_affine_ate_coeffs

struct	mnt4_affine_ate_G1_precomputation

struct	mnt4_affine_ate_G2_precomputation

struct	mnt4_ate_add_coeffs

struct	mnt4_ate_dbl_coeffs

struct	mnt4_ate_G1_precomp

struct	mnt4_ate_G2_precomp

class	mnt4_G1

class	mnt4_G2

class	mnt4_pp

struct	mnt6_affine_ate_coeffs

struct	mnt6_affine_ate_G1_precomputation

struct	mnt6_affine_ate_G2_precomputation

struct	mnt6_ate_add_coeffs

struct	mnt6_ate_dbl_coeffs

struct	mnt6_ate_G1_precomp

struct	mnt6_ate_G2_precomp

class	mnt6_G1

class	mnt6_G2

class	mnt6_pp

struct	void_type

Typedefs
typedef Fp_model< alt_bn128_r_limbs, alt_bn128_modulus_r >	alt_bn128_Fr

typedef Fp_model< alt_bn128_q_limbs, alt_bn128_modulus_q >	alt_bn128_Fq

typedef Fp2_model< alt_bn128_q_limbs, alt_bn128_modulus_q >	alt_bn128_Fq2

typedef Fp6_3over2_model< alt_bn128_q_limbs, alt_bn128_modulus_q >	alt_bn128_Fq6

typedef Fp12_2over3over2_model< alt_bn128_q_limbs, alt_bn128_modulus_q >	alt_bn128_Fq12

typedef alt_bn128_Fq12	alt_bn128_GT

typedef alt_bn128_ate_G1_precomp	alt_bn128_G1_precomp

typedef alt_bn128_ate_G2_precomp	alt_bn128_G2_precomp

typedef Fp_model< bn128_r_limbs, bn128_modulus_r >	bn128_Fr

typedef Fp_model< bn128_q_limbs, bn128_modulus_q >	bn128_Fq

typedef bn128_GT	bn128_Fq12

typedef bn::Fp6	bn128_ate_ell_coeffs

typedef Fp_model< edwards_r_limbs, edwards_modulus_r >	edwards_Fr

typedef Fp_model< edwards_q_limbs, edwards_modulus_q >	edwards_Fq

typedef Fp3_model< edwards_q_limbs, edwards_modulus_q >	edwards_Fq3

typedef Fp6_2over3_model< edwards_q_limbs, edwards_modulus_q >	edwards_Fq6

typedef edwards_Fq6	edwards_GT

typedef std::vector< edwards_Fq_conic_coefficients >	edwards_tate_G1_precomp

typedef std::vector< edwards_Fq3_conic_coefficients >	edwards_ate_G2_precomp

typedef edwards_ate_G1_precomp	edwards_G1_precomp

typedef edwards_ate_G2_precomp	edwards_G2_precomp

typedef Fp_model< mnt4_r_limbs, mnt4_modulus_r >	mnt4_Fr

typedef Fp_model< mnt4_q_limbs, mnt4_modulus_q >	mnt4_Fq

typedef Fp2_model< mnt4_q_limbs, mnt4_modulus_q >	mnt4_Fq2

typedef Fp4_model< mnt4_q_limbs, mnt4_modulus_q >	mnt4_Fq4

typedef mnt4_Fq4	mnt4_GT

typedef mnt4_ate_G1_precomp	mnt4_G1_precomp

typedef mnt4_ate_G2_precomp	mnt4_G2_precomp

typedef Fp_model< mnt6_r_limbs, mnt6_modulus_r >	mnt6_Fr

typedef Fp_model< mnt6_q_limbs, mnt6_modulus_q >	mnt6_Fq

typedef Fp3_model< mnt6_q_limbs, mnt6_modulus_q >	mnt6_Fq3

typedef Fp6_2over3_model< mnt6_q_limbs, mnt6_modulus_q >	mnt6_Fq6

typedef mnt6_Fq6	mnt6_GT

typedef mnt6_ate_G1_precomp	mnt6_G1_precomp

typedef mnt6_ate_G2_precomp	mnt6_G2_precomp

template<typename EC_ppT >
using	Fr = typename EC_ppT::Fp_type

template<typename EC_ppT >
using	G1 = typename EC_ppT::G1_type

template<typename EC_ppT >
using	G2 = typename EC_ppT::G2_type

template<typename EC_ppT >
using	G1_precomp = typename EC_ppT::G1_precomp_type

template<typename EC_ppT >
using	G2_precomp = typename EC_ppT::G2_precomp_type

template<typename EC_ppT >
using	affine_ate_G1_precomp = typename EC_ppT::affine_ate_G1_precomp_type

template<typename EC_ppT >
using	affine_ate_G2_precomp = typename EC_ppT::affine_ate_G2_precomp_type

template<typename EC_ppT >
using	Fq = typename EC_ppT::Fq_type

template<typename EC_ppT >
using	Fqe = typename EC_ppT::Fqe_type

template<typename EC_ppT >
using	Fqk = typename EC_ppT::Fqk_type

template<typename EC_ppT >
using	GT = typename EC_ppT::GT_type

template<typename EC_ppT >
using	Fr_vector = std::vector<Fr<EC_ppT> >

template<typename EC_ppT >
using	G1_vector = std::vector<G1<EC_ppT> >

template<typename EC_ppT >
using	G2_vector = std::vector<G2<EC_ppT> >

template<typename T >
using	window_table = std::vector<std::vector<T> >

typedef std::vector< bool >	bit_vector

Enumerations
enum	multi_exp_method { multi_exp_method_naive , multi_exp_method_naive_plain , multi_exp_method_bos_coster , multi_exp_method_BDLO12 }

Functions
std::ostream &	operator<< (std::ostream &out, const alt_bn128_G1 &g)

std::istream &	operator>> (std::istream &in, alt_bn128_G1 &g)

std::ostream &	operator<< (std::ostream &out, const std::vector< alt_bn128_G1 > &v)

std::istream &	operator>> (std::istream &in, std::vector< alt_bn128_G1 > &v)

template<mp_size_t m>
alt_bn128_G1	operator* (const bigint< m > &lhs, const alt_bn128_G1 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
alt_bn128_G1	operator* (const Fp_model< m, modulus_p > &lhs, const alt_bn128_G1 &rhs)

std::ostream &	operator<< (std::ostream &out, const alt_bn128_G2 &g)

std::istream &	operator>> (std::istream &in, alt_bn128_G2 &g)

template<mp_size_t m>
alt_bn128_G2	operator* (const bigint< m > &lhs, const alt_bn128_G2 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
alt_bn128_G2	operator* (const Fp_model< m, modulus_p > &lhs, const alt_bn128_G2 &rhs)

void	init_alt_bn128_params ()

std::ostream &	operator<< (std::ostream &out, const alt_bn128_ate_G1_precomp &prec_P)

std::istream &	operator>> (std::istream &in, alt_bn128_ate_G1_precomp &prec_P)

std::ostream &	operator<< (std::ostream &out, const alt_bn128_ate_ell_coeffs &c)

std::istream &	operator>> (std::istream &in, alt_bn128_ate_ell_coeffs &c)

std::ostream &	operator<< (std::ostream &out, const alt_bn128_ate_G2_precomp &prec_Q)

std::istream &	operator>> (std::istream &in, alt_bn128_ate_G2_precomp &prec_Q)

alt_bn128_Fq12	alt_bn128_final_exponentiation_first_chunk (const alt_bn128_Fq12 &elt)

alt_bn128_Fq12	alt_bn128_exp_by_neg_z (const alt_bn128_Fq12 &elt)

alt_bn128_Fq12	alt_bn128_final_exponentiation_last_chunk (const alt_bn128_Fq12 &elt)

alt_bn128_GT	alt_bn128_final_exponentiation (const alt_bn128_Fq12 &elt)

void	doubling_step_for_flipped_miller_loop (const alt_bn128_Fq two_inv, alt_bn128_G2 &current, alt_bn128_ate_ell_coeffs &c)

void	mixed_addition_step_for_flipped_miller_loop (const alt_bn128_G2 base, alt_bn128_G2 &current, alt_bn128_ate_ell_coeffs &c)

alt_bn128_ate_G1_precomp	alt_bn128_ate_precompute_G1 (const alt_bn128_G1 &P)

alt_bn128_ate_G2_precomp	alt_bn128_ate_precompute_G2 (const alt_bn128_G2 &Q)

alt_bn128_Fq12	alt_bn128_ate_miller_loop (const alt_bn128_ate_G1_precomp &prec_P, const alt_bn128_ate_G2_precomp &prec_Q)

alt_bn128_Fq12	alt_bn128_ate_double_miller_loop (const alt_bn128_ate_G1_precomp &prec_P1, const alt_bn128_ate_G2_precomp &prec_Q1, const alt_bn128_ate_G1_precomp &prec_P2, const alt_bn128_ate_G2_precomp &prec_Q2)

alt_bn128_Fq12	alt_bn128_ate_pairing (const alt_bn128_G1 &P, const alt_bn128_G2 &Q)

alt_bn128_GT	alt_bn128_ate_reduced_pairing (const alt_bn128_G1 &P, const alt_bn128_G2 &Q)

alt_bn128_G1_precomp	alt_bn128_precompute_G1 (const alt_bn128_G1 &P)

alt_bn128_G2_precomp	alt_bn128_precompute_G2 (const alt_bn128_G2 &Q)

alt_bn128_Fq12	alt_bn128_miller_loop (const alt_bn128_G1_precomp &prec_P, const alt_bn128_G2_precomp &prec_Q)

alt_bn128_Fq12	alt_bn128_double_miller_loop (const alt_bn128_G1_precomp &prec_P1, const alt_bn128_G2_precomp &prec_Q1, const alt_bn128_G1_precomp &prec_P2, const alt_bn128_G2_precomp &prec_Q2)

alt_bn128_Fq12	alt_bn128_pairing (const alt_bn128_G1 &P, const alt_bn128_G2 &Q)

alt_bn128_GT	alt_bn128_reduced_pairing (const alt_bn128_G1 &P, const alt_bn128_G2 &Q)

alt_bn128_GT	alt_bn128_affine_reduced_pairing (const alt_bn128_G1 &P, const alt_bn128_G2 &Q)

std::ostream &	operator<< (std::ostream &out, const bn128_G1 &g)

std::istream &	operator>> (std::istream &in, bn128_G1 &g)

std::ostream &	operator<< (std::ostream &out, const std::vector< bn128_G1 > &v)

std::istream &	operator>> (std::istream &in, std::vector< bn128_G1 > &v)

template<mp_size_t m>
bn128_G1	operator* (const bigint< m > &lhs, const bn128_G1 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
bn128_G1	operator* (const Fp_model< m, modulus_p > &lhs, const bn128_G1 &rhs)

std::ostream &	operator<< (std::ostream &out, const bn128_G2 &g)

std::istream &	operator>> (std::istream &in, bn128_G2 &g)

template<mp_size_t m>
bn128_G2	operator* (const bigint< m > &lhs, const bn128_G2 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
bn128_G2	operator* (const Fp_model< m, modulus_p > &lhs, const bn128_G2 &rhs)

std::ostream &	operator<< (std::ostream &out, const bn128_GT &g)

std::istream &	operator>> (std::istream &in, bn128_GT &g)

template<mp_size_t m>
bn128_GT	operator^ (const bn128_GT &rhs, const bigint< m > &lhs)

template<mp_size_t m, const bigint< m > & modulus_p>
bn128_GT	operator^ (const bn128_GT &rhs, const Fp_model< m, modulus_p > &lhs)

void	init_bn128_params ()

std::ostream &	operator<< (std::ostream &out, const bn128_ate_G1_precomp &prec_P)

std::istream &	operator>> (std::istream &in, bn128_ate_G1_precomp &prec_P)

std::ostream &	operator<< (std::ostream &out, const bn128_ate_G2_precomp &prec_Q)

std::istream &	operator>> (std::istream &in, bn128_ate_G2_precomp &prec_Q)

bn128_ate_G1_precomp	bn128_ate_precompute_G1 (const bn128_G1 &P)

bn128_ate_G2_precomp	bn128_ate_precompute_G2 (const bn128_G2 &Q)

bn128_Fq12	bn128_ate_miller_loop (const bn128_ate_G1_precomp &prec_P, const bn128_ate_G2_precomp &prec_Q)

bn128_Fq12	bn128_double_ate_miller_loop (const bn128_ate_G1_precomp &prec_P1, const bn128_ate_G2_precomp &prec_Q1, const bn128_ate_G1_precomp &prec_P2, const bn128_ate_G2_precomp &prec_Q2)

bn128_GT	bn128_final_exponentiation (const bn128_Fq12 &elt)

template<typename FieldT >
void	bn_batch_invert (std::vector< FieldT > &vec)

template<typename GroupT , mp_size_t m>
GroupT	scalar_mul (const GroupT &base, const bigint< m > &scalar)

std::ostream &	operator<< (std::ostream &out, const edwards_G1 &g)

std::istream &	operator>> (std::istream &in, edwards_G1 &g)

std::ostream &	operator<< (std::ostream &out, const std::vector< edwards_G1 > &v)

std::istream &	operator>> (std::istream &in, std::vector< edwards_G1 > &v)

template<mp_size_t m>
edwards_G1	operator* (const bigint< m > &lhs, const edwards_G1 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
edwards_G1	operator* (const Fp_model< m, modulus_p > &lhs, const edwards_G1 &rhs)

std::ostream &	operator<< (std::ostream &out, const edwards_G2 &g)

std::istream &	operator>> (std::istream &in, edwards_G2 &g)

template<mp_size_t m>
edwards_G2	operator* (const bigint< m > &lhs, const edwards_G2 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
edwards_G2	operator* (const Fp_model< m, modulus_p > &lhs, const edwards_G2 &rhs)

void	init_edwards_params ()

std::ostream &	operator<< (std::ostream &out, const edwards_Fq_conic_coefficients &cc)

std::istream &	operator>> (std::istream &in, edwards_Fq_conic_coefficients &cc)

std::ostream &	operator<< (std::ostream &out, const edwards_tate_G1_precomp &prec_P)

std::istream &	operator>> (std::istream &in, edwards_tate_G1_precomp &prec_P)

std::ostream &	operator<< (std::ostream &out, const edwards_tate_G2_precomp &prec_Q)

std::istream &	operator>> (std::istream &in, edwards_tate_G2_precomp &prec_Q)

std::ostream &	operator<< (std::ostream &out, const edwards_Fq3_conic_coefficients &cc)

std::istream &	operator>> (std::istream &in, edwards_Fq3_conic_coefficients &cc)

std::ostream &	operator<< (std::ostream &out, const edwards_ate_G2_precomp &prec_Q)

std::istream &	operator>> (std::istream &in, edwards_ate_G2_precomp &prec_Q)

std::ostream &	operator<< (std::ostream &out, const edwards_ate_G1_precomp &prec_P)

std::istream &	operator>> (std::istream &in, edwards_ate_G1_precomp &prec_P)

edwards_Fq6	edwards_final_exponentiation_last_chunk (const edwards_Fq6 &elt, const edwards_Fq6 &elt_inv)

edwards_Fq6	edwards_final_exponentiation_first_chunk (const edwards_Fq6 &elt, const edwards_Fq6 &elt_inv)

edwards_GT	edwards_final_exponentiation (const edwards_Fq6 &elt)

edwards_tate_G2_precomp	edwards_tate_precompute_G2 (const edwards_G2 &Q)

void	doubling_step_for_miller_loop (extended_edwards_G1_projective &current, edwards_Fq_conic_coefficients &cc)

void	full_addition_step_for_miller_loop (const extended_edwards_G1_projective &base, extended_edwards_G1_projective &current, edwards_Fq_conic_coefficients &cc)

void	mixed_addition_step_for_miller_loop (const extended_edwards_G1_projective &base, extended_edwards_G1_projective &current, edwards_Fq_conic_coefficients &cc)

edwards_tate_G1_precomp	edwards_tate_precompute_G1 (const edwards_G1 &P)

edwards_Fq6	edwards_tate_miller_loop (const edwards_tate_G1_precomp &prec_P, const edwards_tate_G2_precomp &prec_Q)

edwards_Fq6	edwards_tate_pairing (const edwards_G1 &P, const edwards_G2 &Q)

edwards_GT	edwards_tate_reduced_pairing (const edwards_G1 &P, const edwards_G2 &Q)

void	doubling_step_for_flipped_miller_loop (extended_edwards_G2_projective &current, edwards_Fq3_conic_coefficients &cc)

void	full_addition_step_for_flipped_miller_loop (const extended_edwards_G2_projective &base, extended_edwards_G2_projective &current, edwards_Fq3_conic_coefficients &cc)

void	mixed_addition_step_for_flipped_miller_loop (const extended_edwards_G2_projective &base, extended_edwards_G2_projective &current, edwards_Fq3_conic_coefficients &cc)

edwards_ate_G1_precomp	edwards_ate_precompute_G1 (const edwards_G1 &P)

edwards_ate_G2_precomp	edwards_ate_precompute_G2 (const edwards_G2 &Q)

edwards_Fq6	edwards_ate_miller_loop (const edwards_ate_G1_precomp &prec_P, const edwards_ate_G2_precomp &prec_Q)

edwards_Fq6	edwards_ate_double_miller_loop (const edwards_ate_G1_precomp &prec_P1, const edwards_ate_G2_precomp &prec_Q1, const edwards_ate_G1_precomp &prec_P2, const edwards_ate_G2_precomp &prec_Q2)

edwards_Fq6	edwards_ate_pairing (const edwards_G1 &P, const edwards_G2 &Q)

edwards_GT	edwards_ate_reduced_pairing (const edwards_G1 &P, const edwards_G2 &Q)

edwards_G1_precomp	edwards_precompute_G1 (const edwards_G1 &P)

edwards_G2_precomp	edwards_precompute_G2 (const edwards_G2 &Q)

edwards_Fq6	edwards_miller_loop (const edwards_G1_precomp &prec_P, const edwards_G2_precomp &prec_Q)

edwards_Fq6	edwards_double_miller_loop (const edwards_G1_precomp &prec_P1, const edwards_G2_precomp &prec_Q1, const edwards_G1_precomp &prec_P2, const edwards_G2_precomp &prec_Q2)

edwards_Fq6	edwards_pairing (const edwards_G1 &P, const edwards_G2 &Q)

edwards_GT	edwards_reduced_pairing (const edwards_G1 &P, const edwards_G2 &Q)

std::ostream &	operator<< (std::ostream &out, const mnt4_G1 &g)

std::istream &	operator>> (std::istream &in, mnt4_G1 &g)

std::ostream &	operator<< (std::ostream &out, const std::vector< mnt4_G1 > &v)

std::istream &	operator>> (std::istream &in, std::vector< mnt4_G1 > &v)

template<mp_size_t m>
mnt4_G1	operator* (const bigint< m > &lhs, const mnt4_G1 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
mnt4_G1	operator* (const Fp_model< m, modulus_p > &lhs, const mnt4_G1 &rhs)

std::ostream &	operator<< (std::ostream &out, const mnt4_G2 &g)

std::istream &	operator>> (std::istream &in, mnt4_G2 &g)

template<mp_size_t m>
mnt4_G2	operator* (const bigint< m > &lhs, const mnt4_G2 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
mnt4_G2	operator* (const Fp_model< m, modulus_p > &lhs, const mnt4_G2 &rhs)

void	init_mnt4_params ()

std::ostream &	operator<< (std::ostream &out, const mnt4_ate_G1_precomp &prec_P)

std::istream &	operator>> (std::istream &in, mnt4_ate_G1_precomp &prec_P)

std::ostream &	operator<< (std::ostream &out, const mnt4_ate_dbl_coeffs &dc)

std::istream &	operator>> (std::istream &in, mnt4_ate_dbl_coeffs &dc)

std::ostream &	operator<< (std::ostream &out, const mnt4_ate_add_coeffs &ac)

std::istream &	operator>> (std::istream &in, mnt4_ate_add_coeffs &ac)

std::ostream &	operator<< (std::ostream &out, const mnt4_ate_G2_precomp &prec_Q)

std::istream &	operator>> (std::istream &in, mnt4_ate_G2_precomp &prec_Q)

mnt4_Fq4	mnt4_final_exponentiation_last_chunk (const mnt4_Fq4 &elt, const mnt4_Fq4 &elt_inv)

mnt4_Fq4	mnt4_final_exponentiation_first_chunk (const mnt4_Fq4 &elt, const mnt4_Fq4 &elt_inv)

mnt4_GT	mnt4_final_exponentiation (const mnt4_Fq4 &elt)

mnt4_affine_ate_G1_precomputation	mnt4_affine_ate_precompute_G1 (const mnt4_G1 &P)

mnt4_affine_ate_G2_precomputation	mnt4_affine_ate_precompute_G2 (const mnt4_G2 &Q)

mnt4_Fq4	mnt4_affine_ate_miller_loop (const mnt4_affine_ate_G1_precomputation &prec_P, const mnt4_affine_ate_G2_precomputation &prec_Q)

void	doubling_step_for_flipped_miller_loop (extended_mnt4_G2_projective &current, mnt4_ate_dbl_coeffs &dc)

void	mixed_addition_step_for_flipped_miller_loop (const mnt4_Fq2 base_X, const mnt4_Fq2 base_Y, const mnt4_Fq2 base_Y_squared, extended_mnt4_G2_projective &current, mnt4_ate_add_coeffs &ac)

mnt4_ate_G1_precomp	mnt4_ate_precompute_G1 (const mnt4_G1 &P)

mnt4_ate_G2_precomp	mnt4_ate_precompute_G2 (const mnt4_G2 &Q)

mnt4_Fq4	mnt4_ate_miller_loop (const mnt4_ate_G1_precomp &prec_P, const mnt4_ate_G2_precomp &prec_Q)

mnt4_Fq4	mnt4_ate_double_miller_loop (const mnt4_ate_G1_precomp &prec_P1, const mnt4_ate_G2_precomp &prec_Q1, const mnt4_ate_G1_precomp &prec_P2, const mnt4_ate_G2_precomp &prec_Q2)

mnt4_Fq4	mnt4_ate_pairing (const mnt4_G1 &P, const mnt4_G2 &Q)

mnt4_GT	mnt4_ate_reduced_pairing (const mnt4_G1 &P, const mnt4_G2 &Q)

mnt4_G1_precomp	mnt4_precompute_G1 (const mnt4_G1 &P)

mnt4_G2_precomp	mnt4_precompute_G2 (const mnt4_G2 &Q)

mnt4_Fq4	mnt4_miller_loop (const mnt4_G1_precomp &prec_P, const mnt4_G2_precomp &prec_Q)

mnt4_Fq4	mnt4_double_miller_loop (const mnt4_G1_precomp &prec_P1, const mnt4_G2_precomp &prec_Q1, const mnt4_G1_precomp &prec_P2, const mnt4_G2_precomp &prec_Q2)

mnt4_Fq4	mnt4_pairing (const mnt4_G1 &P, const mnt4_G2 &Q)

mnt4_GT	mnt4_reduced_pairing (const mnt4_G1 &P, const mnt4_G2 &Q)

mnt4_GT	mnt4_affine_reduced_pairing (const mnt4_G1 &P, const mnt4_G2 &Q)

std::ostream &	operator<< (std::ostream &out, const mnt6_G1 &g)

std::istream &	operator>> (std::istream &in, mnt6_G1 &g)

std::ostream &	operator<< (std::ostream &out, const std::vector< mnt6_G1 > &v)

std::istream &	operator>> (std::istream &in, std::vector< mnt6_G1 > &v)

template<mp_size_t m>
mnt6_G1	operator* (const bigint< m > &lhs, const mnt6_G1 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
mnt6_G1	operator* (const Fp_model< m, modulus_p > &lhs, const mnt6_G1 &rhs)

std::ostream &	operator<< (std::ostream &out, const mnt6_G2 &g)

std::istream &	operator>> (std::istream &in, mnt6_G2 &g)

template<mp_size_t m>
mnt6_G2	operator* (const bigint< m > &lhs, const mnt6_G2 &rhs)

template<mp_size_t m, const bigint< m > & modulus_p>
mnt6_G2	operator* (const Fp_model< m, modulus_p > &lhs, const mnt6_G2 &rhs)

void	init_mnt6_params ()

std::ostream &	operator<< (std::ostream &out, const mnt6_ate_G1_precomp &prec_P)

std::istream &	operator>> (std::istream &in, mnt6_ate_G1_precomp &prec_P)

std::ostream &	operator<< (std::ostream &out, const mnt6_ate_dbl_coeffs &dc)

std::istream &	operator>> (std::istream &in, mnt6_ate_dbl_coeffs &dc)

std::ostream &	operator<< (std::ostream &out, const mnt6_ate_add_coeffs &ac)

std::istream &	operator>> (std::istream &in, mnt6_ate_add_coeffs &ac)

std::ostream &	operator<< (std::ostream &out, const mnt6_ate_G2_precomp &prec_Q)

std::istream &	operator>> (std::istream &in, mnt6_ate_G2_precomp &prec_Q)

mnt6_Fq6	mnt6_final_exponentiation_last_chunk (const mnt6_Fq6 &elt, const mnt6_Fq6 &elt_inv)

mnt6_Fq6	mnt6_final_exponentiation_first_chunk (const mnt6_Fq6 &elt, const mnt6_Fq6 &elt_inv)

mnt6_GT	mnt6_final_exponentiation (const mnt6_Fq6 &elt)

mnt6_affine_ate_G1_precomputation	mnt6_affine_ate_precompute_G1 (const mnt6_G1 &P)

mnt6_affine_ate_G2_precomputation	mnt6_affine_ate_precompute_G2 (const mnt6_G2 &Q)

mnt6_Fq6	mnt6_affine_ate_miller_loop (const mnt6_affine_ate_G1_precomputation &prec_P, const mnt6_affine_ate_G2_precomputation &prec_Q)

void	doubling_step_for_flipped_miller_loop (extended_mnt6_G2_projective &current, mnt6_ate_dbl_coeffs &dc)

void	mixed_addition_step_for_flipped_miller_loop (const mnt6_Fq3 base_X, const mnt6_Fq3 base_Y, const mnt6_Fq3 base_Y_squared, extended_mnt6_G2_projective &current, mnt6_ate_add_coeffs &ac)

mnt6_ate_G1_precomp	mnt6_ate_precompute_G1 (const mnt6_G1 &P)

mnt6_ate_G2_precomp	mnt6_ate_precompute_G2 (const mnt6_G2 &Q)

mnt6_Fq6	mnt6_ate_miller_loop (const mnt6_ate_G1_precomp &prec_P, const mnt6_ate_G2_precomp &prec_Q)

mnt6_Fq6	mnt6_ate_double_miller_loop (const mnt6_ate_G1_precomp &prec_P1, const mnt6_ate_G2_precomp &prec_Q1, const mnt6_ate_G1_precomp &prec_P2, const mnt6_ate_G2_precomp &prec_Q2)

mnt6_Fq6	mnt6_ate_pairing (const mnt6_G1 &P, const mnt6_G2 &Q)

mnt6_GT	mnt6_ate_reduced_pairing (const mnt6_G1 &P, const mnt6_G2 &Q)

mnt6_G1_precomp	mnt6_precompute_G1 (const mnt6_G1 &P)

mnt6_G2_precomp	mnt6_precompute_G2 (const mnt6_G2 &Q)

mnt6_Fq6	mnt6_miller_loop (const mnt6_G1_precomp &prec_P, const mnt6_G2_precomp &prec_Q)

mnt6_Fq6	mnt6_double_miller_loop (const mnt6_G1_precomp &prec_P1, const mnt6_G2_precomp &prec_Q1, const mnt6_G1_precomp &prec_P2, const mnt6_G2_precomp &prec_Q2)

mnt6_Fq6	mnt6_pairing (const mnt6_G1 &P, const mnt6_G2 &Q)

mnt6_GT	mnt6_reduced_pairing (const mnt6_G1 &P, const mnt6_G2 &Q)

mnt6_GT	mnt6_affine_reduced_pairing (const mnt6_G1 &P, const mnt6_G2 &Q)

template<typename FieldT , mp_size_t m>
FieldT	power (const FieldT &base, const bigint< m > &exponent)

template<typename FieldT >
FieldT	power (const FieldT &base, const unsigned long exponent)

template<mp_size_t n>
std::ostream &	operator<< (std::ostream &out, const bigint< n > &b)

template<mp_size_t n>
std::istream &	operator>> (std::istream &in, bigint< n > &b)

template<typename FieldT >
std::enable_if< std::is_same< FieldT, Double >::value, FieldT >::type	get_root_of_unity (const size_t n)

template<typename FieldT >
std::enable_if<!std::is_same< FieldT, Double >::value, FieldT >::type	get_root_of_unity (const size_t n)

template<typename FieldT >
std::vector< FieldT >	pack_int_vector_into_field_element_vector (const std::vector< size_t > &v, const size_t w)

template<typename FieldT >
std::vector< FieldT >	pack_bit_vector_into_field_element_vector (const bit_vector &v, const size_t chunk_bits)

template<typename FieldT >
std::vector< FieldT >	pack_bit_vector_into_field_element_vector (const bit_vector &v)

template<typename FieldT >
std::vector< FieldT >	convert_bit_vector_to_field_element_vector (const bit_vector &v)

template<typename FieldT >
bit_vector	convert_field_element_vector_to_bit_vector (const std::vector< FieldT > &v)

template<typename FieldT >
bit_vector	convert_field_element_to_bit_vector (const FieldT &el)

template<typename FieldT >
bit_vector	convert_field_element_to_bit_vector (const FieldT &el, const size_t bitcount)

template<typename FieldT >
FieldT	convert_bit_vector_to_field_element (const bit_vector &v)

template<typename FieldT >
void	batch_invert (std::vector< FieldT > &vec)

template<mp_size_t n, const bigint< n > & modulus>
std::ostream &	operator<< (std::ostream &, const Fp_model< n, modulus > &)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, Fp_model< n, modulus > &p)

template<mp_size_t n, const bigint< n > & modulus>
std::ostream &	operator<< (std::ostream &, const Fp12_2over3over2_model< n, modulus > &)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, Fp12_2over3over2_model< n, modulus > &el)

template<mp_size_t n, const bigint< n > & modulus>
std::ostream &	operator<< (std::ostream &out, const std::vector< Fp12_2over3over2_model< n, modulus > > &v)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, std::vector< Fp12_2over3over2_model< n, modulus > > &v)

template<mp_size_t n, const bigint< n > & modulus>
Fp12_2over3over2_model< n, modulus >	operator* (const Fp_model< n, modulus > &lhs, const Fp12_2over3over2_model< n, modulus > &rhs)

template<mp_size_t n, const bigint< n > & modulus>
Fp12_2over3over2_model< n, modulus >	operator* (const Fp2_model< n, modulus > &lhs, const Fp12_2over3over2_model< n, modulus > &rhs)

template<mp_size_t n, const bigint< n > & modulus>
Fp12_2over3over2_model< n, modulus >	operator* (const Fp6_3over2_model< n, modulus > &lhs, const Fp12_2over3over2_model< n, modulus > &rhs)

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m>
Fp12_2over3over2_model< n, modulus >	operator^ (const Fp12_2over3over2_model< n, modulus > &self, const bigint< m > &exponent)

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m, const bigint< m > & exp_modulus>
Fp12_2over3over2_model< n, modulus >	operator^ (const Fp12_2over3over2_model< n, modulus > &self, const Fp_model< m, exp_modulus > &exponent)

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 &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>
std::ostream &	operator<< (std::ostream &, const Fp3_model< n, modulus > &)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, Fp3_model< n, modulus > &el)

template<mp_size_t n, const bigint< n > & modulus>
std::ostream &	operator<< (std::ostream &out, const std::vector< Fp3_model< n, modulus > > &v)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, std::vector< Fp3_model< n, modulus > > &v)

template<mp_size_t n, const bigint< n > & modulus>
Fp3_model< n, modulus >	operator* (const Fp_model< n, modulus > &lhs, const Fp3_model< n, modulus > &rhs)

template<mp_size_t n, const bigint< n > & modulus>
std::ostream &	operator<< (std::ostream &, const Fp4_model< n, modulus > &)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, Fp4_model< n, modulus > &el)

template<mp_size_t n, const bigint< n > & modulus>
Fp4_model< n, modulus >	operator* (const Fp_model< n, modulus > &lhs, const Fp4_model< n, modulus > &rhs)

template<mp_size_t n, const bigint< n > & modulus>
Fp4_model< n, modulus >	operator* (const Fp2_model< n, modulus > &lhs, const Fp4_model< n, modulus > &rhs)

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m>
Fp4_model< n, modulus >	operator^ (const Fp4_model< n, modulus > &self, const bigint< m > &exponent)

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m, const bigint< m > & modulus_p>
Fp4_model< n, modulus >	operator^ (const Fp4_model< n, modulus > &self, const Fp_model< m, modulus_p > &exponent)

template<mp_size_t n, const bigint< n > & modulus>
std::ostream &	operator<< (std::ostream &, const Fp6_2over3_model< n, modulus > &)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, Fp6_2over3_model< n, modulus > &el)

template<mp_size_t n, const bigint< n > & modulus>
std::ostream &	operator<< (std::ostream &out, const std::vector< Fp6_2over3_model< n, modulus > > &v)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, std::vector< Fp6_2over3_model< n, modulus > > &v)

template<mp_size_t n, const bigint< n > & modulus>
Fp6_2over3_model< n, modulus >	operator* (const Fp_model< n, modulus > &lhs, const Fp6_2over3_model< n, modulus > &rhs)

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m>
Fp6_2over3_model< n, modulus >	operator^ (const Fp6_2over3_model< n, modulus > &self, const bigint< m > &exponent)

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m, const bigint< m > & exp_modulus>
Fp6_2over3_model< n, modulus >	operator^ (const Fp6_2over3_model< n, modulus > &self, const Fp_model< m, exp_modulus > &exponent)

template<mp_size_t n, const bigint< n > & modulus>
std::ostream &	operator<< (std::ostream &, const Fp6_3over2_model< n, modulus > &)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, Fp6_3over2_model< n, modulus > &el)

template<mp_size_t n, const bigint< n > & modulus>
std::ostream &	operator<< (std::ostream &out, const std::vector< Fp6_3over2_model< n, modulus > > &v)

template<mp_size_t n, const bigint< n > & modulus>
std::istream &	operator>> (std::istream &in, std::vector< Fp6_3over2_model< n, modulus > > &v)

template<mp_size_t n, const bigint< n > & modulus>
Fp6_3over2_model< n, modulus >	operator* (const Fp_model< n, modulus > &lhs, const Fp6_3over2_model< n, modulus > &rhs)

template<mp_size_t n, const bigint< n > & modulus>
Fp6_3over2_model< n, modulus >	operator* (const Fp2_model< n, modulus > &lhs, const Fp6_3over2_model< n, modulus > &rhs)

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 >
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)

template<mp_size_t n>
std::vector< long >	find_wnaf (const size_t window_size, const bigint< n > &scalar)

template<typename T , mp_size_t n>
T	fixed_window_wnaf_exp (const size_t window_size, const T &base, const bigint< n > &scalar)

template<typename T , mp_size_t n>
T	opt_window_wnaf_exp (const T &base, const bigint< n > &scalar, const size_t scalar_bits)

long long	get_nsec_time ()

long long	get_nsec_cpu_time ()

void	start_profiling ()

void	clear_profiling_counters ()

void	print_cumulative_time_entry (const std::string &key, const long long factor)

void	print_cumulative_times (const long long factor)

void	print_cumulative_op_counts (const bool only_fq)

void	print_op_profiling (const std::string &msg)

void	print_time (const char *msg)

void	print_header (const char *msg)

void	print_indent ()

void	op_profiling_enter (const std::string &msg)

void	enter_block (const std::string &msg, const bool indent)

void	leave_block (const std::string &msg, const bool indent)

void	print_mem (const std::string &s)

void	print_compilation_info ()

template<typename FieldT >
FieldT	SHA512_rng (const uint64_t idx)

void	consume_newline (std::istream &in)

void	consume_OUTPUT_NEWLINE (std::istream &in)

void	consume_OUTPUT_SEPARATOR (std::istream &in)

void	output_bool (std::ostream &out, const bool b)

void	input_bool (std::istream &in, bool &b)

void	output_bool_vector (std::ostream &out, const std::vector< bool > &v)

void	input_bool_vector (std::istream &in, std::vector< bool > &v)

template<typename T >
T	reserialize (const T &obj)

template<typename T >
std::ostream &	operator<< (std::ostream &out, const std::vector< T > &v)

template<typename T >
std::istream &	operator>> (std::ostream &out, std::vector< T > &v)

template<typename T1 , typename T2 >
std::ostream &	operator<< (std::ostream &out, const std::map< T1, T2 > &m)

template<typename T1 , typename T2 >
std::istream &	operator>> (std::istream &in, std::map< T1, T2 > &m)

template<typename T >
std::ostream &	operator<< (std::ostream &out, const std::set< T > &s)

template<typename T >
std::istream &	operator>> (std::istream &in, std::set< T > &s)

size_t	get_power_of_two (size_t n)

size_t	log2 (size_t n)
	returns ceil(log2(n)), so 1ul<<log2(n) is the smallest power of 2, that is not less than n

size_t	to_twos_complement (int i, size_t w)

int	from_twos_complement (size_t i, size_t w)

size_t	bitreverse (size_t n, const size_t l)

bit_vector	int_list_to_bits (const std::initializer_list< unsigned long > &l, const size_t wordsize)

long long	div_ceil (long long x, long long y)

bool	is_little_endian ()

std::string	FORMAT (const std::string &prefix, const char *format,...)

void	serialize_bit_vector (std::ostream &out, const bit_vector &v)

void	deserialize_bit_vector (std::istream &in, bit_vector &v)

size_t	exp2 (size_t k)

template<typename ... Types>
void	UNUSED (Types &&...)

template<typename T >
size_t	size_in_bits (const std::vector< T > &v)

Variables
bigint< alt_bn128_r_limbs >	alt_bn128_modulus_r

bigint< alt_bn128_q_limbs >	alt_bn128_modulus_q

alt_bn128_Fq	alt_bn128_coeff_b

alt_bn128_Fq2	alt_bn128_twist

alt_bn128_Fq2	alt_bn128_twist_coeff_b

alt_bn128_Fq	alt_bn128_twist_mul_by_b_c0

alt_bn128_Fq	alt_bn128_twist_mul_by_b_c1

alt_bn128_Fq2	alt_bn128_twist_mul_by_q_X

alt_bn128_Fq2	alt_bn128_twist_mul_by_q_Y

bigint< alt_bn128_q_limbs >	alt_bn128_ate_loop_count

bool	alt_bn128_ate_is_loop_count_neg

bigint< 12 *alt_bn128_q_limbs >	alt_bn128_final_exponent

bigint< alt_bn128_q_limbs >	alt_bn128_final_exponent_z

bool	alt_bn128_final_exponent_is_z_neg

const mp_size_t	alt_bn128_r_bitcount = 254

const mp_size_t	alt_bn128_q_bitcount = 254

const mp_size_t	alt_bn128_r_limbs = (alt_bn128_r_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

const mp_size_t	alt_bn128_q_limbs = (alt_bn128_q_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

bigint< bn128_r_limbs >	bn128_modulus_r

bigint< bn128_q_limbs >	bn128_modulus_q

bn::Fp	bn128_coeff_b

size_t	bn128_Fq_s

bn::Fp	bn128_Fq_nqr_to_t

mie::Vuint	bn128_Fq_t_minus_1_over_2

bn::Fp2	bn128_twist_coeff_b

size_t	bn128_Fq2_s

bn::Fp2	bn128_Fq2_nqr_to_t

mie::Vuint	bn128_Fq2_t_minus_1_over_2

const mp_size_t	bn128_r_bitcount = 254

const mp_size_t	bn128_q_bitcount = 254

const mp_size_t	bn128_r_limbs = (bn128_r_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

const mp_size_t	bn128_q_limbs = (bn128_q_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

bigint< edwards_r_limbs >	edwards_modulus_r

bigint< edwards_q_limbs >	edwards_modulus_q

edwards_Fq	edwards_coeff_a

edwards_Fq	edwards_coeff_d

edwards_Fq3	edwards_twist

edwards_Fq3	edwards_twist_coeff_a

edwards_Fq3	edwards_twist_coeff_d

edwards_Fq	edwards_twist_mul_by_a_c0

edwards_Fq	edwards_twist_mul_by_a_c1

edwards_Fq	edwards_twist_mul_by_a_c2

edwards_Fq	edwards_twist_mul_by_d_c0

edwards_Fq	edwards_twist_mul_by_d_c1

edwards_Fq	edwards_twist_mul_by_d_c2

edwards_Fq	edwards_twist_mul_by_q_Y

edwards_Fq	edwards_twist_mul_by_q_Z

bigint< edwards_q_limbs >	edwards_ate_loop_count

bigint< 6 *edwards_q_limbs >	edwards_final_exponent

bigint< edwards_q_limbs >	edwards_final_exponent_last_chunk_abs_of_w0

bool	edwards_final_exponent_last_chunk_is_w0_neg

bigint< edwards_q_limbs >	edwards_final_exponent_last_chunk_w1

const mp_size_t	edwards_r_bitcount = 181

const mp_size_t	edwards_q_bitcount = 183

const mp_size_t	edwards_r_limbs = (edwards_r_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

const mp_size_t	edwards_q_limbs = (edwards_q_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

mnt4_Fq2	mnt4_twist

mnt4_Fq2	mnt4_twist_coeff_a

mnt4_Fq2	mnt4_twist_coeff_b

mnt4_Fq	mnt4_twist_mul_by_a_c0

mnt4_Fq	mnt4_twist_mul_by_a_c1

mnt4_Fq	mnt4_twist_mul_by_b_c0

mnt4_Fq	mnt4_twist_mul_by_b_c1

mnt4_Fq	mnt4_twist_mul_by_q_X

mnt4_Fq	mnt4_twist_mul_by_q_Y

bigint< mnt4_q_limbs >	mnt4_ate_loop_count

bool	mnt4_ate_is_loop_count_neg

bigint< 4 *mnt4_q_limbs >	mnt4_final_exponent

bigint< mnt4_q_limbs >	mnt4_final_exponent_last_chunk_abs_of_w0

bool	mnt4_final_exponent_last_chunk_is_w0_neg

bigint< mnt4_q_limbs >	mnt4_final_exponent_last_chunk_w1

const mp_size_t	mnt4_r_bitcount = mnt46_A_bitcount

const mp_size_t	mnt4_q_bitcount = mnt46_B_bitcount

const mp_size_t	mnt4_r_limbs = mnt46_A_limbs

const mp_size_t	mnt4_q_limbs = mnt46_B_limbs

bigint< mnt4_r_limbs >	mnt4_modulus_r

bigint< mnt4_q_limbs >	mnt4_modulus_q

bigint< mnt46_A_limbs >	mnt46_modulus_A

bigint< mnt46_B_limbs >	mnt46_modulus_B

const mp_size_t	mnt46_A_bitcount = 298

const mp_size_t	mnt46_B_bitcount = 298

const mp_size_t	mnt46_A_limbs = (mnt46_A_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

const mp_size_t	mnt46_B_limbs = (mnt46_B_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

mnt6_Fq3	mnt6_twist

mnt6_Fq3	mnt6_twist_coeff_a

mnt6_Fq3	mnt6_twist_coeff_b

mnt6_Fq	mnt6_twist_mul_by_a_c0

mnt6_Fq	mnt6_twist_mul_by_a_c1

mnt6_Fq	mnt6_twist_mul_by_a_c2

mnt6_Fq	mnt6_twist_mul_by_b_c0

mnt6_Fq	mnt6_twist_mul_by_b_c1

mnt6_Fq	mnt6_twist_mul_by_b_c2

mnt6_Fq	mnt6_twist_mul_by_q_X

mnt6_Fq	mnt6_twist_mul_by_q_Y

bigint< mnt6_q_limbs >	mnt6_ate_loop_count

bool	mnt6_ate_is_loop_count_neg

bigint< 6 *mnt6_q_limbs >	mnt6_final_exponent

bigint< mnt6_q_limbs >	mnt6_final_exponent_last_chunk_abs_of_w0

bool	mnt6_final_exponent_last_chunk_is_w0_neg

bigint< mnt6_q_limbs >	mnt6_final_exponent_last_chunk_w1

const mp_size_t	mnt6_r_bitcount = mnt46_B_bitcount

const mp_size_t	mnt6_q_bitcount = mnt46_A_bitcount

const mp_size_t	mnt6_r_limbs = mnt46_B_limbs

const mp_size_t	mnt6_q_limbs = mnt46_A_limbs

bigint< mnt6_r_limbs >	mnt6_modulus_r

bigint< mnt6_q_limbs >	mnt6_modulus_q

const double	PI = 3.141592653589793238460264338328L

long long	start_time

long long	last_time

long long	start_cpu_time

long long	last_cpu_time

std::map< std::string, size_t >	invocation_counts

std::map< std::string, long long >	enter_times

std::map< std::string, long long >	last_times

std::map< std::string, long long >	cumulative_times

std::map< std::string, long long >	enter_cpu_times

std::map< std::string, long long >	last_cpu_times

std::map< std::pair< std::string, std::string >, long long >	op_counts

std::map< std::pair< std::string, std::string >, long long >	cumulative_op_counts

size_t	indentation = 0

std::vector< std::string >	block_names

std::list< std::pair< std::string, long long * > >	op_data_points

bool	inhibit_profiling_info = false

bool	inhibit_profiling_counters = false

Typedef Documentation

◆ affine_ate_G1_precomp

template<typename EC_ppT >

using libff::affine_ate_G1_precomp = typename EC_ppT::affine_ate_G1_precomp_type

Definition at line 82 of file public_params.hpp.

◆ affine_ate_G2_precomp

template<typename EC_ppT >

using libff::affine_ate_G2_precomp = typename EC_ppT::affine_ate_G2_precomp_type

Definition at line 84 of file public_params.hpp.

◆ alt_bn128_Fq

typedef Fp_model<alt_bn128_q_limbs, alt_bn128_modulus_q> libff::alt_bn128_Fq

Definition at line 28 of file alt_bn128_init.hpp.

◆ alt_bn128_Fq12

typedef Fp12_2over3over2_model<alt_bn128_q_limbs, alt_bn128_modulus_q> libff::alt_bn128_Fq12

Definition at line 31 of file alt_bn128_init.hpp.

◆ alt_bn128_Fq2

typedef Fp2_model<alt_bn128_q_limbs, alt_bn128_modulus_q> libff::alt_bn128_Fq2

Definition at line 29 of file alt_bn128_init.hpp.

◆ alt_bn128_Fq6

typedef Fp6_3over2_model<alt_bn128_q_limbs, alt_bn128_modulus_q> libff::alt_bn128_Fq6

Definition at line 30 of file alt_bn128_init.hpp.

◆ alt_bn128_Fr

typedef Fp_model<alt_bn128_r_limbs, alt_bn128_modulus_r> libff::alt_bn128_Fr

Definition at line 27 of file alt_bn128_init.hpp.

◆ alt_bn128_G1_precomp

typedef alt_bn128_ate_G1_precomp libff::alt_bn128_G1_precomp

Definition at line 68 of file alt_bn128_pairing.hpp.

◆ alt_bn128_G2_precomp

typedef alt_bn128_ate_G2_precomp libff::alt_bn128_G2_precomp

Definition at line 69 of file alt_bn128_pairing.hpp.

◆ alt_bn128_GT

typedef alt_bn128_Fq12 libff::alt_bn128_GT

Definition at line 32 of file alt_bn128_init.hpp.

◆ bit_vector

typedef std::vector<bool> libff::bit_vector

Definition at line 21 of file utils.hpp.

◆ bn128_ate_ell_coeffs

typedef bn::Fp6 libff::bn128_ate_ell_coeffs

Definition at line 29 of file bn128_pairing.hpp.

◆ bn128_Fq

typedef Fp_model<bn128_q_limbs, bn128_modulus_q> libff::bn128_Fq

Definition at line 37 of file bn128_init.hpp.

◆ bn128_Fq12

typedef bn128_GT libff::bn128_Fq12

Definition at line 44 of file bn128_init.hpp.

◆ bn128_Fr

typedef Fp_model<bn128_r_limbs, bn128_modulus_r> libff::bn128_Fr

Definition at line 36 of file bn128_init.hpp.

◆ edwards_ate_G2_precomp

typedef std::vector<edwards_Fq3_conic_coefficients> libff::edwards_ate_G2_precomp

Definition at line 70 of file edwards_pairing.hpp.

◆ edwards_Fq

typedef Fp_model<edwards_q_limbs, edwards_modulus_q> libff::edwards_Fq

Definition at line 27 of file edwards_init.hpp.

◆ edwards_Fq3

typedef Fp3_model<edwards_q_limbs, edwards_modulus_q> libff::edwards_Fq3

Definition at line 28 of file edwards_init.hpp.

◆ edwards_Fq6

typedef Fp6_2over3_model<edwards_q_limbs, edwards_modulus_q> libff::edwards_Fq6

Definition at line 29 of file edwards_init.hpp.

◆ edwards_Fr

typedef Fp_model<edwards_r_limbs, edwards_modulus_r> libff::edwards_Fr

Definition at line 26 of file edwards_init.hpp.

◆ edwards_G1_precomp

typedef edwards_ate_G1_precomp libff::edwards_G1_precomp

Definition at line 102 of file edwards_pairing.hpp.

◆ edwards_G2_precomp

typedef edwards_ate_G2_precomp libff::edwards_G2_precomp

Definition at line 103 of file edwards_pairing.hpp.

◆ edwards_GT

typedef edwards_Fq6 libff::edwards_GT

Definition at line 30 of file edwards_init.hpp.

◆ edwards_tate_G1_precomp

typedef std::vector<edwards_Fq_conic_coefficients> libff::edwards_tate_G1_precomp

Definition at line 35 of file edwards_pairing.hpp.

◆ Fq

template<typename EC_ppT >

using libff::Fq = typename EC_ppT::Fq_type

Definition at line 86 of file public_params.hpp.

◆ Fqe

template<typename EC_ppT >

using libff::Fqe = typename EC_ppT::Fqe_type

Definition at line 88 of file public_params.hpp.

◆ Fqk

template<typename EC_ppT >

using libff::Fqk = typename EC_ppT::Fqk_type

Definition at line 90 of file public_params.hpp.

◆ Fr

template<typename EC_ppT >

using libff::Fr = typename EC_ppT::Fp_type

Definition at line 72 of file public_params.hpp.

◆ Fr_vector

template<typename EC_ppT >

using libff::Fr_vector = std::vector<Fr<EC_ppT> >

Definition at line 95 of file public_params.hpp.

◆ G1

template<typename EC_ppT >

using libff::G1 = typename EC_ppT::G1_type

Definition at line 74 of file public_params.hpp.

◆ G1_precomp

template<typename EC_ppT >

using libff::G1_precomp = typename EC_ppT::G1_precomp_type

Definition at line 78 of file public_params.hpp.

◆ G1_vector

template<typename EC_ppT >

using libff::G1_vector = std::vector<G1<EC_ppT> >

Definition at line 97 of file public_params.hpp.

◆ G2

template<typename EC_ppT >

using libff::G2 = typename EC_ppT::G2_type

Definition at line 76 of file public_params.hpp.

◆ G2_precomp

template<typename EC_ppT >

using libff::G2_precomp = typename EC_ppT::G2_precomp_type

Definition at line 80 of file public_params.hpp.

◆ G2_vector

template<typename EC_ppT >

using libff::G2_vector = std::vector<G2<EC_ppT> >

Definition at line 99 of file public_params.hpp.

◆ GT

template<typename EC_ppT >

using libff::GT = typename EC_ppT::GT_type

Definition at line 92 of file public_params.hpp.

◆ mnt4_Fq

typedef Fp_model<mnt4_q_limbs, mnt4_modulus_q> libff::mnt4_Fq

Definition at line 36 of file mnt4_init.hpp.

◆ mnt4_Fq2

typedef Fp2_model<mnt4_q_limbs, mnt4_modulus_q> libff::mnt4_Fq2

Definition at line 37 of file mnt4_init.hpp.

◆ mnt4_Fq4

typedef Fp4_model<mnt4_q_limbs, mnt4_modulus_q> libff::mnt4_Fq4

Definition at line 38 of file mnt4_init.hpp.

◆ mnt4_Fr

typedef Fp_model<mnt4_r_limbs, mnt4_modulus_r> libff::mnt4_Fr

Definition at line 35 of file mnt4_init.hpp.

◆ mnt4_G1_precomp

typedef mnt4_ate_G1_precomp libff::mnt4_G1_precomp

Definition at line 122 of file mnt4_pairing.hpp.

◆ mnt4_G2_precomp

typedef mnt4_ate_G2_precomp libff::mnt4_G2_precomp

Definition at line 123 of file mnt4_pairing.hpp.

◆ mnt4_GT

typedef mnt4_Fq4 libff::mnt4_GT

Definition at line 39 of file mnt4_init.hpp.

◆ mnt6_Fq

typedef Fp_model<mnt6_q_limbs, mnt6_modulus_q> libff::mnt6_Fq

Definition at line 36 of file mnt6_init.hpp.

◆ mnt6_Fq3

typedef Fp3_model<mnt6_q_limbs, mnt6_modulus_q> libff::mnt6_Fq3

Definition at line 37 of file mnt6_init.hpp.

◆ mnt6_Fq6

typedef Fp6_2over3_model<mnt6_q_limbs, mnt6_modulus_q> libff::mnt6_Fq6

Definition at line 38 of file mnt6_init.hpp.

◆ mnt6_Fr

typedef Fp_model<mnt6_r_limbs, mnt6_modulus_r> libff::mnt6_Fr

Definition at line 35 of file mnt6_init.hpp.

◆ mnt6_G1_precomp

typedef mnt6_ate_G1_precomp libff::mnt6_G1_precomp

Definition at line 122 of file mnt6_pairing.hpp.

◆ mnt6_G2_precomp

typedef mnt6_ate_G2_precomp libff::mnt6_G2_precomp

Definition at line 123 of file mnt6_pairing.hpp.

◆ mnt6_GT

typedef mnt6_Fq6 libff::mnt6_GT

Definition at line 39 of file mnt6_init.hpp.

◆ window_table

template<typename T >

using libff::window_table = std::vector<std::vector<T> >

A window table stores window sizes for different instance sizes for fixed-base multi-scalar multiplications.

Definition at line 91 of file multiexp.hpp.

Enumeration Type Documentation

◆ multi_exp_method

enum libff::multi_exp_method

Enumerator
multi_exp_method_naive	Naive multi-exponentiation individually multiplies each base by the corresponding scalar and adds up the results. multi_exp_method_naive uses opt_window_wnaf_exp for exponentiation, while multi_exp_method_plain uses operator *.
multi_exp_method_naive_plain
multi_exp_method_bos_coster	A variant of the Bos-Coster algorithm [1], with implementation suggestions from [2]. [1] = Bos and Coster, "Addition chain heuristics", CRYPTO '89 [2] = Bernstein, Duif, Lange, Schwabe, and Yang, "High-speed high-security signatures", CHES '11
multi_exp_method_BDLO12	A special case of Pippenger's algorithm from Page 15 of Bernstein, Doumen, Lange, Oosterwijk, "Faster batch forgery identification", INDOCRYPT 2012 (https://eprint.iacr.org/2012/549.pdf) When compiled with USE_MIXED_ADDITION, assumes input is in special form. Requires that T implements .dbl() (and, if USE_MIXED_ADDITION is defined, .to_special(), .mixed_add(), and batch_to_special()).

Definition at line 20 of file multiexp.hpp.

                      {
 multi_exp_method_naive,
 multi_exp_method_naive_plain,
 multi_exp_method_bos_coster,
 multi_exp_method_BDLO12
};

Function Documentation

◆ alt_bn128_affine_reduced_pairing()

alt_bn128_GT libff::alt_bn128_affine_reduced_pairing	(	const alt_bn128_G1 &	P,
		const alt_bn128_G2 &	Q )

◆ alt_bn128_ate_double_miller_loop()

alt_bn128_Fq12 libff::alt_bn128_ate_double_miller_loop	(	const alt_bn128_ate_G1_precomp &	prec_P1,
		const alt_bn128_ate_G2_precomp &	prec_Q1,
		const alt_bn128_ate_G1_precomp &	prec_P2,
		const alt_bn128_ate_G2_precomp &	prec_Q2 )

Definition at line 422 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_ate_double_miller_loop");
 
    alt_bn128_Fq12 f = alt_bn128_Fq12::one();
 
    bool found_one = false;
    size_t idx = 0;
 
    const bigint<alt_bn128_Fr::num_limbs> &loop_count = alt_bn128_ate_loop_count;
    for (long i = loop_count.max_bits(); i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           alt_bn128_param_p (skipping leading zeros) in MSB to LSB
           order */
 
        alt_bn128_ate_ell_coeffs c1 = prec_Q1.coeffs[idx];
        alt_bn128_ate_ell_coeffs c2 = prec_Q2.coeffs[idx];
        ++idx;
 
        f = f.squared();
 
        f = f.mul_by_024(c1.ell_0, prec_P1.PY * c1.ell_VW, prec_P1.PX * c1.ell_VV);
        f = f.mul_by_024(c2.ell_0, prec_P2.PY * c2.ell_VW, prec_P2.PX * c2.ell_VV);
 
        if (bit)
        {
            alt_bn128_ate_ell_coeffs c1 = prec_Q1.coeffs[idx];
            alt_bn128_ate_ell_coeffs c2 = prec_Q2.coeffs[idx];
            ++idx;
 
            f = f.mul_by_024(c1.ell_0, prec_P1.PY * c1.ell_VW, prec_P1.PX * c1.ell_VV);
            f = f.mul_by_024(c2.ell_0, prec_P2.PY * c2.ell_VW, prec_P2.PX * c2.ell_VV);
        }
    }
 
    if (alt_bn128_ate_is_loop_count_neg)
    {
        f = f.inverse();
    }
 
    alt_bn128_ate_ell_coeffs c1 = prec_Q1.coeffs[idx];
    alt_bn128_ate_ell_coeffs c2 = prec_Q2.coeffs[idx];
    ++idx;
    f = f.mul_by_024(c1.ell_0, prec_P1.PY * c1.ell_VW, prec_P1.PX * c1.ell_VV);
    f = f.mul_by_024(c2.ell_0, prec_P2.PY * c2.ell_VW, prec_P2.PX * c2.ell_VV);
 
    c1 = prec_Q1.coeffs[idx];
    c2 = prec_Q2.coeffs[idx];
    ++idx;
    f = f.mul_by_024(c1.ell_0, prec_P1.PY * c1.ell_VW, prec_P1.PX * c1.ell_VV);
    f = f.mul_by_024(c2.ell_0, prec_P2.PY * c2.ell_VW, prec_P2.PX * c2.ell_VV);
 
    leave_block("Call to alt_bn128_ate_double_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_ate_miller_loop()

alt_bn128_Fq12 libff::alt_bn128_ate_miller_loop	(	const alt_bn128_ate_G1_precomp &	prec_P,
		const alt_bn128_ate_G2_precomp &	prec_Q )

Definition at line 368 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_ate_miller_loop");
 
    alt_bn128_Fq12 f = alt_bn128_Fq12::one();
 
    bool found_one = false;
    size_t idx = 0;
 
    const bigint<alt_bn128_Fr::num_limbs> &loop_count = alt_bn128_ate_loop_count;
    alt_bn128_ate_ell_coeffs c;
 
    for (long i = loop_count.max_bits(); i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           alt_bn128_param_p (skipping leading zeros) in MSB to LSB
           order */
 
        c = prec_Q.coeffs[idx++];
        f = f.squared();
        f = f.mul_by_024(c.ell_0, prec_P.PY * c.ell_VW, prec_P.PX * c.ell_VV);
 
        if (bit)
        {
            c = prec_Q.coeffs[idx++];
            f = f.mul_by_024(c.ell_0, prec_P.PY * c.ell_VW, prec_P.PX * c.ell_VV);
        }
 
    }
 
    if (alt_bn128_ate_is_loop_count_neg)
    {
        f = f.inverse();
    }
 
    c = prec_Q.coeffs[idx++];
    f = f.mul_by_024(c.ell_0,prec_P.PY * c.ell_VW,prec_P.PX * c.ell_VV);
 
    c = prec_Q.coeffs[idx++];
    f = f.mul_by_024(c.ell_0,prec_P.PY * c.ell_VW,prec_P.PX * c.ell_VV);
 
    leave_block("Call to alt_bn128_ate_miller_loop");
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_ate_pairing()

alt_bn128_Fq12 libff::alt_bn128_ate_pairing	(	const alt_bn128_G1 &	P,
		const alt_bn128_G2 &	Q )

Definition at line 491 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_ate_pairing");
    alt_bn128_ate_G1_precomp prec_P = alt_bn128_ate_precompute_G1(P);
    alt_bn128_ate_G2_precomp prec_Q = alt_bn128_ate_precompute_G2(Q);
    alt_bn128_Fq12 result = alt_bn128_ate_miller_loop(prec_P, prec_Q);
    leave_block("Call to alt_bn128_ate_pairing");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_ate_precompute_G1()

alt_bn128_ate_G1_precomp libff::alt_bn128_ate_precompute_G1 ( const alt_bn128_G1 & P )

Definition at line 290 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_ate_precompute_G1");
 
    alt_bn128_G1 Pcopy = P;
    Pcopy.to_affine_coordinates();
 
    alt_bn128_ate_G1_precomp result;
    result.PX = Pcopy.X;
    result.PY = Pcopy.Y;
 
    leave_block("Call to alt_bn128_ate_precompute_G1");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_ate_precompute_G2()

alt_bn128_ate_G2_precomp libff::alt_bn128_ate_precompute_G2 ( const alt_bn128_G2 & Q )

Definition at line 305 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_ate_precompute_G2");
 
    alt_bn128_G2 Qcopy(Q);
    Qcopy.to_affine_coordinates();
 
    alt_bn128_Fq two_inv = (alt_bn128_Fq("2").inverse()); // could add to global params if needed
 
    alt_bn128_ate_G2_precomp result;
    result.QX = Qcopy.X;
    result.QY = Qcopy.Y;
 
    alt_bn128_G2 R;
    R.X = Qcopy.X;
    R.Y = Qcopy.Y;
    R.Z = alt_bn128_Fq2::one();
 
    const bigint<alt_bn128_Fr::num_limbs> &loop_count = alt_bn128_ate_loop_count;
    bool found_one = false;
    alt_bn128_ate_ell_coeffs c;
 
    for (long i = loop_count.max_bits(); i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        doubling_step_for_flipped_miller_loop(two_inv, R, c);
        result.coeffs.push_back(c);
 
        if (bit)
        {
            mixed_addition_step_for_flipped_miller_loop(Qcopy, R, c);
            result.coeffs.push_back(c);
        }
    }
 
    alt_bn128_G2 Q1 = Qcopy.mul_by_q();
    assert(Q1.Z == alt_bn128_Fq2::one());
    alt_bn128_G2 Q2 = Q1.mul_by_q();
    assert(Q2.Z == alt_bn128_Fq2::one());
 
    if (alt_bn128_ate_is_loop_count_neg)
    {
        R.Y = - R.Y;
    }
    Q2.Y = - Q2.Y;
 
    mixed_addition_step_for_flipped_miller_loop(Q1, R, c);
    result.coeffs.push_back(c);
 
    mixed_addition_step_for_flipped_miller_loop(Q2, R, c);
    result.coeffs.push_back(c);
 
    leave_block("Call to alt_bn128_ate_precompute_G2");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_ate_reduced_pairing()

alt_bn128_GT libff::alt_bn128_ate_reduced_pairing	(	const alt_bn128_G1 &	P,
		const alt_bn128_G2 &	Q )

Definition at line 501 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_ate_reduced_pairing");
    const alt_bn128_Fq12 f = alt_bn128_ate_pairing(P, Q);
    const alt_bn128_GT result = alt_bn128_final_exponentiation(f);
    leave_block("Call to alt_bn128_ate_reduced_pairing");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_double_miller_loop()

alt_bn128_Fq12 libff::alt_bn128_double_miller_loop	(	const alt_bn128_G1_precomp &	prec_P1,
		const alt_bn128_G2_precomp &	prec_Q1,
		const alt_bn128_G1_precomp &	prec_P2,
		const alt_bn128_G2_precomp &	prec_Q2 )

Definition at line 528 of file alt_bn128_pairing.cpp.

{
    return alt_bn128_ate_double_miller_loop(prec_P1, prec_Q1, prec_P2, prec_Q2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_exp_by_neg_z()

alt_bn128_Fq12 libff::alt_bn128_exp_by_neg_z ( const alt_bn128_Fq12 & elt )

Definition at line 137 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_exp_by_neg_z");
 
    alt_bn128_Fq12 result = elt.cyclotomic_exp(alt_bn128_final_exponent_z);
    if (!alt_bn128_final_exponent_is_z_neg)
    {
        result = result.unitary_inverse();
    }
 
    leave_block("Call to alt_bn128_exp_by_neg_z");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_final_exponentiation()

alt_bn128_GT libff::alt_bn128_final_exponentiation ( const alt_bn128_Fq12 & elt )

Definition at line 226 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_final_exponentiation");
    /* OLD naive version:
        alt_bn128_GT result = elt^alt_bn128_final_exponent;
    */
    alt_bn128_Fq12 A = alt_bn128_final_exponentiation_first_chunk(elt);
    alt_bn128_GT result = alt_bn128_final_exponentiation_last_chunk(A);
 
    leave_block("Call to alt_bn128_final_exponentiation");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_final_exponentiation_first_chunk()

alt_bn128_Fq12 libff::alt_bn128_final_exponentiation_first_chunk ( const alt_bn128_Fq12 & elt )

Definition at line 110 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_final_exponentiation_first_chunk");
 
    /*
      Computes result = elt^((q^6-1)*(q^2+1)).
      Follows, e.g., Beuchat et al page 9, by computing result as follows:
         elt^((q^6-1)*(q^2+1)) = (conj(elt) * elt^(-1))^(q^2+1)
      More precisely:
      A = conj(elt)
      B = elt.inverse()
      C = A * B
      D = C.Frobenius_map(2)
      result = D * C
    */
 
    const alt_bn128_Fq12 A = alt_bn128_Fq12(elt.c0,-elt.c1);
    const alt_bn128_Fq12 B = elt.inverse();
    const alt_bn128_Fq12 C = A * B;
    const alt_bn128_Fq12 D = C.Frobenius_map(2);
    const alt_bn128_Fq12 result = D * C;
 
    leave_block("Call to alt_bn128_final_exponentiation_first_chunk");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_final_exponentiation_last_chunk()

alt_bn128_Fq12 libff::alt_bn128_final_exponentiation_last_chunk ( const alt_bn128_Fq12 & elt )

Definition at line 152 of file alt_bn128_pairing.cpp.

{
    enter_block("Call to alt_bn128_final_exponentiation_last_chunk");
 
    /*
      Follows Laura Fuentes-Castaneda et al. "Faster hashing to G2"
      by computing:
 
      result = elt^(q^3 * (12*z^3 + 6z^2 + 4z - 1) +
                    q^2 * (12*z^3 + 6z^2 + 6z) +
                    q   * (12*z^3 + 6z^2 + 4z) +
                    1   * (12*z^3 + 12z^2 + 6z + 1))
      which equals
 
      result = elt^( 2z * ( 6z^2 + 3z + 1 ) * (q^4 - q^2 + 1)/r ).
 
      Using the following addition chain:
 
      A = exp_by_neg_z(elt)  // = elt^(-z)
      B = A^2                // = elt^(-2*z)
      C = B^2                // = elt^(-4*z)
      D = C * B              // = elt^(-6*z)
      E = exp_by_neg_z(D)    // = elt^(6*z^2)
      F = E^2                // = elt^(12*z^2)
      G = epx_by_neg_z(F)    // = elt^(-12*z^3)
      H = conj(D)            // = elt^(6*z)
      I = conj(G)            // = elt^(12*z^3)
      J = I * E              // = elt^(12*z^3 + 6*z^2)
      K = J * H              // = elt^(12*z^3 + 6*z^2 + 6*z)
      L = K * B              // = elt^(12*z^3 + 6*z^2 + 4*z)
      M = K * E              // = elt^(12*z^3 + 12*z^2 + 6*z)
      N = M * elt            // = elt^(12*z^3 + 12*z^2 + 6*z + 1)
      O = L.Frobenius_map(1) // = elt^(q*(12*z^3 + 6*z^2 + 4*z))
      P = O * N              // = elt^(q*(12*z^3 + 6*z^2 + 4*z) * (12*z^3 + 12*z^2 + 6*z + 1))
      Q = K.Frobenius_map(2) // = elt^(q^2 * (12*z^3 + 6*z^2 + 6*z))
      R = Q * P              // = elt^(q^2 * (12*z^3 + 6*z^2 + 6*z) + q*(12*z^3 + 6*z^2 + 4*z) * (12*z^3 + 12*z^2 + 6*z + 1))
      S = conj(elt)          // = elt^(-1)
      T = S * L              // = elt^(12*z^3 + 6*z^2 + 4*z - 1)
      U = T.Frobenius_map(3) // = elt^(q^3(12*z^3 + 6*z^2 + 4*z - 1))
      V = U * R              // = elt^(q^3(12*z^3 + 6*z^2 + 4*z - 1) + q^2 * (12*z^3 + 6*z^2 + 6*z) + q*(12*z^3 + 6*z^2 + 4*z) * (12*z^3 + 12*z^2 + 6*z + 1))
      result = V
 
    */
 
    const alt_bn128_Fq12 A = alt_bn128_exp_by_neg_z(elt);
    const alt_bn128_Fq12 B = A.cyclotomic_squared();
    const alt_bn128_Fq12 C = B.cyclotomic_squared();
    const alt_bn128_Fq12 D = C * B;
    const alt_bn128_Fq12 E = alt_bn128_exp_by_neg_z(D);
    const alt_bn128_Fq12 F = E.cyclotomic_squared();
    const alt_bn128_Fq12 G = alt_bn128_exp_by_neg_z(F);
    const alt_bn128_Fq12 H = D.unitary_inverse();
    const alt_bn128_Fq12 I = G.unitary_inverse();
    const alt_bn128_Fq12 J = I * E;
    const alt_bn128_Fq12 K = J * H;
    const alt_bn128_Fq12 L = K * B;
    const alt_bn128_Fq12 M = K * E;
    const alt_bn128_Fq12 N = M * elt;
    const alt_bn128_Fq12 O = L.Frobenius_map(1);
    const alt_bn128_Fq12 P = O * N;
    const alt_bn128_Fq12 Q = K.Frobenius_map(2);
    const alt_bn128_Fq12 R = Q * P;
    const alt_bn128_Fq12 S = elt.unitary_inverse();
    const alt_bn128_Fq12 T = S * L;
    const alt_bn128_Fq12 U = T.Frobenius_map(3);
    const alt_bn128_Fq12 V = U * R;
 
    const alt_bn128_Fq12 result = V;
 
    leave_block("Call to alt_bn128_final_exponentiation_last_chunk");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_miller_loop()

alt_bn128_Fq12 libff::alt_bn128_miller_loop	(	const alt_bn128_G1_precomp &	prec_P,
		const alt_bn128_G2_precomp &	prec_Q )

Definition at line 522 of file alt_bn128_pairing.cpp.

{
    return alt_bn128_ate_miller_loop(prec_P, prec_Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_pairing()

alt_bn128_Fq12 libff::alt_bn128_pairing	(	const alt_bn128_G1 &	P,
		const alt_bn128_G2 &	Q )

Definition at line 536 of file alt_bn128_pairing.cpp.

{
    return alt_bn128_ate_pairing(P, Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_precompute_G1()

alt_bn128_G1_precomp libff::alt_bn128_precompute_G1 ( const alt_bn128_G1 & P )

Definition at line 512 of file alt_bn128_pairing.cpp.

{
    return alt_bn128_ate_precompute_G1(P);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_precompute_G2()

alt_bn128_G2_precomp libff::alt_bn128_precompute_G2 ( const alt_bn128_G2 & Q )

Definition at line 517 of file alt_bn128_pairing.cpp.

{
    return alt_bn128_ate_precompute_G2(Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ alt_bn128_reduced_pairing()

alt_bn128_GT libff::alt_bn128_reduced_pairing	(	const alt_bn128_G1 &	P,
		const alt_bn128_G2 &	Q )

Definition at line 542 of file alt_bn128_pairing.cpp.

{
    return alt_bn128_ate_reduced_pairing(P, Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ batch_exp()

template<typename T , typename FieldT >

std::vector< T > libff::batch_exp	(	const size_t	scalar_size,
		const size_t	window,
		const window_table< T > &	table,
		const std::vector< FieldT > &	v )

◆ batch_exp_with_coeff()

template<typename T , typename FieldT >

std::vector< T > libff::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 )

◆ batch_invert()

template<typename FieldT >

void libff::batch_invert ( std::vector< FieldT > & vec )

Here is the caller graph for this function:

◆ batch_to_special()

template<typename T >

void libff::batch_to_special ( std::vector< T > & vec )

◆ bitreverse()

size_t libff::bitreverse	(	size_t	n,
		const size_t	l )

Definition at line 60 of file utils.cpp.

{
    size_t r = 0;
    for (size_t k = 0; k < l; ++k)
    {
        r = (r << 1) | (n & 1);
        n >>= 1;
    }
    return r;
}

◆ bn128_ate_miller_loop()

bn128_Fq12 libff::bn128_ate_miller_loop	(	const bn128_ate_G1_precomp &	prec_P,
		const bn128_ate_G2_precomp &	prec_Q )

Definition at line 190 of file bn128_pairing.cpp.

{
    bn128_Fq12 f;
    bn::components::millerLoop(f.elem, prec_Q.coeffs, prec_P.P);
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bn128_ate_precompute_G1()

bn128_ate_G1_precomp libff::bn128_ate_precompute_G1 ( const bn128_G1 & P )

Definition at line 164 of file bn128_pairing.cpp.

{
    enter_block("Call to bn128_ate_precompute_G1");
 
    bn128_ate_G1_precomp result;
    bn::Fp P_coord[3];
    P.fill_coord(P_coord);
    bn::ecop::NormalizeJac(result.P, P_coord);
 
    leave_block("Call to bn128_ate_precompute_G1");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bn128_ate_precompute_G2()

bn128_ate_G2_precomp libff::bn128_ate_precompute_G2 ( const bn128_G2 & Q )

Definition at line 177 of file bn128_pairing.cpp.

{
    enter_block("Call to bn128_ate_precompute_G2");
 
    bn128_ate_G2_precomp result;
    bn::Fp2 Q_coord[3];
    Q.fill_coord(Q_coord);
    bn::components::precomputeG2(result.coeffs, result.Q, Q_coord);
 
    leave_block("Call to bn128_ate_precompute_G2");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bn128_double_ate_miller_loop()

bn128_Fq12 libff::bn128_double_ate_miller_loop	(	const bn128_ate_G1_precomp &	prec_P1,
		const bn128_ate_G2_precomp &	prec_Q1,
		const bn128_ate_G1_precomp &	prec_P2,
		const bn128_ate_G2_precomp &	prec_Q2 )

Definition at line 198 of file bn128_pairing.cpp.

{
    bn128_Fq12 f;
    bn::components::millerLoop2(f.elem, prec_Q1.coeffs, prec_P1.P, prec_Q2.coeffs, prec_P2.P);
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bn128_final_exponentiation()

bn128_GT libff::bn128_final_exponentiation ( const bn128_Fq12 & elt )

Definition at line 208 of file bn128_pairing.cpp.

{
    enter_block("Call to bn128_final_exponentiation");
    bn128_GT eltcopy = elt;
    eltcopy.elem.final_exp();
    leave_block("Call to bn128_final_exponentiation");
    return eltcopy;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bn_batch_invert()

template<typename FieldT >

void libff::bn_batch_invert ( std::vector< FieldT > & vec )

Here is the caller graph for this function:

◆ clear_profiling_counters()

void libff::clear_profiling_counters ( )

Definition at line 98 of file profiling.cpp.

{
    invocation_counts.clear();
    last_times.clear();
    last_cpu_times.clear();
    cumulative_times.clear();
}

◆ consume_newline()

void libff::consume_newline ( std::istream & in )

inline

Here is the caller graph for this function:

◆ consume_OUTPUT_NEWLINE()

void libff::consume_OUTPUT_NEWLINE ( std::istream & in )

inline

Here is the caller graph for this function:

◆ consume_OUTPUT_SEPARATOR()

void libff::consume_OUTPUT_SEPARATOR ( std::istream & in )

inline

◆ convert_bit_vector_to_field_element()

template<typename FieldT >

FieldT libff::convert_bit_vector_to_field_element ( const bit_vector & v )

◆ convert_bit_vector_to_field_element_vector()

template<typename FieldT >

std::vector< FieldT > libff::convert_bit_vector_to_field_element_vector ( const bit_vector & v )

◆ convert_field_element_to_bit_vector() [1/2]

template<typename FieldT >

bit_vector libff::convert_field_element_to_bit_vector ( const FieldT & el )

◆ convert_field_element_to_bit_vector() [2/2]

template<typename FieldT >

bit_vector libff::convert_field_element_to_bit_vector	(	const FieldT &	el,
		const size_t	bitcount )

◆ convert_field_element_vector_to_bit_vector()

template<typename FieldT >

bit_vector libff::convert_field_element_vector_to_bit_vector ( const std::vector< FieldT > & v )

◆ deserialize_bit_vector()

void libff::deserialize_bit_vector	(	std::istream &	in,
		bit_vector &	v )

Definition at line 117 of file utils.cpp.

{
    size_t size;
    in >> size;
    v.resize(size);
    for (size_t i = 0; i < size; ++i)
    {
        bool b;
        in >> b;
        v[i] = b;
    }
}

◆ div_ceil()

long long libff::div_ceil	(	long long	x,
		long long	y )

Definition at line 84 of file utils.cpp.

{
    return (x + (y-1)) / y;
}

◆ doubling_step_for_flipped_miller_loop() [1/4]

void libff::doubling_step_for_flipped_miller_loop	(	const alt_bn128_Fq	two_inv,
		alt_bn128_G2 &	current,
		alt_bn128_ate_ell_coeffs &	c )

Definition at line 241 of file alt_bn128_pairing.cpp.

{
    const alt_bn128_Fq2 X = current.X, Y = current.Y, Z = current.Z;
 
    const alt_bn128_Fq2 A = two_inv * (X * Y);                     // A = X1 * Y1 / 2
    const alt_bn128_Fq2 B = Y.squared();                           // B = Y1^2
    const alt_bn128_Fq2 C = Z.squared();                           // C = Z1^2
    const alt_bn128_Fq2 D = C+C+C;                                 // D = 3 * C
    const alt_bn128_Fq2 E = alt_bn128_twist_coeff_b * D;             // E = twist_b * D
    const alt_bn128_Fq2 F = E+E+E;                                 // F = 3 * E
    const alt_bn128_Fq2 G = two_inv * (B+F);                       // G = (B+F)/2
    const alt_bn128_Fq2 H = (Y+Z).squared() - (B+C);               // H = (Y1+Z1)^2-(B+C)
    const alt_bn128_Fq2 I = E-B;                                   // I = E-B
    const alt_bn128_Fq2 J = X.squared();                           // J = X1^2
    const alt_bn128_Fq2 E_squared = E.squared();                   // E_squared = E^2
 
    current.X = A * (B-F);                                       // X3 = A * (B-F)
    current.Y = G.squared() - (E_squared+E_squared+E_squared);   // Y3 = G^2 - 3*E^2
    current.Z = B * H;                                           // Z3 = B * H
    c.ell_0 = alt_bn128_twist * I;                                 // ell_0 = xi * I
    c.ell_VW = -H;                                               // ell_VW = - H (later: * yP)
    c.ell_VV = J+J+J;                                            // ell_VV = 3*J (later: * xP)
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ doubling_step_for_flipped_miller_loop() [2/4]

void libff::doubling_step_for_flipped_miller_loop	(	extended_edwards_G2_projective &	current,
		edwards_Fq3_conic_coefficients &	cc )

Definition at line 471 of file edwards_pairing.cpp.

{
    const edwards_Fq3 &X = current.X, &Y = current.Y, &Z = current.Z, &T = current.T;
    const edwards_Fq3 A = X.squared();     // A    = X1^2
    const edwards_Fq3 B = Y.squared();     // B    = Y1^2
    const edwards_Fq3 C = Z.squared();     // C    = Z1^2
    const edwards_Fq3 D = (X+Y).squared(); // D    = (X1+Y1)^2
    const edwards_Fq3 E = (Y+Z).squared(); // E    = (Y1+Z1)^2
    const edwards_Fq3 F = D-(A+B);         // F    = D-(A+B)
    const edwards_Fq3 G = E-(B+C);         // G    = E-(B+C)
    const edwards_Fq3 H = edwards_G2::mul_by_a(A); // edwards_param_twist_coeff_a is 1 * X for us
                                   // H    = twisted_a * A
    const edwards_Fq3 I = H+B;             // I    = H+B
    const edwards_Fq3 J = C-I;             // J    = C-I
    const edwards_Fq3 K = J+C;             // K    = J+C
 
    cc.c_ZZ = Y*(T-X);            // c_ZZ = 2*Y1*(T1-X1)
    cc.c_ZZ = cc.c_ZZ + cc.c_ZZ;
 
    // c_XY = 2*(C-edwards_a * A * delta_3-B)+G (edwards_a = 1 for us)
    cc.c_XY = C - edwards_G2::mul_by_a(A) - B; // edwards_param_twist_coeff_a is 1 * X for us
    cc.c_XY = cc.c_XY + cc.c_XY + G;
 
    // c_XZ = 2*(edwards_a*X1*T1*delta_3-B) (edwards_a = 1 for us)
    cc.c_XZ = edwards_G2::mul_by_a(X * T) - B; // edwards_param_twist_coeff_a is 1 * X for us
    cc.c_XZ = cc.c_XZ + cc.c_XZ;
 
    current.X = F*K;              // X3 = F*K
    current.Y = I*(B-H);          // Y3 = I*(B-H)
    current.Z = I*K;              // Z3 = I*K
    current.T = F*(B-H);          // T3 = F*(B-H)
#ifdef DEBUG
    current.test_invariant();
#endif
}

Here is the call graph for this function:

◆ doubling_step_for_flipped_miller_loop() [3/4]

void libff::doubling_step_for_flipped_miller_loop	(	extended_mnt4_G2_projective &	current,
		mnt4_ate_dbl_coeffs &	dc )

Definition at line 410 of file mnt4_pairing.cpp.

{
    const mnt4_Fq2 X = current.X, Y = current.Y, Z = current.Z, T = current.T;
 
    const mnt4_Fq2 A = T.squared(); // A = T1^2
    const mnt4_Fq2 B = X.squared(); // B = X1^2
    const mnt4_Fq2 C = Y.squared(); // C = Y1^2
    const mnt4_Fq2 D = C.squared(); // D = C^2
    const mnt4_Fq2 E = (X+C).squared() - B - D; // E = (X1+C)^2-B-D
    const mnt4_Fq2 F = (B+B+B) + mnt4_twist_coeff_a * A; // F = 3*B +  a  *A
    const mnt4_Fq2 G = F.squared(); // G = F^2
 
    current.X = -(E+E+E+E) + G; // X3 = -4*E+G
    current.Y = -mnt4_Fq("8")*D + F*(E+E-current.X); // Y3 = -8*D+F*(2*E-X3)
    current.Z = (Y+Z).squared() - C - Z.squared(); // Z3 = (Y1+Z1)^2-C-Z1^2
    current.T = current.Z.squared(); // T3 = Z3^2
 
    dc.c_H = (current.Z + T).squared() - current.T - A; // H = (Z3+T1)^2-T3-A
    dc.c_4C = C+C+C+C; // fourC = 4*C
    dc.c_J = (F+T).squared() - G - A; // J = (F+T1)^2-G-A
    dc.c_L = (F+X).squared() - G - B; // L = (F+X1)^2-G-B
 
#ifdef DEBUG
    current.test_invariant();
#endif
}

Here is the call graph for this function:

◆ doubling_step_for_flipped_miller_loop() [4/4]

void libff::doubling_step_for_flipped_miller_loop	(	extended_mnt6_G2_projective &	current,
		mnt6_ate_dbl_coeffs &	dc )

Definition at line 416 of file mnt6_pairing.cpp.

{
    const mnt6_Fq3 X = current.X, Y = current.Y, Z = current.Z, T = current.T;
 
    const mnt6_Fq3 A = T.squared(); // A = T1^2
    const mnt6_Fq3 B = X.squared(); // B = X1^2
    const mnt6_Fq3 C = Y.squared(); // C = Y1^2
    const mnt6_Fq3 D = C.squared(); // D = C^2
    const mnt6_Fq3 E = (X+C).squared() - B - D; // E = (X1+C)^2-B-D
    const mnt6_Fq3 F = (B+B+B) + mnt6_twist_coeff_a * A; // F = 3*B +  a  *A
    const mnt6_Fq3 G = F.squared(); // G = F^2
 
    current.X = -(E+E+E+E) + G; // X3 = -4*E+G
    current.Y = -mnt6_Fq("8")*D + F*(E+E-current.X); // Y3 = -8*D+F*(2*E-X3)
    current.Z = (Y+Z).squared() - C - Z.squared(); // Z3 = (Y1+Z1)^2-C-Z1^2
    current.T = current.Z.squared(); // T3 = Z3^2
 
    dc.c_H = (current.Z + T).squared() - current.T - A; // H = (Z3+T1)^2-T3-A
    dc.c_4C = C+C+C+C; // fourC = 4*C
    dc.c_J = (F+T).squared() - G - A; // J = (F+T1)^2-G-A
    dc.c_L = (F+X).squared() - G - B; // L = (F+X1)^2-G-B
 
#ifdef DEBUG
    current.test_invariant();
#endif
}

Here is the call graph for this function:

◆ doubling_step_for_miller_loop()

void libff::doubling_step_for_miller_loop	(	extended_edwards_G1_projective &	current,
		edwards_Fq_conic_coefficients &	cc )

Definition at line 253 of file edwards_pairing.cpp.

{
    const edwards_Fq &X = current.X, &Y = current.Y, &Z = current.Z, &T = current.T;
    const edwards_Fq A = X.squared();     // A    = X1^2
    const edwards_Fq B = Y.squared();     // B    = Y1^2
    const edwards_Fq C = Z.squared();     // C    = Z1^2
    const edwards_Fq D = (X+Y).squared(); // D    = (X1+Y1)^2
    const edwards_Fq E = (Y+Z).squared(); // E    = (Y1+Z1)^2
    const edwards_Fq F = D-(A+B);         // F    = D-(A+B)
    const edwards_Fq G = E-(B+C);         // G    = E-(B+C)
    const edwards_Fq &H = A;              // H    = A (edwards_a=1)
    const edwards_Fq I = H+B;             // I    = H+B
    const edwards_Fq J = C-I;             // J    = C-I
    const edwards_Fq K = J+C;             // K    = J+C
 
    cc.c_ZZ = Y*(T-X);            // c_ZZ = 2*Y1*(T1-X1)
    cc.c_ZZ = cc.c_ZZ + cc.c_ZZ;
 
    cc.c_XY = J+J+G;              // c_XY = 2*J+G
    cc.c_XZ = X*T-B;              // c_XZ = 2*(X1*T1-B) (edwards_a=1)
    cc.c_XZ = cc.c_XZ + cc.c_XZ;
 
    current.X = F*K;              // X3 = F*K
    current.Y = I*(B-H);          // Y3 = I*(B-H)
    current.Z = I*K;              // Z3 = I*K
    current.T = F*(B-H);          // T3 = F*(B-H)
 
#ifdef DEBUG
    current.test_invariant();
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_ate_double_miller_loop()

edwards_Fq6 libff::edwards_ate_double_miller_loop	(	const edwards_ate_G1_precomp &	prec_P1,
		const edwards_ate_G2_precomp &	prec_Q1,
		const edwards_ate_G1_precomp &	prec_P2,
		const edwards_ate_G2_precomp &	prec_Q2 )

Definition at line 669 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_ate_double_miller_loop");
    const bigint<edwards_Fr::num_limbs> &loop_count = edwards_ate_loop_count;
 
    edwards_Fq6 f = edwards_Fq6::one();
 
    bool found_one = false;
    size_t idx = 0;
    for (long i = loop_count.max_bits()-1; i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           edwards_param_p (skipping leading zeros) in MSB to LSB
           order */
        edwards_Fq3_conic_coefficients cc1 = prec_Q1[idx];
        edwards_Fq3_conic_coefficients cc2 = prec_Q2[idx];
        ++idx;
 
        edwards_Fq6 g_RR_at_P1 = edwards_Fq6(prec_P1.P_XY * cc1.c_XY + prec_P1.P_XZ * cc1.c_XZ,
                                             prec_P1.P_ZZplusYZ * cc1.c_ZZ);
 
        edwards_Fq6 g_RR_at_P2 = edwards_Fq6(prec_P2.P_XY * cc2.c_XY + prec_P2.P_XZ * cc2.c_XZ,
                                             prec_P2.P_ZZplusYZ * cc2.c_ZZ);
        f = f.squared() * g_RR_at_P1 * g_RR_at_P2;
 
        if (bit)
        {
            cc1 = prec_Q1[idx];
            cc2 = prec_Q2[idx];
            ++idx;
            edwards_Fq6 g_RQ_at_P1 = edwards_Fq6(prec_P1.P_ZZplusYZ * cc1.c_ZZ,
                                                 prec_P1.P_XY * cc1.c_XY + prec_P1.P_XZ * cc1.c_XZ);
            edwards_Fq6 g_RQ_at_P2 = edwards_Fq6(prec_P2.P_ZZplusYZ * cc2.c_ZZ,
                                                 prec_P2.P_XY * cc2.c_XY + prec_P2.P_XZ * cc2.c_XZ);
            f = f * g_RQ_at_P1 * g_RQ_at_P2;
        }
    }
    leave_block("Call to edwards_ate_double_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_ate_miller_loop()

edwards_Fq6 libff::edwards_ate_miller_loop	(	const edwards_ate_G1_precomp &	prec_P,
		const edwards_ate_G2_precomp &	prec_Q )

Definition at line 628 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_ate_miller_loop");
    const bigint<edwards_Fr::num_limbs> &loop_count = edwards_ate_loop_count;
 
    edwards_Fq6 f = edwards_Fq6::one();
 
    bool found_one = false;
    size_t idx = 0;
    for (long i = loop_count.max_bits()-1; i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           edwards_param_p (skipping leading zeros) in MSB to LSB
           order */
        edwards_Fq3_conic_coefficients cc = prec_Q[idx++];
 
        edwards_Fq6 g_RR_at_P = edwards_Fq6(prec_P.P_XY * cc.c_XY + prec_P.P_XZ * cc.c_XZ,
                                            prec_P.P_ZZplusYZ * cc.c_ZZ);
        f = f.squared() * g_RR_at_P;
        if (bit)
        {
            cc = prec_Q[idx++];
            edwards_Fq6 g_RQ_at_P = edwards_Fq6(prec_P.P_ZZplusYZ * cc.c_ZZ,
                                                prec_P.P_XY * cc.c_XY + prec_P.P_XZ * cc.c_XZ);
            f = f * g_RQ_at_P;
        }
    }
    leave_block("Call to edwards_ate_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_ate_pairing()

edwards_Fq6 libff::edwards_ate_pairing	(	const edwards_G1 &	P,
		const edwards_G2 &	Q )

Definition at line 722 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_ate_pairing");
    edwards_ate_G1_precomp prec_P = edwards_ate_precompute_G1(P);
    edwards_ate_G2_precomp prec_Q = edwards_ate_precompute_G2(Q);
    edwards_Fq6 result = edwards_ate_miller_loop(prec_P, prec_Q);
    leave_block("Call to edwards_ate_pairing");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_ate_precompute_G1()

edwards_ate_G1_precomp libff::edwards_ate_precompute_G1 ( const edwards_G1 & P )

Definition at line 573 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_ate_precompute_G1");
    edwards_G1 Pcopy = P;
    Pcopy.to_affine_coordinates();
    edwards_ate_G1_precomp result;
    result.P_XY = Pcopy.X*Pcopy.Y;
    result.P_XZ = Pcopy.X; // P.X * P.Z but P.Z = 1
    result.P_ZZplusYZ = (edwards_Fq::one() + Pcopy.Y); // (P.Z + P.Y) * P.Z but P.Z = 1
    leave_block("Call to edwards_ate_precompute_G1");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_ate_precompute_G2()

edwards_ate_G2_precomp libff::edwards_ate_precompute_G2 ( const edwards_G2 & Q )

Definition at line 586 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_ate_precompute_G2");
    const bigint<edwards_Fr::num_limbs> &loop_count = edwards_ate_loop_count;
    edwards_ate_G2_precomp result;
 
    edwards_G2 Qcopy(Q);
    Qcopy.to_affine_coordinates();
 
    extended_edwards_G2_projective Q_ext;
    Q_ext.X = Qcopy.X;
    Q_ext.Y = Qcopy.Y;
    Q_ext.Z = Qcopy.Z;
    Q_ext.T = Qcopy.X*Qcopy.Y;
 
    extended_edwards_G2_projective R = Q_ext;
 
    bool found_one = false;
    for (long i = loop_count.max_bits()-1; i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        edwards_Fq3_conic_coefficients cc;
        doubling_step_for_flipped_miller_loop(R, cc);
        result.push_back(cc);
        if (bit)
        {
            mixed_addition_step_for_flipped_miller_loop(Q_ext, R, cc);
            result.push_back(cc);
        }
    }
 
    leave_block("Call to edwards_ate_precompute_G2");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_ate_reduced_pairing()

edwards_GT libff::edwards_ate_reduced_pairing	(	const edwards_G1 &	P,
		const edwards_G2 &	Q )

Definition at line 732 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_ate_reduced_pairing");
    const edwards_Fq6 f = edwards_ate_pairing(P, Q);
    const edwards_GT result = edwards_final_exponentiation(f);
    leave_block("Call to edwards_ate_reduced_pairing");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_double_miller_loop()

edwards_Fq6 libff::edwards_double_miller_loop	(	const edwards_G1_precomp &	prec_P1,
		const edwards_G2_precomp &	prec_Q1,
		const edwards_G1_precomp &	prec_P2,
		const edwards_G2_precomp &	prec_Q2 )

Definition at line 757 of file edwards_pairing.cpp.

{
    return edwards_ate_double_miller_loop(prec_P1, prec_Q1, prec_P2, prec_Q2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_final_exponentiation()

edwards_GT libff::edwards_final_exponentiation ( const edwards_Fq6 & elt )

Definition at line 207 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_final_exponentiation");
    const edwards_Fq6 elt_inv = elt.inverse();
    const edwards_Fq6 elt_to_first_chunk = edwards_final_exponentiation_first_chunk(elt, elt_inv);
    const edwards_Fq6 elt_inv_to_first_chunk = edwards_final_exponentiation_first_chunk(elt_inv, elt);
    edwards_GT result = edwards_final_exponentiation_last_chunk(elt_to_first_chunk, elt_inv_to_first_chunk);
    leave_block("Call to edwards_final_exponentiation");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_final_exponentiation_first_chunk()

edwards_Fq6 libff::edwards_final_exponentiation_first_chunk	(	const edwards_Fq6 &	elt,
		const edwards_Fq6 &	elt_inv )

Definition at line 189 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_final_exponentiation_first_chunk");
 
    /* (q^3-1)*(q+1) */
 
    /* elt_q3 = elt^(q^3) */
    const edwards_Fq6 elt_q3 = elt.Frobenius_map(3);
    /* elt_q3_over_elt = elt^(q^3-1) */
    const edwards_Fq6 elt_q3_over_elt = elt_q3 * elt_inv;
    /* alpha = elt^((q^3-1) * q) */
    const edwards_Fq6 alpha = elt_q3_over_elt.Frobenius_map(1);
    /* beta = elt^((q^3-1)*(q+1) */
    const edwards_Fq6 beta = alpha * elt_q3_over_elt;
    leave_block("Call to edwards_final_exponentiation_first_chunk");
    return beta;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_final_exponentiation_last_chunk()

edwards_Fq6 libff::edwards_final_exponentiation_last_chunk	(	const edwards_Fq6 &	elt,
		const edwards_Fq6 &	elt_inv )

Definition at line 171 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_final_exponentiation_last_chunk");
    const edwards_Fq6 elt_q = elt.Frobenius_map(1);
    edwards_Fq6 w1_part = elt_q.cyclotomic_exp(edwards_final_exponent_last_chunk_w1);
    edwards_Fq6 w0_part;
    if (edwards_final_exponent_last_chunk_is_w0_neg)
    {
        w0_part = elt_inv.cyclotomic_exp(edwards_final_exponent_last_chunk_abs_of_w0);
    } else {
        w0_part = elt.cyclotomic_exp(edwards_final_exponent_last_chunk_abs_of_w0);
    }
    edwards_Fq6 result = w1_part * w0_part;
    leave_block("Call to edwards_final_exponentiation_last_chunk");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_miller_loop()

edwards_Fq6 libff::edwards_miller_loop	(	const edwards_G1_precomp &	prec_P,
		const edwards_G2_precomp &	prec_Q )

Definition at line 751 of file edwards_pairing.cpp.

{
    return edwards_ate_miller_loop(prec_P, prec_Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_pairing()

edwards_Fq6 libff::edwards_pairing	(	const edwards_G1 &	P,
		const edwards_G2 &	Q )

Definition at line 765 of file edwards_pairing.cpp.

{
    return edwards_ate_pairing(P, Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_precompute_G1()

edwards_G1_precomp libff::edwards_precompute_G1 ( const edwards_G1 & P )

Definition at line 741 of file edwards_pairing.cpp.

{
    return edwards_ate_precompute_G1(P);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_precompute_G2()

edwards_G2_precomp libff::edwards_precompute_G2 ( const edwards_G2 & Q )

Definition at line 746 of file edwards_pairing.cpp.

{
    return edwards_ate_precompute_G2(Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_reduced_pairing()

edwards_GT libff::edwards_reduced_pairing	(	const edwards_G1 &	P,
		const edwards_G2 &	Q )

Definition at line 771 of file edwards_pairing.cpp.

{
    return edwards_ate_reduced_pairing(P, Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_tate_miller_loop()

edwards_Fq6 libff::edwards_tate_miller_loop	(	const edwards_tate_G1_precomp &	prec_P,
		const edwards_tate_G2_precomp &	prec_Q )

Definition at line 391 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_tate_miller_loop");
 
    edwards_Fq6 f = edwards_Fq6::one();
 
    bool found_one = false;
    size_t idx = 0;
    for (long i = edwards_modulus_r.max_bits()-1; i >= 0; --i)
    {
        const bool bit = edwards_modulus_r.test_bit(i);
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           edwards_modulus_r (skipping leading zeros) in MSB to LSB
           order */
        edwards_Fq_conic_coefficients cc = prec_P[idx++];
        edwards_Fq6 g_RR_at_Q = edwards_Fq6(edwards_Fq3(cc.c_XZ, edwards_Fq(0l), edwards_Fq(0l)) + cc.c_XY * prec_Q.y0,
                                            cc.c_ZZ * prec_Q.eta);
        f = f.squared() * g_RR_at_Q;
        if (bit)
        {
            cc = prec_P[idx++];
 
            edwards_Fq6 g_RP_at_Q = edwards_Fq6(edwards_Fq3(cc.c_XZ, edwards_Fq(0l), edwards_Fq(0l)) + cc.c_XY * prec_Q.y0,
                                                cc.c_ZZ * prec_Q.eta);
            f = f * g_RP_at_Q;
        }
    }
    leave_block("Call to edwards_tate_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_tate_pairing()

edwards_Fq6 libff::edwards_tate_pairing	(	const edwards_G1 &	P,
		const edwards_G2 &	Q )

Definition at line 431 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_tate_pairing");
    edwards_tate_G1_precomp prec_P = edwards_tate_precompute_G1(P);
    edwards_tate_G2_precomp prec_Q = edwards_tate_precompute_G2(Q);
    edwards_Fq6 result = edwards_tate_miller_loop(prec_P, prec_Q);
    leave_block("Call to edwards_tate_pairing");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_tate_precompute_G1()

edwards_tate_G1_precomp libff::edwards_tate_precompute_G1 ( const edwards_G1 & P )

Definition at line 346 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_tate_precompute_G1");
    edwards_tate_G1_precomp result;
 
    edwards_G1 Pcopy = P;
    Pcopy.to_affine_coordinates();
 
    extended_edwards_G1_projective P_ext;
    P_ext.X = Pcopy.X;
    P_ext.Y = Pcopy.Y;
    P_ext.Z = Pcopy.Z;
    P_ext.T = Pcopy.X*Pcopy.Y;
 
    extended_edwards_G1_projective R = P_ext;
 
    bool found_one = false;
    for (long i = edwards_modulus_r.max_bits(); i >= 0; --i)
    {
        const bool bit = edwards_modulus_r.test_bit(i);
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           edwards_modulus_r (skipping leading zeros) in MSB to LSB
           order */
        edwards_Fq_conic_coefficients cc;
        doubling_step_for_miller_loop(R, cc);
        result.push_back(cc);
 
        if (bit)
        {
            mixed_addition_step_for_miller_loop(P_ext, R, cc);
            result.push_back(cc);
        }
    }
 
    leave_block("Call to edwards_tate_precompute_G1");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_tate_precompute_G2()

edwards_tate_G2_precomp libff::edwards_tate_precompute_G2 ( const edwards_G2 & Q )

Definition at line 219 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_tate_precompute_G2");
    edwards_G2 Qcopy = Q;
    Qcopy.to_affine_coordinates();
    edwards_tate_G2_precomp result;
    result.y0 = Qcopy.Y * Qcopy.Z.inverse(); // Y/Z
    result.eta = (Qcopy.Z+Qcopy.Y) * edwards_Fq6::mul_by_non_residue(Qcopy.X).inverse(); // (Z+Y)/(nqr*X)
    leave_block("Call to edwards_tate_precompute_G2");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ edwards_tate_reduced_pairing()

edwards_GT libff::edwards_tate_reduced_pairing	(	const edwards_G1 &	P,
		const edwards_G2 &	Q )

Definition at line 441 of file edwards_pairing.cpp.

{
    enter_block("Call to edwards_tate_reduced_pairing");
    const edwards_Fq6 f = edwards_tate_pairing(P, Q);
    const edwards_GT result = edwards_final_exponentiation(f);
    leave_block("Call to edwards_tate_reduce_pairing");
    return result;
}

Here is the call graph for this function:

◆ enter_block()

void libff::enter_block	(	const std::string &	msg,
		const bool	indent )

Definition at line 245 of file profiling.cpp.

{
    if (inhibit_profiling_counters)
    {
        return;
    }
 
    block_names.emplace_back(msg);
    long long t = get_nsec_time();
    enter_times[msg] = t;
    long long cpu_t = get_nsec_cpu_time();
    enter_cpu_times[msg] = cpu_t;
 
    if (inhibit_profiling_info)
    {
        return;
    }
 
#ifdef MULTICORE
#pragma omp critical
#endif
    {
        op_profiling_enter(msg);
 
        print_indent();
        printf("(enter) %-35s\t", msg.c_str());
        print_times_from_last_and_start(t, t, cpu_t, cpu_t);
        printf("\n");
        fflush(stdout);
 
        if (indent)
        {
            ++indentation;
        }
    }
}

Here is the call graph for this function:

◆ exp2()

size_t libff::exp2 ( size_t k )

inline

Definition at line 28 of file utils.hpp.

28{ return size_t(1) << k; }

◆ find_wnaf()

template<mp_size_t n>

std::vector< long > libff::find_wnaf	(	const size_t	window_size,
		const bigint< n > &	scalar )

Find the wNAF representation of the given scalar relative to the given window size.

Here is the caller graph for this function:

◆ fixed_window_wnaf_exp()

template<typename T , mp_size_t n>

T libff::fixed_window_wnaf_exp	(	const size_t	window_size,
		const T &	base,
		const bigint< n > &	scalar )

In additive notation, use wNAF exponentiation (with the given window size) to compute scalar * base.

◆ FORMAT()

std::string libff::FORMAT	(	const std::string &	prefix,
		const char *	format,
			... )

Definition at line 96 of file utils.cpp.

{
    const static size_t MAX_FMT = 256;
    char buf[MAX_FMT];
    va_list args;
    va_start(args, format);
    vsnprintf(buf, MAX_FMT, format, args);
    va_end(args);
 
    return prefix + std::string(buf);
}

◆ from_twos_complement()

int libff::from_twos_complement	(	size_t	i,
		size_t	w )

Definition at line 54 of file utils.cpp.

{
    assert(i < (1ul<<w));
    return (i < (1ul<<(w-1))) ? i : i - (1ul<<w);
}

◆ full_addition_step_for_flipped_miller_loop()

void libff::full_addition_step_for_flipped_miller_loop	(	const extended_edwards_G2_projective &	base,
		extended_edwards_G2_projective &	current,
		edwards_Fq3_conic_coefficients &	cc )

Definition at line 508 of file edwards_pairing.cpp.

{
    const edwards_Fq3 &X1 = current.X, &Y1 = current.Y, &Z1 = current.Z, &T1 = current.T;
    const edwards_Fq3 &X2 = base.X, &Y2 =  base.Y, &Z2 = base.Z, &T2 = base.T;
 
    const edwards_Fq3 A = X1*X2;               // A    = X1*X2
    const edwards_Fq3 B = Y1*Y2;               // B    = Y1*Y2
    const edwards_Fq3 C = Z1*T2;               // C    = Z1*T2
    const edwards_Fq3 D = T1*Z2;               // D    = T1*Z2
    const edwards_Fq3 E = D+C;                 // E    = D+C
    const edwards_Fq3 F = (X1-Y1)*(X2+Y2)+B-A; // F    = (X1-Y1)*(X2+Y2)+B-A
    // G = B + twisted_edwards_a * A
    const edwards_Fq3 G = B + edwards_G2::mul_by_a(A); // edwards_param_twist_coeff_a is 1*X for us
    const edwards_Fq3 H = D-C;                 // H    = D-C
    const edwards_Fq3 I = T1*T2;               // I    = T1*T2
 
    // c_ZZ = delta_3* ((T1-X1)*(T2+X2)-I+A)
    cc.c_ZZ = edwards_G2::mul_by_a((T1-X1)*(T2+X2)-I+A); // edwards_param_twist_coeff_a is 1*X for us
 
    cc.c_XY = X1*Z2-X2*Z1+F;          // c_XY = X1*Z2-X2*Z1+F
    cc.c_XZ = (Y1-T1)*(Y2+T2)-B+I-H;  // c_XZ = (Y1-T1)*(Y2+T2)-B+I-H
    current.X = E*F;                  // X3   = E*F
    current.Y = G*H;                  // Y3   = G*H
    current.Z = F*G;                  // Z3   = F*G
    current.T = E*H;                  // T3   = E*H
 
#ifdef DEBUG
    current.test_invariant();
#endif
}

Here is the call graph for this function:

◆ full_addition_step_for_miller_loop()

void libff::full_addition_step_for_miller_loop	(	const extended_edwards_G1_projective &	base,
		extended_edwards_G1_projective &	current,
		edwards_Fq_conic_coefficients &	cc )

Definition at line 286 of file edwards_pairing.cpp.

{
    const edwards_Fq &X1 = current.X, &Y1 = current.Y, &Z1 = current.Z, &T1 = current.T;
    const edwards_Fq &X2 = base.X, &Y2 =  base.Y, &Z2 = base.Z, &T2 = base.T;
 
    const edwards_Fq A = X1*X2;               // A    = X1*X2
    const edwards_Fq B = Y1*Y2;               // B    = Y1*Y2
    const edwards_Fq C = Z1*T2;               // C    = Z1*T2
    const edwards_Fq D = T1*Z2;               // D    = T1*Z2
    const edwards_Fq E = D+C;                 // E    = D+C
    const edwards_Fq F = (X1-Y1)*(X2+Y2)+B-A; // F    = (X1-Y1)*(X2+Y2)+B-A
    const edwards_Fq G = B + A;               // G    = B + A (edwards_a=1)
    const edwards_Fq H = D-C;                 // H    = D-C
    const edwards_Fq I = T1*T2;               // I    = T1*T2
 
    cc.c_ZZ = (T1-X1)*(T2+X2)-I+A;    // c_ZZ = (T1-X1)*(T2+X2)-I+A
    cc.c_XY = X1*Z2-X2*Z1+F;          // c_XY = X1*Z2-X2*Z1+F
    cc.c_XZ = (Y1-T1)*(Y2+T2)-B+I-H;  // c_XZ = (Y1-T1)*(Y2+T2)-B+I-H
    current.X = E*F;                  // X3   = E*F
    current.Y = G*H;                  // Y3   = G*H
    current.Z = F*G;                  // Z3   = F*G
    current.T = E*H;                  // T3   = E*H
 
#ifdef DEBUG
    current.test_invariant();
#endif
}

◆ get_exp_window_size()

template<typename T >

size_t libff::get_exp_window_size ( const size_t num_scalars )

Compute window size for the given number of scalars.

◆ get_nsec_cpu_time()

long long libff::get_nsec_cpu_time ( )

Definition at line 39 of file profiling.cpp.

{
#if _MSC_VER
    return 0;
#else
    ::timespec ts;
    if ( ::clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts) )
        throw ::std::runtime_error("clock_gettime(CLOCK_PROCESS_CPUTIME_ID) failed");
        // If we expected this to work, don't silently ignore failures, because that would hide the problem and incur an unnecessarily system-call overhead. So if we ever observe this exception, we should probably add a suitable #ifdef .
        //TODO: clock_gettime(CLOCK_PROCESS_CPUTIME_ID) is not supported by native Windows. What about Cygwin? Should we #ifdef on CLOCK_PROCESS_CPUTIME_ID or on __linux__?
    return ts.tv_sec * 1000000000ll + ts.tv_nsec;
#endif
}

Here is the caller graph for this function:

◆ get_nsec_time()

long long libff::get_nsec_time ( )

Definition at line 32 of file profiling.cpp.

{
    auto timepoint = std::chrono::high_resolution_clock::now();
    return std::chrono::duration_cast<std::chrono::nanoseconds>(timepoint.time_since_epoch()).count();
}

Here is the caller graph for this function:

◆ get_power_of_two()

size_t libff::get_power_of_two ( size_t n )

Definition at line 19 of file utils.cpp.

{
    n--;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    n++;
 
    return n;
}

◆ get_root_of_unity() [1/2]

template<typename FieldT >

std::enable_if< std::is_same< FieldT, Double >::value, FieldT >::type libff::get_root_of_unity ( const size_t n )

◆ get_root_of_unity() [2/2]

template<typename FieldT >

std::enable_if<!std::is_same< FieldT, Double >::value, FieldT >::type libff::get_root_of_unity ( const size_t n )

◆ get_window_table()

template<typename T >

window_table< T > libff::get_window_table	(	const size_t	scalar_size,
		const size_t	window,
		const T &	g )

Compute table of window sizes.

◆ init_alt_bn128_params()

void libff::init_alt_bn128_params ( )

Definition at line 31 of file alt_bn128_init.cpp.

{
    typedef bigint<alt_bn128_r_limbs> bigint_r;
    typedef bigint<alt_bn128_q_limbs> bigint_q;
 
    assert(sizeof(mp_limb_t) == 8 || sizeof(mp_limb_t) == 4); // Montgomery assumes this
 
    /* parameters for scalar field Fr */
 
    alt_bn128_modulus_r = bigint_r("21888242871839275222246405745257275088548364400416034343698204186575808495617");
    assert(alt_bn128_Fr::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        alt_bn128_Fr::Rsquared = bigint_r("944936681149208446651664254269745548490766851729442924617792859073125903783");
        alt_bn128_Fr::Rcubed = bigint_r("5866548545943845227489894872040244720403868105578784105281690076696998248512");
        alt_bn128_Fr::inv = 0xc2e1f593efffffff;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        alt_bn128_Fr::Rsquared = bigint_r("944936681149208446651664254269745548490766851729442924617792859073125903783");
        alt_bn128_Fr::Rcubed = bigint_r("5866548545943845227489894872040244720403868105578784105281690076696998248512");
        alt_bn128_Fr::inv = 0xefffffff;
    }
    alt_bn128_Fr::num_bits = 254;
    alt_bn128_Fr::euler = bigint_r("10944121435919637611123202872628637544274182200208017171849102093287904247808");
    alt_bn128_Fr::s = 28;
    alt_bn128_Fr::t = bigint_r("81540058820840996586704275553141814055101440848469862132140264610111");
    alt_bn128_Fr::t_minus_1_over_2 = bigint_r("40770029410420498293352137776570907027550720424234931066070132305055");
    alt_bn128_Fr::multiplicative_generator = alt_bn128_Fr("5");
    alt_bn128_Fr::root_of_unity = alt_bn128_Fr("19103219067921713944291392827692070036145651957329286315305642004821462161904");
    alt_bn128_Fr::nqr = alt_bn128_Fr("5");
    alt_bn128_Fr::nqr_to_t = alt_bn128_Fr("19103219067921713944291392827692070036145651957329286315305642004821462161904");
 
    /* parameters for base field Fq */
 
    alt_bn128_modulus_q = bigint_q("21888242871839275222246405745257275088696311157297823662689037894645226208583");
    assert(alt_bn128_Fq::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        alt_bn128_Fq::Rsquared = bigint_q("3096616502983703923843567936837374451735540968419076528771170197431451843209");
        alt_bn128_Fq::Rcubed = bigint_q("14921786541159648185948152738563080959093619838510245177710943249661917737183");
        alt_bn128_Fq::inv = 0x87d20782e4866389;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        alt_bn128_Fq::Rsquared = bigint_q("3096616502983703923843567936837374451735540968419076528771170197431451843209");
        alt_bn128_Fq::Rcubed = bigint_q("14921786541159648185948152738563080959093619838510245177710943249661917737183");
        alt_bn128_Fq::inv = 0xe4866389;
    }
    alt_bn128_Fq::num_bits = 254;
    alt_bn128_Fq::euler = bigint_q("10944121435919637611123202872628637544348155578648911831344518947322613104291");
    alt_bn128_Fq::s = 1;
    alt_bn128_Fq::t = bigint_q("10944121435919637611123202872628637544348155578648911831344518947322613104291");
    alt_bn128_Fq::t_minus_1_over_2 = bigint_q("5472060717959818805561601436314318772174077789324455915672259473661306552145");
    alt_bn128_Fq::multiplicative_generator = alt_bn128_Fq("3");
    alt_bn128_Fq::root_of_unity = alt_bn128_Fq("21888242871839275222246405745257275088696311157297823662689037894645226208582");
    alt_bn128_Fq::nqr = alt_bn128_Fq("3");
    alt_bn128_Fq::nqr_to_t = alt_bn128_Fq("21888242871839275222246405745257275088696311157297823662689037894645226208582");
 
    /* parameters for twist field Fq2 */
    alt_bn128_Fq2::euler = bigint<2*alt_bn128_q_limbs>("239547588008311421220994022608339370399626158265550411218223901127035046843189118723920525909718935985594116157406550130918127817069793474323196511433944");
    alt_bn128_Fq2::s = 4;
    alt_bn128_Fq2::t = bigint<2*alt_bn128_q_limbs>("29943448501038927652624252826042421299953269783193801402277987640879380855398639840490065738714866998199264519675818766364765977133724184290399563929243");
    alt_bn128_Fq2::t_minus_1_over_2 = bigint<2*alt_bn128_q_limbs>("14971724250519463826312126413021210649976634891596900701138993820439690427699319920245032869357433499099632259837909383182382988566862092145199781964621");
    alt_bn128_Fq2::non_residue = alt_bn128_Fq("21888242871839275222246405745257275088696311157297823662689037894645226208582");
    alt_bn128_Fq2::nqr = alt_bn128_Fq2(alt_bn128_Fq("2"),alt_bn128_Fq("1"));
    alt_bn128_Fq2::nqr_to_t = alt_bn128_Fq2(alt_bn128_Fq("5033503716262624267312492558379982687175200734934877598599011485707452665730"),alt_bn128_Fq("314498342015008975724433667930697407966947188435857772134235984660852259084"));
    alt_bn128_Fq2::Frobenius_coeffs_c1[0] = alt_bn128_Fq("1");
    alt_bn128_Fq2::Frobenius_coeffs_c1[1] = alt_bn128_Fq("21888242871839275222246405745257275088696311157297823662689037894645226208582");
 
    /* parameters for Fq6 */
    alt_bn128_Fq6::non_residue = alt_bn128_Fq2(alt_bn128_Fq("9"),alt_bn128_Fq("1"));
    alt_bn128_Fq6::Frobenius_coeffs_c1[0] = alt_bn128_Fq2(alt_bn128_Fq("1"),alt_bn128_Fq("0"));
    alt_bn128_Fq6::Frobenius_coeffs_c1[1] = alt_bn128_Fq2(alt_bn128_Fq("21575463638280843010398324269430826099269044274347216827212613867836435027261"),alt_bn128_Fq("10307601595873709700152284273816112264069230130616436755625194854815875713954"));
    alt_bn128_Fq6::Frobenius_coeffs_c1[2] = alt_bn128_Fq2(alt_bn128_Fq("21888242871839275220042445260109153167277707414472061641714758635765020556616"),alt_bn128_Fq("0"));
    alt_bn128_Fq6::Frobenius_coeffs_c1[3] = alt_bn128_Fq2(alt_bn128_Fq("3772000881919853776433695186713858239009073593817195771773381919316419345261"),alt_bn128_Fq("2236595495967245188281701248203181795121068902605861227855261137820944008926"));
    alt_bn128_Fq6::Frobenius_coeffs_c1[4] = alt_bn128_Fq2(alt_bn128_Fq("2203960485148121921418603742825762020974279258880205651966"),alt_bn128_Fq("0"));
    alt_bn128_Fq6::Frobenius_coeffs_c1[5] = alt_bn128_Fq2(alt_bn128_Fq("18429021223477853657660792034369865839114504446431234726392080002137598044644"),alt_bn128_Fq("9344045779998320333812420223237981029506012124075525679208581902008406485703"));
    alt_bn128_Fq6::Frobenius_coeffs_c2[0] = alt_bn128_Fq2(alt_bn128_Fq("1"),alt_bn128_Fq("0"));
    alt_bn128_Fq6::Frobenius_coeffs_c2[1] = alt_bn128_Fq2(alt_bn128_Fq("2581911344467009335267311115468803099551665605076196740867805258568234346338"),alt_bn128_Fq("19937756971775647987995932169929341994314640652964949448313374472400716661030"));
    alt_bn128_Fq6::Frobenius_coeffs_c2[2] = alt_bn128_Fq2(alt_bn128_Fq("2203960485148121921418603742825762020974279258880205651966"),alt_bn128_Fq("0"));
    alt_bn128_Fq6::Frobenius_coeffs_c2[3] = alt_bn128_Fq2(alt_bn128_Fq("5324479202449903542726783395506214481928257762400643279780343368557297135718"),alt_bn128_Fq("16208900380737693084919495127334387981393726419856888799917914180988844123039"));
    alt_bn128_Fq6::Frobenius_coeffs_c2[4] = alt_bn128_Fq2(alt_bn128_Fq("21888242871839275220042445260109153167277707414472061641714758635765020556616"),alt_bn128_Fq("0"));
    alt_bn128_Fq6::Frobenius_coeffs_c2[5] = alt_bn128_Fq2(alt_bn128_Fq("13981852324922362344252311234282257507216387789820983642040889267519694726527"),alt_bn128_Fq("7629828391165209371577384193250820201684255241773809077146787135900891633097"));
 
    /* parameters for Fq12 */
 
    alt_bn128_Fq12::non_residue = alt_bn128_Fq2(alt_bn128_Fq("9"),alt_bn128_Fq("1"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[0]  = alt_bn128_Fq2(alt_bn128_Fq("1"),alt_bn128_Fq("0"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[1]  = alt_bn128_Fq2(alt_bn128_Fq("8376118865763821496583973867626364092589906065868298776909617916018768340080"),alt_bn128_Fq("16469823323077808223889137241176536799009286646108169935659301613961712198316"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[2]  = alt_bn128_Fq2(alt_bn128_Fq("21888242871839275220042445260109153167277707414472061641714758635765020556617"),alt_bn128_Fq("0"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[3]  = alt_bn128_Fq2(alt_bn128_Fq("11697423496358154304825782922584725312912383441159505038794027105778954184319"),alt_bn128_Fq("303847389135065887422783454877609941456349188919719272345083954437860409601"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[4]  = alt_bn128_Fq2(alt_bn128_Fq("21888242871839275220042445260109153167277707414472061641714758635765020556616"),alt_bn128_Fq("0"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[5]  = alt_bn128_Fq2(alt_bn128_Fq("3321304630594332808241809054958361220322477375291206261884409189760185844239"),alt_bn128_Fq("5722266937896532885780051958958348231143373700109372999374820235121374419868"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[6]  = alt_bn128_Fq2(alt_bn128_Fq("21888242871839275222246405745257275088696311157297823662689037894645226208582"),alt_bn128_Fq("0"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[7]  = alt_bn128_Fq2(alt_bn128_Fq("13512124006075453725662431877630910996106405091429524885779419978626457868503"),alt_bn128_Fq("5418419548761466998357268504080738289687024511189653727029736280683514010267"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[8]  = alt_bn128_Fq2(alt_bn128_Fq("2203960485148121921418603742825762020974279258880205651966"),alt_bn128_Fq("0"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[9]  = alt_bn128_Fq2(alt_bn128_Fq("10190819375481120917420622822672549775783927716138318623895010788866272024264"),alt_bn128_Fq("21584395482704209334823622290379665147239961968378104390343953940207365798982"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[10] = alt_bn128_Fq2(alt_bn128_Fq("2203960485148121921418603742825762020974279258880205651967"),alt_bn128_Fq("0"));
    alt_bn128_Fq12::Frobenius_coeffs_c1[11] = alt_bn128_Fq2(alt_bn128_Fq("18566938241244942414004596690298913868373833782006617400804628704885040364344"),alt_bn128_Fq("16165975933942742336466353786298926857552937457188450663314217659523851788715"));
 
    /* choice of short Weierstrass curve and its twist */
 
    alt_bn128_coeff_b = alt_bn128_Fq("3");
    alt_bn128_twist = alt_bn128_Fq2(alt_bn128_Fq("9"), alt_bn128_Fq("1"));
    alt_bn128_twist_coeff_b = alt_bn128_coeff_b * alt_bn128_twist.inverse();
    alt_bn128_twist_mul_by_b_c0 = alt_bn128_coeff_b * alt_bn128_Fq2::non_residue;
    alt_bn128_twist_mul_by_b_c1 = alt_bn128_coeff_b * alt_bn128_Fq2::non_residue;
    alt_bn128_twist_mul_by_q_X = alt_bn128_Fq2(alt_bn128_Fq("21575463638280843010398324269430826099269044274347216827212613867836435027261"),
                                           alt_bn128_Fq("10307601595873709700152284273816112264069230130616436755625194854815875713954"));
    alt_bn128_twist_mul_by_q_Y = alt_bn128_Fq2(alt_bn128_Fq("2821565182194536844548159561693502659359617185244120367078079554186484126554"),
                                           alt_bn128_Fq("3505843767911556378687030309984248845540243509899259641013678093033130930403"));
 
    /* choice of group G1 */
    alt_bn128_G1::G1_zero = alt_bn128_G1(alt_bn128_Fq::zero(),
                                     alt_bn128_Fq::one(),
                                     alt_bn128_Fq::zero());
    alt_bn128_G1::G1_one = alt_bn128_G1(alt_bn128_Fq("1"),
                                    alt_bn128_Fq("2"),
                                    alt_bn128_Fq::one());
    alt_bn128_G1::initialized = true;
 
    alt_bn128_G1::wnaf_window_table.resize(0);
    alt_bn128_G1::wnaf_window_table.push_back(11);
    alt_bn128_G1::wnaf_window_table.push_back(24);
    alt_bn128_G1::wnaf_window_table.push_back(60);
    alt_bn128_G1::wnaf_window_table.push_back(127);
 
    alt_bn128_G1::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 4.99]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [4.99, 10.99]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(5);
    // window 3 is unbeaten in [10.99, 32.29]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(11);
    // window 4 is unbeaten in [32.29, 55.23]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(32);
    // window 5 is unbeaten in [55.23, 162.03]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(55);
    // window 6 is unbeaten in [162.03, 360.15]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(162);
    // window 7 is unbeaten in [360.15, 815.44]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(360);
    // window 8 is unbeaten in [815.44, 2373.07]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(815);
    // window 9 is unbeaten in [2373.07, 6977.75]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(2373);
    // window 10 is unbeaten in [6977.75, 7122.23]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(6978);
    // window 11 is unbeaten in [7122.23, 57818.46]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(7122);
    // window 12 is never the best
    alt_bn128_G1::fixed_base_exp_window_table.push_back(0);
    // window 13 is unbeaten in [57818.46, 169679.14]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(57818);
    // window 14 is never the best
    alt_bn128_G1::fixed_base_exp_window_table.push_back(0);
    // window 15 is unbeaten in [169679.14, 439758.91]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(169679);
    // window 16 is unbeaten in [439758.91, 936073.41]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(439759);
    // window 17 is unbeaten in [936073.41, 4666554.74]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(936073);
    // window 18 is never the best
    alt_bn128_G1::fixed_base_exp_window_table.push_back(0);
    // window 19 is unbeaten in [4666554.74, 7580404.42]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(4666555);
    // window 20 is unbeaten in [7580404.42, 34552892.20]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(7580404);
    // window 21 is never the best
    alt_bn128_G1::fixed_base_exp_window_table.push_back(0);
    // window 22 is unbeaten in [34552892.20, inf]
    alt_bn128_G1::fixed_base_exp_window_table.push_back(34552892);
 
    /* choice of group G2 */
 
    alt_bn128_G2::G2_zero = alt_bn128_G2(alt_bn128_Fq2::zero(),
                                     alt_bn128_Fq2::one(),
                                     alt_bn128_Fq2::zero());
 
    alt_bn128_G2::G2_one = alt_bn128_G2(alt_bn128_Fq2(alt_bn128_Fq("10857046999023057135944570762232829481370756359578518086990519993285655852781"),
                                                alt_bn128_Fq("11559732032986387107991004021392285783925812861821192530917403151452391805634")),
                                    alt_bn128_Fq2(alt_bn128_Fq("8495653923123431417604973247489272438418190587263600148770280649306958101930"),
                                                alt_bn128_Fq("4082367875863433681332203403145435568316851327593401208105741076214120093531")),
                                    alt_bn128_Fq2::one());
    alt_bn128_G2::initialized = true;
 
    alt_bn128_G2::wnaf_window_table.resize(0);
    alt_bn128_G2::wnaf_window_table.push_back(5);
    alt_bn128_G2::wnaf_window_table.push_back(15);
    alt_bn128_G2::wnaf_window_table.push_back(39);
    alt_bn128_G2::wnaf_window_table.push_back(109);
 
    alt_bn128_G2::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 5.10]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [5.10, 10.43]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(5);
    // window 3 is unbeaten in [10.43, 25.28]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(10);
    // window 4 is unbeaten in [25.28, 59.00]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(25);
    // window 5 is unbeaten in [59.00, 154.03]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(59);
    // window 6 is unbeaten in [154.03, 334.25]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(154);
    // window 7 is unbeaten in [334.25, 742.58]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(334);
    // window 8 is unbeaten in [742.58, 2034.40]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(743);
    // window 9 is unbeaten in [2034.40, 4987.56]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(2034);
    // window 10 is unbeaten in [4987.56, 8888.27]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(4988);
    // window 11 is unbeaten in [8888.27, 26271.13]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(8888);
    // window 12 is unbeaten in [26271.13, 39768.20]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(26271);
    // window 13 is unbeaten in [39768.20, 106275.75]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(39768);
    // window 14 is unbeaten in [106275.75, 141703.40]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(106276);
    // window 15 is unbeaten in [141703.40, 462422.97]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(141703);
    // window 16 is unbeaten in [462422.97, 926871.84]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(462423);
    // window 17 is unbeaten in [926871.84, 4873049.17]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(926872);
    // window 18 is never the best
    alt_bn128_G2::fixed_base_exp_window_table.push_back(0);
    // window 19 is unbeaten in [4873049.17, 5706707.88]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(4873049);
    // window 20 is unbeaten in [5706707.88, 31673814.95]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(5706708);
    // window 21 is never the best
    alt_bn128_G2::fixed_base_exp_window_table.push_back(0);
    // window 22 is unbeaten in [31673814.95, inf]
    alt_bn128_G2::fixed_base_exp_window_table.push_back(31673815);
 
    /* pairing parameters */
 
    alt_bn128_ate_loop_count = bigint_q("29793968203157093288");
    alt_bn128_ate_is_loop_count_neg = false;
    alt_bn128_final_exponent = bigint<12*alt_bn128_q_limbs>("552484233613224096312617126783173147097382103762957654188882734314196910839907541213974502761540629817009608548654680343627701153829446747810907373256841551006201639677726139946029199968412598804882391702273019083653272047566316584365559776493027495458238373902875937659943504873220554161550525926302303331747463515644711876653177129578303191095900909191624817826566688241804408081892785725967931714097716709526092261278071952560171111444072049229123565057483750161460024353346284167282452756217662335528813519139808291170539072125381230815729071544861602750936964829313608137325426383735122175229541155376346436093930287402089517426973178917569713384748081827255472576937471496195752727188261435633271238710131736096299798168852925540549342330775279877006784354801422249722573783561685179618816480037695005515426162362431072245638324744480");
    alt_bn128_final_exponent_z = bigint_q("4965661367192848881");
    alt_bn128_final_exponent_is_z_neg = false;
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_bn128_params()

void libff::init_bn128_params ( )

Definition at line 28 of file bn128_init.cpp.

{
    bn::Param::init(); // init ate-pairing library
 
    typedef bigint<bn128_r_limbs> bigint_r;
    typedef bigint<bn128_q_limbs> bigint_q;
 
    assert(sizeof(mp_limb_t) == 8 || sizeof(mp_limb_t) == 4); // Montgomery assumes this
 
    /* parameters for scalar field Fr */
    bn128_modulus_r = bigint_r("21888242871839275222246405745257275088548364400416034343698204186575808495617");
    assert(bn128_Fr::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        bn128_Fr::Rsquared = bigint_r("944936681149208446651664254269745548490766851729442924617792859073125903783");
        bn128_Fr::Rcubed = bigint_r("5866548545943845227489894872040244720403868105578784105281690076696998248512");
        bn128_Fr::inv = 0xc2e1f593efffffff;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        bn128_Fr::Rsquared = bigint_r("944936681149208446651664254269745548490766851729442924617792859073125903783");
        bn128_Fr::Rcubed = bigint_r("5866548545943845227489894872040244720403868105578784105281690076696998248512");
        bn128_Fr::inv = 0xefffffff;
    }
    bn128_Fr::num_bits = 254;
    bn128_Fr::euler = bigint_r("10944121435919637611123202872628637544274182200208017171849102093287904247808");
    bn128_Fr::s = 28;
    bn128_Fr::t = bigint_r("81540058820840996586704275553141814055101440848469862132140264610111");
    bn128_Fr::t_minus_1_over_2 = bigint_r("40770029410420498293352137776570907027550720424234931066070132305055");
    bn128_Fr::multiplicative_generator = bn128_Fr("5");
    bn128_Fr::root_of_unity = bn128_Fr("19103219067921713944291392827692070036145651957329286315305642004821462161904");
    bn128_Fr::nqr = bn128_Fr("5");
    bn128_Fr::nqr_to_t = bn128_Fr("19103219067921713944291392827692070036145651957329286315305642004821462161904");
 
    /* parameters for base field Fq */
    bn128_modulus_q = bigint_q("21888242871839275222246405745257275088696311157297823662689037894645226208583");
    assert(bn128_Fq::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        bn128_Fq::Rsquared = bigint_q("3096616502983703923843567936837374451735540968419076528771170197431451843209");
        bn128_Fq::Rcubed = bigint_q("14921786541159648185948152738563080959093619838510245177710943249661917737183");
        bn128_Fq::inv = 0x87d20782e4866389;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        bn128_Fq::Rsquared = bigint_q("3096616502983703923843567936837374451735540968419076528771170197431451843209");
        bn128_Fq::Rcubed = bigint_q("14921786541159648185948152738563080959093619838510245177710943249661917737183");
        bn128_Fq::inv = 0xe4866389;
    }
    bn128_Fq::num_bits = 254;
    bn128_Fq::euler = bigint_q("10944121435919637611123202872628637544348155578648911831344518947322613104291");
    bn128_Fq::s = 1;
    bn128_Fq::t = bigint_q("10944121435919637611123202872628637544348155578648911831344518947322613104291");
    bn128_Fq::t_minus_1_over_2 = bigint_q("5472060717959818805561601436314318772174077789324455915672259473661306552145");
    bn128_Fq::multiplicative_generator = bn128_Fq("3");
    bn128_Fq::root_of_unity = bn128_Fq("21888242871839275222246405745257275088696311157297823662689037894645226208582");
    bn128_Fq::nqr = bn128_Fq("3");
    bn128_Fq::nqr_to_t = bn128_Fq("21888242871839275222246405745257275088696311157297823662689037894645226208582");
 
    /* additional parameters for square roots in Fq/Fq2 */
    bn128_coeff_b = bn::Fp(3);
    bn128_Fq_s = 1;
    bn128_Fq_nqr_to_t = bn::Fp("21888242871839275222246405745257275088696311157297823662689037894645226208582");
    bn128_Fq_t_minus_1_over_2 = mie::Vuint("5472060717959818805561601436314318772174077789324455915672259473661306552145");
 
    bn128_twist_coeff_b = bn::Fp2(bn::Fp("19485874751759354771024239261021720505790618469301721065564631296452457478373"),
                                  bn::Fp("266929791119991161246907387137283842545076965332900288569378510910307636690"));
    bn128_Fq2_s = 4;
    bn128_Fq2_nqr_to_t = bn::Fp2(bn::Fp("5033503716262624267312492558379982687175200734934877598599011485707452665730"),
                                 bn::Fp("314498342015008975724433667930697407966947188435857772134235984660852259084"));
    bn128_Fq2_t_minus_1_over_2 = mie::Vuint("14971724250519463826312126413021210649976634891596900701138993820439690427699319920245032869357433499099632259837909383182382988566862092145199781964621");
 
    /* choice of group G1 */
    bn128_G1::G1_zero.X = bn::Fp(1);
    bn128_G1::G1_zero.Y = bn::Fp(1);
    bn128_G1::G1_zero.Z = bn::Fp(0);
 
    bn128_G1::G1_one.X = bn::Fp(1);
    bn128_G1::G1_one.Y = bn::Fp(2);
    bn128_G1::G1_one.Z = bn::Fp(1);
 
    bn128_G1::initialized = true;
 
    bn128_G1::wnaf_window_table.resize(0);
    bn128_G1::wnaf_window_table.push_back(10);
    bn128_G1::wnaf_window_table.push_back(24);
    bn128_G1::wnaf_window_table.push_back(40);
    bn128_G1::wnaf_window_table.push_back(132);
 
    bn128_G1::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 4.24]
    bn128_G1::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [4.24, 10.43]
    bn128_G1::fixed_base_exp_window_table.push_back(4);
    // window 3 is unbeaten in [10.43, 24.88]
    bn128_G1::fixed_base_exp_window_table.push_back(10);
    // window 4 is unbeaten in [24.88, 62.10]
    bn128_G1::fixed_base_exp_window_table.push_back(25);
    // window 5 is unbeaten in [62.10, 157.80]
    bn128_G1::fixed_base_exp_window_table.push_back(62);
    // window 6 is unbeaten in [157.80, 362.05]
    bn128_G1::fixed_base_exp_window_table.push_back(158);
    // window 7 is unbeaten in [362.05, 806.67]
    bn128_G1::fixed_base_exp_window_table.push_back(362);
    // window 8 is unbeaten in [806.67, 2090.34]
    bn128_G1::fixed_base_exp_window_table.push_back(807);
    // window 9 is unbeaten in [2090.34, 4459.58]
    bn128_G1::fixed_base_exp_window_table.push_back(2090);
    // window 10 is unbeaten in [4459.58, 9280.12]
    bn128_G1::fixed_base_exp_window_table.push_back(4460);
    // window 11 is unbeaten in [9280.12, 43302.64]
    bn128_G1::fixed_base_exp_window_table.push_back(9280);
    // window 12 is unbeaten in [43302.64, 210998.73]
    bn128_G1::fixed_base_exp_window_table.push_back(43303);
    // window 13 is never the best
    bn128_G1::fixed_base_exp_window_table.push_back(0);
    // window 14 is never the best
    bn128_G1::fixed_base_exp_window_table.push_back(0);
    // window 15 is unbeaten in [210998.73, 506869.47]
    bn128_G1::fixed_base_exp_window_table.push_back(210999);
    // window 16 is unbeaten in [506869.47, 930023.36]
    bn128_G1::fixed_base_exp_window_table.push_back(506869);
    // window 17 is unbeaten in [930023.36, 8350812.20]
    bn128_G1::fixed_base_exp_window_table.push_back(930023);
    // window 18 is never the best
    bn128_G1::fixed_base_exp_window_table.push_back(0);
    // window 19 is never the best
    bn128_G1::fixed_base_exp_window_table.push_back(0);
    // window 20 is unbeaten in [8350812.20, 21708138.87]
    bn128_G1::fixed_base_exp_window_table.push_back(8350812);
    // window 21 is unbeaten in [21708138.87, 29482995.52]
    bn128_G1::fixed_base_exp_window_table.push_back(21708139);
    // window 22 is unbeaten in [29482995.52, inf]
    bn128_G1::fixed_base_exp_window_table.push_back(29482996);
 
    /* choice of group G2 */
    bn128_G2::G2_zero.X = bn::Fp2(bn::Fp(1), bn::Fp(0));
    bn128_G2::G2_zero.Y = bn::Fp2(bn::Fp(1), bn::Fp(0));
    bn128_G2::G2_zero.Z = bn::Fp2(bn::Fp(0), bn::Fp(0));
 
    bn128_G2::G2_one.X = bn::Fp2(bn::Fp("15267802884793550383558706039165621050290089775961208824303765753922461897946"),
                                        bn::Fp("9034493566019742339402378670461897774509967669562610788113215988055021632533"));
    bn128_G2::G2_one.Y = bn::Fp2(bn::Fp("644888581738283025171396578091639672120333224302184904896215738366765861164"),
                                        bn::Fp("20532875081203448695448744255224543661959516361327385779878476709582931298750"));
    bn128_G2::G2_one.Z = bn::Fp2(bn::Fp(1), bn::Fp(0));
 
    bn128_G2::initialized = true;
 
    bn128_G2::wnaf_window_table.resize(0);
    bn128_G2::wnaf_window_table.push_back(7);
    bn128_G2::wnaf_window_table.push_back(18);
    bn128_G2::wnaf_window_table.push_back(35);
    bn128_G2::wnaf_window_table.push_back(116);
 
    bn128_G2::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 4.13]
    bn128_G2::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [4.13, 10.72]
    bn128_G2::fixed_base_exp_window_table.push_back(4);
    // window 3 is unbeaten in [10.72, 25.60]
    bn128_G2::fixed_base_exp_window_table.push_back(11);
    // window 4 is unbeaten in [25.60, 60.99]
    bn128_G2::fixed_base_exp_window_table.push_back(26);
    // window 5 is unbeaten in [60.99, 153.66]
    bn128_G2::fixed_base_exp_window_table.push_back(61);
    // window 6 is unbeaten in [153.66, 353.13]
    bn128_G2::fixed_base_exp_window_table.push_back(154);
    // window 7 is unbeaten in [353.13, 771.87]
    bn128_G2::fixed_base_exp_window_table.push_back(353);
    // window 8 is unbeaten in [771.87, 2025.85]
    bn128_G2::fixed_base_exp_window_table.push_back(772);
    // window 9 is unbeaten in [2025.85, 4398.65]
    bn128_G2::fixed_base_exp_window_table.push_back(2026);
    // window 10 is unbeaten in [4398.65, 10493.42]
    bn128_G2::fixed_base_exp_window_table.push_back(4399);
    // window 11 is unbeaten in [10493.42, 37054.73]
    bn128_G2::fixed_base_exp_window_table.push_back(10493);
    // window 12 is unbeaten in [37054.73, 49928.78]
    bn128_G2::fixed_base_exp_window_table.push_back(37055);
    // window 13 is unbeaten in [49928.78, 114502.82]
    bn128_G2::fixed_base_exp_window_table.push_back(49929);
    // window 14 is unbeaten in [114502.82, 161445.26]
    bn128_G2::fixed_base_exp_window_table.push_back(114503);
    // window 15 is unbeaten in [161445.26, 470648.01]
    bn128_G2::fixed_base_exp_window_table.push_back(161445);
    // window 16 is unbeaten in [470648.01, 1059821.87]
    bn128_G2::fixed_base_exp_window_table.push_back(470648);
    // window 17 is unbeaten in [1059821.87, 5450848.25]
    bn128_G2::fixed_base_exp_window_table.push_back(1059822);
    // window 18 is never the best
    bn128_G2::fixed_base_exp_window_table.push_back(0);
    // window 19 is unbeaten in [5450848.25, 5566795.57]
    bn128_G2::fixed_base_exp_window_table.push_back(5450848);
    // window 20 is unbeaten in [5566795.57, 33055217.52]
    bn128_G2::fixed_base_exp_window_table.push_back(5566796);
    // window 21 is never the best
    bn128_G2::fixed_base_exp_window_table.push_back(0);
    // window 22 is unbeaten in [33055217.52, inf]
    bn128_G2::fixed_base_exp_window_table.push_back(33055218);
 
    bn128_GT::GT_one.elem = bn::Fp12(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_edwards_params()

void libff::init_edwards_params ( )

Definition at line 37 of file edwards_init.cpp.

{
    typedef bigint<edwards_r_limbs> bigint_r;
    typedef bigint<edwards_q_limbs> bigint_q;
 
    assert(sizeof(mp_limb_t) == 8 || sizeof(mp_limb_t) == 4); // Montgomery assumes this
 
    /* parameters for scalar field Fr */
 
    edwards_modulus_r = bigint_r("1552511030102430251236801561344621993261920897571225601");
    assert(edwards_Fr::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        edwards_Fr::Rsquared = bigint_r("621738487827897760168419760282818735947979812540885779");
        edwards_Fr::Rcubed = bigint_r("899968968216802386013510389846941393831065658679774050");
        edwards_Fr::inv = 0xdde553277fffffff;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        edwards_Fr::Rsquared = bigint_r("621738487827897760168419760282818735947979812540885779");
        edwards_Fr::Rcubed = bigint_r("899968968216802386013510389846941393831065658679774050");
        edwards_Fr::inv = 0x7fffffff;
    }
    edwards_Fr::num_bits = 181;
    edwards_Fr::euler = bigint_r("776255515051215125618400780672310996630960448785612800");
    edwards_Fr::s = 31;
    edwards_Fr::t = bigint_r("722944284836962004768104088187507350585386575");
    edwards_Fr::t_minus_1_over_2 = bigint_r("361472142418481002384052044093753675292693287");
    edwards_Fr::multiplicative_generator = edwards_Fr("19");
    edwards_Fr::root_of_unity = edwards_Fr("695314865466598274460565335217615316274564719601897184");
    edwards_Fr::nqr = edwards_Fr("11");
    edwards_Fr::nqr_to_t = edwards_Fr("1326707053668679463752768729767248251415639579872144553");
 
    /* parameters for base field Fq */
 
    edwards_modulus_q = bigint_q("6210044120409721004947206240885978274523751269793792001");
    assert(edwards_Fq::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        edwards_Fq::Rsquared = bigint_q("5943559676554581037560514598978484097352477055348195432");
        edwards_Fq::Rcubed = bigint_q("1081560488703514202058739223469726982199727506489234349");
        edwards_Fq::inv = 0x76eb690b7fffffff;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        edwards_Fq::Rsquared = bigint_q("5943559676554581037560514598978484097352477055348195432");
        edwards_Fq::Rcubed = bigint_q("1081560488703514202058739223469726982199727506489234349");
        edwards_Fq::inv = 0x7fffffff;
    }
    edwards_Fq::num_bits = 183;
    edwards_Fq::euler = bigint_q("3105022060204860502473603120442989137261875634896896000");
    edwards_Fq::s = 31;
    edwards_Fq::t = bigint_q("2891777139347848019072416350658041552884388375");
    edwards_Fq::t_minus_1_over_2 = bigint_q("1445888569673924009536208175329020776442194187");
    edwards_Fq::multiplicative_generator = edwards_Fq("61");
    edwards_Fq::root_of_unity = edwards_Fq("4692813029219384139894873043933463717810008194158530536");
    edwards_Fq::nqr = edwards_Fq("23");
    edwards_Fq::nqr_to_t = edwards_Fq("2626736066325740702418554487368721595489070118548299138");
 
    /* parameters for twist field Fq3 */
 
    edwards_Fq3::euler = bigint<3*edwards_q_limbs>("119744082713971502962992613191067836698205043373978948903839934564152994858051284658545502971203325031831647424413111161318314144765646525057914792711854057586688000");
    edwards_Fq3::s = 31;
    edwards_Fq3::t = bigint<3*edwards_q_limbs>("111520367408144756185815309352304634357062208814526860512643991563611659089151103662834971185031649686239331424621037357783237607000066456438894190557165125");
    edwards_Fq3::t_minus_1_over_2 = bigint<3*edwards_q_limbs>("55760183704072378092907654676152317178531104407263430256321995781805829544575551831417485592515824843119665712310518678891618803500033228219447095278582562");
    edwards_Fq3::non_residue = edwards_Fq("61");
    edwards_Fq3::nqr = edwards_Fq3(edwards_Fq("23"),edwards_Fq("0"),edwards_Fq("0"));
    edwards_Fq3::nqr_to_t = edwards_Fq3(edwards_Fq("104810943629412208121981114244673004633270996333237516"),edwards_Fq("0"),edwards_Fq("0"));
    edwards_Fq3::Frobenius_coeffs_c1[0] = edwards_Fq("1");
    edwards_Fq3::Frobenius_coeffs_c1[1] = edwards_Fq("1073752683758513276629212192812154536507607213288832061");
    edwards_Fq3::Frobenius_coeffs_c1[2] = edwards_Fq("5136291436651207728317994048073823738016144056504959939");
    edwards_Fq3::Frobenius_coeffs_c2[0] = edwards_Fq("1");
    edwards_Fq3::Frobenius_coeffs_c2[1] = edwards_Fq("5136291436651207728317994048073823738016144056504959939");
    edwards_Fq3::Frobenius_coeffs_c2[2] = edwards_Fq("1073752683758513276629212192812154536507607213288832061");
 
    /* parameters for Fq6 */
 
    edwards_Fq6::non_residue = edwards_Fq("61");
    edwards_Fq6::Frobenius_coeffs_c1[0] = edwards_Fq("1");
    edwards_Fq6::Frobenius_coeffs_c1[1] = edwards_Fq("1073752683758513276629212192812154536507607213288832062");
    edwards_Fq6::Frobenius_coeffs_c1[2] = edwards_Fq("1073752683758513276629212192812154536507607213288832061");
    edwards_Fq6::Frobenius_coeffs_c1[3] = edwards_Fq("6210044120409721004947206240885978274523751269793792000");
    edwards_Fq6::Frobenius_coeffs_c1[4] = edwards_Fq("5136291436651207728317994048073823738016144056504959939");
    edwards_Fq6::Frobenius_coeffs_c1[5] = edwards_Fq("5136291436651207728317994048073823738016144056504959940");
    edwards_Fq6::my_Fp2::non_residue = edwards_Fq3::non_residue;
 
    /* choice of Edwards curve and its twist */
 
    edwards_coeff_a = edwards_Fq::one();
    edwards_coeff_d = edwards_Fq("600581931845324488256649384912508268813600056237543024");
    edwards_twist = edwards_Fq3(edwards_Fq::zero(), edwards_Fq::one(), edwards_Fq::zero());
    edwards_twist_coeff_a = edwards_coeff_a * edwards_twist;
    edwards_twist_coeff_d = edwards_coeff_d * edwards_twist;
    edwards_twist_mul_by_a_c0 = edwards_coeff_a * edwards_Fq3::non_residue;
    edwards_twist_mul_by_a_c1 = edwards_coeff_a;
    edwards_twist_mul_by_a_c2 = edwards_coeff_a;
    edwards_twist_mul_by_d_c0 = edwards_coeff_d * edwards_Fq3::non_residue;
    edwards_twist_mul_by_d_c1 = edwards_coeff_d;
    edwards_twist_mul_by_d_c2 = edwards_coeff_d;
    edwards_twist_mul_by_q_Y = edwards_Fq("1073752683758513276629212192812154536507607213288832062");
    edwards_twist_mul_by_q_Z = edwards_Fq("1073752683758513276629212192812154536507607213288832062");
 
    /* choice of group G1 */
    edwards_G1::G1_zero = edwards_G1(edwards_Fq::zero(),
                                     edwards_Fq::one());
    edwards_G1::G1_one = edwards_G1(edwards_Fq("3713709671941291996998665608188072510389821008693530490"),
                                    edwards_Fq("4869953702976555123067178261685365085639705297852816679"));
    edwards_G1::initialized = true;
 
    edwards_G1::wnaf_window_table.resize(0);
    edwards_G1::wnaf_window_table.push_back(9);
    edwards_G1::wnaf_window_table.push_back(14);
    edwards_G1::wnaf_window_table.push_back(24);
    edwards_G1::wnaf_window_table.push_back(117);
 
    edwards_G1::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 4.10]
    edwards_G1::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [4.10, 9.69]
    edwards_G1::fixed_base_exp_window_table.push_back(4);
    // window 3 is unbeaten in [9.69, 25.21]
    edwards_G1::fixed_base_exp_window_table.push_back(10);
    // window 4 is unbeaten in [25.21, 60.00]
    edwards_G1::fixed_base_exp_window_table.push_back(25);
    // window 5 is unbeaten in [60.00, 149.33]
    edwards_G1::fixed_base_exp_window_table.push_back(60);
    // window 6 is unbeaten in [149.33, 369.61]
    edwards_G1::fixed_base_exp_window_table.push_back(149);
    // window 7 is unbeaten in [369.61, 849.07]
    edwards_G1::fixed_base_exp_window_table.push_back(370);
    // window 8 is unbeaten in [849.07, 1764.94]
    edwards_G1::fixed_base_exp_window_table.push_back(849);
    // window 9 is unbeaten in [1764.94, 4429.59]
    edwards_G1::fixed_base_exp_window_table.push_back(1765);
    // window 10 is unbeaten in [4429.59, 13388.78]
    edwards_G1::fixed_base_exp_window_table.push_back(4430);
    // window 11 is unbeaten in [13388.78, 15368.00]
    edwards_G1::fixed_base_exp_window_table.push_back(13389);
    // window 12 is unbeaten in [15368.00, 74912.07]
    edwards_G1::fixed_base_exp_window_table.push_back(15368);
    // window 13 is unbeaten in [74912.07, 438107.20]
    edwards_G1::fixed_base_exp_window_table.push_back(74912);
    // window 14 is never the best
    edwards_G1::fixed_base_exp_window_table.push_back(0);
    // window 15 is unbeaten in [438107.20, 1045626.18]
    edwards_G1::fixed_base_exp_window_table.push_back(438107);
    // window 16 is never the best
    edwards_G1::fixed_base_exp_window_table.push_back(0);
    // window 17 is unbeaten in [1045626.18, 1577434.48]
    edwards_G1::fixed_base_exp_window_table.push_back(1045626);
    // window 18 is unbeaten in [1577434.48, 17350594.23]
    edwards_G1::fixed_base_exp_window_table.push_back(1577434);
    // window 19 is never the best
    edwards_G1::fixed_base_exp_window_table.push_back(0);
    // window 20 is never the best
    edwards_G1::fixed_base_exp_window_table.push_back(0);
    // window 21 is unbeaten in [17350594.23, inf]
    edwards_G1::fixed_base_exp_window_table.push_back(17350594);
    // window 22 is never the best
    edwards_G1::fixed_base_exp_window_table.push_back(0);
 
    /* choice of group G2 */
 
    edwards_G2::G2_zero = edwards_G2(edwards_Fq3::zero(),
                                     edwards_Fq3::one());
    edwards_G2::G2_one = edwards_G2(edwards_Fq3(edwards_Fq("4531683359223370252210990718516622098304721701253228128"),
                                                edwards_Fq("5339624155305731263217400504407647531329993548123477368"),
                                                edwards_Fq("3964037981777308726208525982198654699800283729988686552")),
                                    edwards_Fq3(edwards_Fq("364634864866983740775341816274081071386963546650700569"),
                                                edwards_Fq("3264380230116139014996291397901297105159834497864380415"),
                                                edwards_Fq("3504781284999684163274269077749440837914479176282903747")));
    edwards_G2::initialized = true;
 
    edwards_G2::wnaf_window_table.resize(0);
    edwards_G2::wnaf_window_table.push_back(6);
    edwards_G2::wnaf_window_table.push_back(12);
    edwards_G2::wnaf_window_table.push_back(42);
    edwards_G2::wnaf_window_table.push_back(97);
 
    edwards_G2::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 4.74]
    edwards_G2::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [4.74, 10.67]
    edwards_G2::fixed_base_exp_window_table.push_back(5);
    // window 3 is unbeaten in [10.67, 25.53]
    edwards_G2::fixed_base_exp_window_table.push_back(11);
    // window 4 is unbeaten in [25.53, 60.67]
    edwards_G2::fixed_base_exp_window_table.push_back(26);
    // window 5 is unbeaten in [60.67, 145.77]
    edwards_G2::fixed_base_exp_window_table.push_back(61);
    // window 6 is unbeaten in [145.77, 356.76]
    edwards_G2::fixed_base_exp_window_table.push_back(146);
    // window 7 is unbeaten in [356.76, 823.08]
    edwards_G2::fixed_base_exp_window_table.push_back(357);
    // window 8 is unbeaten in [823.08, 1589.45]
    edwards_G2::fixed_base_exp_window_table.push_back(823);
    // window 9 is unbeaten in [1589.45, 4135.70]
    edwards_G2::fixed_base_exp_window_table.push_back(1589);
    // window 10 is unbeaten in [4135.70, 14297.74]
    edwards_G2::fixed_base_exp_window_table.push_back(4136);
    // window 11 is unbeaten in [14297.74, 16744.85]
    edwards_G2::fixed_base_exp_window_table.push_back(14298);
    // window 12 is unbeaten in [16744.85, 51768.98]
    edwards_G2::fixed_base_exp_window_table.push_back(16745);
    // window 13 is unbeaten in [51768.98, 99811.01]
    edwards_G2::fixed_base_exp_window_table.push_back(51769);
    // window 14 is unbeaten in [99811.01, 193306.72]
    edwards_G2::fixed_base_exp_window_table.push_back(99811);
    // window 15 is unbeaten in [193306.72, 907184.68]
    edwards_G2::fixed_base_exp_window_table.push_back(193307);
    // window 16 is never the best
    edwards_G2::fixed_base_exp_window_table.push_back(0);
    // window 17 is unbeaten in [907184.68, 1389682.59]
    edwards_G2::fixed_base_exp_window_table.push_back(907185);
    // window 18 is unbeaten in [1389682.59, 6752695.74]
    edwards_G2::fixed_base_exp_window_table.push_back(1389683);
    // window 19 is never the best
    edwards_G2::fixed_base_exp_window_table.push_back(0);
    // window 20 is unbeaten in [6752695.74, 193642894.51]
    edwards_G2::fixed_base_exp_window_table.push_back(6752696);
    // window 21 is unbeaten in [193642894.51, 226760202.29]
    edwards_G2::fixed_base_exp_window_table.push_back(193642895);
    // window 22 is unbeaten in [226760202.29, inf]
    edwards_G2::fixed_base_exp_window_table.push_back(226760202);
 
    /* pairing parameters */
 
    edwards_ate_loop_count = bigint_q("4492509698523932320491110403");
    edwards_final_exponent = bigint<6*edwards_q_limbs>("36943107177961694649618797346446870138748651578611748415128207429491593976636391130175425245705674550269561361208979548749447898941828686017765730419416875539615941651269793928962468899856083169227457503942470721108165443528513330156264699608120624990672333642644221591552000");
    edwards_final_exponent_last_chunk_abs_of_w0 = bigint_q("17970038794095729281964441603");
    edwards_final_exponent_last_chunk_is_w0_neg = true;
    edwards_final_exponent_last_chunk_w1 = bigint_q("4");
 
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_mnt4_params()

void libff::init_mnt4_params ( )

Definition at line 40 of file mnt4_init.cpp.

{
    typedef bigint<mnt4_r_limbs> bigint_r;
    typedef bigint<mnt4_q_limbs> bigint_q;
 
    assert(sizeof(mp_limb_t) == 8 || sizeof(mp_limb_t) == 4); // Montgomery assumes this
 
    /* parameters for scalar field Fr */
    mnt4_modulus_r = bigint_r("475922286169261325753349249653048451545124878552823515553267735739164647307408490559963137");
    assert(mnt4_Fr::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        mnt4_Fr::Rsquared = bigint_r("163983144722506446826715124368972380525894397127205577781234305496325861831001705438796139");
        mnt4_Fr::Rcubed = bigint_r("207236281459091063710247635236340312578688659363066707916716212805695955118593239854980171");
        mnt4_Fr::inv = 0xbb4334a3ffffffff;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        mnt4_Fr::Rsquared = bigint_r("163983144722506446826715124368972380525894397127205577781234305496325861831001705438796139");
        mnt4_Fr::Rcubed = bigint_r("207236281459091063710247635236340312578688659363066707916716212805695955118593239854980171");
        mnt4_Fr::inv = 0xffffffff;
    }
    mnt4_Fr::num_bits = 298;
    mnt4_Fr::euler = bigint_r("237961143084630662876674624826524225772562439276411757776633867869582323653704245279981568");
    mnt4_Fr::s = 34;
    mnt4_Fr::t = bigint_r("27702323054502562488973446286577291993024111641153199339359284829066871159442729");
    mnt4_Fr::t_minus_1_over_2 = bigint_r("13851161527251281244486723143288645996512055820576599669679642414533435579721364");
    mnt4_Fr::multiplicative_generator = mnt4_Fr("10");
    mnt4_Fr::root_of_unity = mnt4_Fr("120638817826913173458768829485690099845377008030891618010109772937363554409782252579816313");
    mnt4_Fr::nqr = mnt4_Fr("5");
    mnt4_Fr::nqr_to_t = mnt4_Fr("406220604243090401056429458730298145937262552508985450684842547562990900634752279902740880");
 
    /* parameters for base field Fq */
    mnt4_modulus_q = bigint_q("475922286169261325753349249653048451545124879242694725395555128576210262817955800483758081");
    assert(mnt4_Fq::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        mnt4_Fq::Rsquared = bigint_q("273000478523237720910981655601160860640083126627235719712980612296263966512828033847775776");
        mnt4_Fq::Rcubed = bigint_q("427298980065529822574935274648041073124704261331681436071990730954930769758106792920349077");
        mnt4_Fq::inv = 0xb071a1b67165ffff;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        mnt4_Fq::Rsquared = bigint_q("273000478523237720910981655601160860640083126627235719712980612296263966512828033847775776");
        mnt4_Fq::Rcubed = bigint_q("427298980065529822574935274648041073124704261331681436071990730954930769758106792920349077");
        mnt4_Fq::inv = 0x7165ffff;
    }
    mnt4_Fq::num_bits = 298;
    mnt4_Fq::euler = bigint_q("237961143084630662876674624826524225772562439621347362697777564288105131408977900241879040");
    mnt4_Fq::s = 17;
    mnt4_Fq::t = bigint_q("3630998887399759870554727551674258816109656366292531779446068791017229177993437198515");
    mnt4_Fq::t_minus_1_over_2 = bigint_q("1815499443699879935277363775837129408054828183146265889723034395508614588996718599257");
    mnt4_Fq::multiplicative_generator = mnt4_Fq("17");
    mnt4_Fq::root_of_unity = mnt4_Fq("264706250571800080758069302369654305530125675521263976034054878017580902343339784464690243");
    mnt4_Fq::nqr = mnt4_Fq("17");
    mnt4_Fq::nqr_to_t = mnt4_Fq("264706250571800080758069302369654305530125675521263976034054878017580902343339784464690243");
 
    /* parameters for twist field Fq2 */
    mnt4_Fq2::euler = bigint<2*mnt4_q_limbs>("113251011236288135098249345249154230895914381858788918106847214243419142422924133497460817468249854833067260038985710370091920860837014281886963086681184370139950267830740466401280");
    mnt4_Fq2::s = 18;
    mnt4_Fq2::t = bigint<2*mnt4_q_limbs>("864036645784668999467844736092790457885088972921668381552484239528039111503022258739172496553419912972009735404859240494475714575477709059806542104196047745818712370534824115");
    mnt4_Fq2::t_minus_1_over_2 = bigint<2*mnt4_q_limbs>("432018322892334499733922368046395228942544486460834190776242119764019555751511129369586248276709956486004867702429620247237857287738854529903271052098023872909356185267412057");
    mnt4_Fq2::non_residue = mnt4_Fq("17");
    mnt4_Fq2::nqr = mnt4_Fq2(mnt4_Fq("8"),mnt4_Fq("1"));
    mnt4_Fq2::nqr_to_t = mnt4_Fq2(mnt4_Fq("0"),mnt4_Fq("29402818985595053196743631544512156561638230562612542604956687802791427330205135130967658"));
    mnt4_Fq2::Frobenius_coeffs_c1[0] = mnt4_Fq("1");
    mnt4_Fq2::Frobenius_coeffs_c1[1] = mnt4_Fq("475922286169261325753349249653048451545124879242694725395555128576210262817955800483758080");
 
    /* parameters for Fq4 */
    mnt4_Fq4::non_residue = mnt4_Fq("17");
    mnt4_Fq4::Frobenius_coeffs_c1[0] = mnt4_Fq("1");
    mnt4_Fq4::Frobenius_coeffs_c1[1] = mnt4_Fq("7684163245453501615621351552473337069301082060976805004625011694147890954040864167002308");
    mnt4_Fq4::Frobenius_coeffs_c1[2] = mnt4_Fq("475922286169261325753349249653048451545124879242694725395555128576210262817955800483758080");
    mnt4_Fq4::Frobenius_coeffs_c1[3] = mnt4_Fq("468238122923807824137727898100575114475823797181717920390930116882062371863914936316755773");
 
    /* choice of short Weierstrass curve and its twist */
    mnt4_G1::coeff_a = mnt4_Fq("2");
    mnt4_G1::coeff_b = mnt4_Fq("423894536526684178289416011533888240029318103673896002803341544124054745019340795360841685");
    mnt4_twist = mnt4_Fq2(mnt4_Fq::zero(), mnt4_Fq::one());
    mnt4_twist_coeff_a = mnt4_Fq2(mnt4_G1::coeff_a * mnt4_Fq2::non_residue, mnt4_Fq::zero());
    mnt4_twist_coeff_b = mnt4_Fq2(mnt4_Fq::zero(), mnt4_G1::coeff_b * mnt4_Fq2::non_residue);
    mnt4_G2::twist = mnt4_twist;
    mnt4_G2::coeff_a = mnt4_twist_coeff_a;
    mnt4_G2::coeff_b = mnt4_twist_coeff_b;
    mnt4_twist_mul_by_a_c0 = mnt4_G1::coeff_a * mnt4_Fq2::non_residue;
    mnt4_twist_mul_by_a_c1 = mnt4_G1::coeff_a * mnt4_Fq2::non_residue;
    mnt4_twist_mul_by_b_c0 = mnt4_G1::coeff_b * mnt4_Fq2::non_residue.squared();
    mnt4_twist_mul_by_b_c1 = mnt4_G1::coeff_b * mnt4_Fq2::non_residue;
    mnt4_twist_mul_by_q_X = mnt4_Fq("475922286169261325753349249653048451545124879242694725395555128576210262817955800483758080");
    mnt4_twist_mul_by_q_Y = mnt4_Fq("7684163245453501615621351552473337069301082060976805004625011694147890954040864167002308");
 
    /* choice of group G1 */
    mnt4_G1::G1_zero = mnt4_G1(mnt4_Fq::zero(),
                               mnt4_Fq::one(),
                               mnt4_Fq::zero());
 
 
    mnt4_G1::G1_one = mnt4_G1(mnt4_Fq("60760244141852568949126569781626075788424196370144486719385562369396875346601926534016838"),
                              mnt4_Fq("363732850702582978263902770815145784459747722357071843971107674179038674942891694705904306"),
                              mnt4_Fq::one());
    mnt4_G1::initialized = true;
 
    mnt4_G1::wnaf_window_table.resize(0);
    mnt4_G1::wnaf_window_table.push_back(11);
    mnt4_G1::wnaf_window_table.push_back(24);
    mnt4_G1::wnaf_window_table.push_back(60);
    mnt4_G1::wnaf_window_table.push_back(127);
 
    mnt4_G1::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 5.09]
    mnt4_G1::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [5.09, 9.64]
    mnt4_G1::fixed_base_exp_window_table.push_back(5);
    // window 3 is unbeaten in [9.64, 24.79]
    mnt4_G1::fixed_base_exp_window_table.push_back(10);
    // window 4 is unbeaten in [24.79, 60.29]
    mnt4_G1::fixed_base_exp_window_table.push_back(25);
    // window 5 is unbeaten in [60.29, 144.37]
    mnt4_G1::fixed_base_exp_window_table.push_back(60);
    // window 6 is unbeaten in [144.37, 344.90]
    mnt4_G1::fixed_base_exp_window_table.push_back(144);
    // window 7 is unbeaten in [344.90, 855.00]
    mnt4_G1::fixed_base_exp_window_table.push_back(345);
    // window 8 is unbeaten in [855.00, 1804.62]
    mnt4_G1::fixed_base_exp_window_table.push_back(855);
    // window 9 is unbeaten in [1804.62, 3912.30]
    mnt4_G1::fixed_base_exp_window_table.push_back(1805);
    // window 10 is unbeaten in [3912.30, 11264.50]
    mnt4_G1::fixed_base_exp_window_table.push_back(3912);
    // window 11 is unbeaten in [11264.50, 27897.51]
    mnt4_G1::fixed_base_exp_window_table.push_back(11265);
    // window 12 is unbeaten in [27897.51, 57596.79]
    mnt4_G1::fixed_base_exp_window_table.push_back(27898);
    // window 13 is unbeaten in [57596.79, 145298.71]
    mnt4_G1::fixed_base_exp_window_table.push_back(57597);
    // window 14 is unbeaten in [145298.71, 157204.59]
    mnt4_G1::fixed_base_exp_window_table.push_back(145299);
    // window 15 is unbeaten in [157204.59, 601600.62]
    mnt4_G1::fixed_base_exp_window_table.push_back(157205);
    // window 16 is unbeaten in [601600.62, 1107377.25]
    mnt4_G1::fixed_base_exp_window_table.push_back(601601);
    // window 17 is unbeaten in [1107377.25, 1789646.95]
    mnt4_G1::fixed_base_exp_window_table.push_back(1107377);
    // window 18 is unbeaten in [1789646.95, 4392626.92]
    mnt4_G1::fixed_base_exp_window_table.push_back(1789647);
    // window 19 is unbeaten in [4392626.92, 8221210.60]
    mnt4_G1::fixed_base_exp_window_table.push_back(4392627);
    // window 20 is unbeaten in [8221210.60, 42363731.19]
    mnt4_G1::fixed_base_exp_window_table.push_back(8221211);
    // window 21 is never the best
    mnt4_G1::fixed_base_exp_window_table.push_back(0);
    // window 22 is unbeaten in [42363731.19, inf]
    mnt4_G1::fixed_base_exp_window_table.push_back(42363731);
 
    /* choice of group G2 */
    mnt4_G2::G2_zero = mnt4_G2(mnt4_Fq2::zero(),
                               mnt4_Fq2::one(),
                               mnt4_Fq2::zero());
 
    mnt4_G2::G2_one = mnt4_G2(mnt4_Fq2(mnt4_Fq("438374926219350099854919100077809681842783509163790991847867546339851681564223481322252708"),
                                       mnt4_Fq("37620953615500480110935514360923278605464476459712393277679280819942849043649216370485641")),
                              mnt4_Fq2(mnt4_Fq("37437409008528968268352521034936931842973546441370663118543015118291998305624025037512482"),
                                       mnt4_Fq("424621479598893882672393190337420680597584695892317197646113820787463109735345923009077489")),
                              mnt4_Fq2::one());
    mnt4_G2::initialized = true;
 
    mnt4_G2::wnaf_window_table.resize(0);
    mnt4_G2::wnaf_window_table.push_back(5);
    mnt4_G2::wnaf_window_table.push_back(15);
    mnt4_G2::wnaf_window_table.push_back(39);
    mnt4_G2::wnaf_window_table.push_back(109);
 
    mnt4_G2::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 4.17]
    mnt4_G2::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [4.17, 10.12]
    mnt4_G2::fixed_base_exp_window_table.push_back(4);
    // window 3 is unbeaten in [10.12, 24.65]
    mnt4_G2::fixed_base_exp_window_table.push_back(10);
    // window 4 is unbeaten in [24.65, 60.03]
    mnt4_G2::fixed_base_exp_window_table.push_back(25);
    // window 5 is unbeaten in [60.03, 143.16]
    mnt4_G2::fixed_base_exp_window_table.push_back(60);
    // window 6 is unbeaten in [143.16, 344.73]
    mnt4_G2::fixed_base_exp_window_table.push_back(143);
    // window 7 is unbeaten in [344.73, 821.24]
    mnt4_G2::fixed_base_exp_window_table.push_back(345);
    // window 8 is unbeaten in [821.24, 1793.92]
    mnt4_G2::fixed_base_exp_window_table.push_back(821);
    // window 9 is unbeaten in [1793.92, 3919.59]
    mnt4_G2::fixed_base_exp_window_table.push_back(1794);
    // window 10 is unbeaten in [3919.59, 11301.46]
    mnt4_G2::fixed_base_exp_window_table.push_back(3920);
    // window 11 is unbeaten in [11301.46, 18960.09]
    mnt4_G2::fixed_base_exp_window_table.push_back(11301);
    // window 12 is unbeaten in [18960.09, 44198.62]
    mnt4_G2::fixed_base_exp_window_table.push_back(18960);
    // window 13 is unbeaten in [44198.62, 150799.57]
    mnt4_G2::fixed_base_exp_window_table.push_back(44199);
    // window 14 is never the best
    mnt4_G2::fixed_base_exp_window_table.push_back(0);
    // window 15 is unbeaten in [150799.57, 548694.81]
    mnt4_G2::fixed_base_exp_window_table.push_back(150800);
    // window 16 is unbeaten in [548694.81, 1051769.08]
    mnt4_G2::fixed_base_exp_window_table.push_back(548695);
    // window 17 is unbeaten in [1051769.08, 2023925.59]
    mnt4_G2::fixed_base_exp_window_table.push_back(1051769);
    // window 18 is unbeaten in [2023925.59, 3787108.68]
    mnt4_G2::fixed_base_exp_window_table.push_back(2023926);
    // window 19 is unbeaten in [3787108.68, 7107480.30]
    mnt4_G2::fixed_base_exp_window_table.push_back(3787109);
    // window 20 is unbeaten in [7107480.30, 38760027.14]
    mnt4_G2::fixed_base_exp_window_table.push_back(7107480);
    // window 21 is never the best
    mnt4_G2::fixed_base_exp_window_table.push_back(0);
    // window 22 is unbeaten in [38760027.14, inf]
    mnt4_G2::fixed_base_exp_window_table.push_back(38760027);
 
    /* pairing parameters */
    mnt4_ate_loop_count = bigint_q("689871209842287392837045615510547309923794944");
    mnt4_ate_is_loop_count_neg = false;
    mnt4_final_exponent = bigint<4*mnt4_q_limbs>("107797360357109903430794490309592072278927783803031854357910908121903439838772861497177116410825586743089760869945394610511917274977971559062689561855016270594656570874331111995170645233717143416875749097203441437192367065467706065411650403684877366879441766585988546560");
    mnt4_final_exponent_last_chunk_abs_of_w0 = bigint_q("689871209842287392837045615510547309923794945");
    mnt4_final_exponent_last_chunk_is_w0_neg = false;
    mnt4_final_exponent_last_chunk_w1 = bigint_q("1");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_mnt6_params()

void libff::init_mnt6_params ( )

Definition at line 42 of file mnt6_init.cpp.

{
    typedef bigint<mnt6_r_limbs> bigint_r;
    typedef bigint<mnt6_q_limbs> bigint_q;
 
    assert(sizeof(mp_limb_t) == 8 || sizeof(mp_limb_t) == 4); // Montgomery assumes this
 
    /* parameters for scalar field Fr */
    mnt6_modulus_r = bigint_r("475922286169261325753349249653048451545124879242694725395555128576210262817955800483758081");
    assert(mnt6_Fr::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        mnt6_Fr::Rsquared = bigint_r("273000478523237720910981655601160860640083126627235719712980612296263966512828033847775776");
        mnt6_Fr::Rcubed = bigint_r("427298980065529822574935274648041073124704261331681436071990730954930769758106792920349077");
        mnt6_Fr::inv = 0xb071a1b67165ffff;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        mnt6_Fr::Rsquared = bigint_r("273000478523237720910981655601160860640083126627235719712980612296263966512828033847775776");
        mnt6_Fr::Rcubed = bigint_r("427298980065529822574935274648041073124704261331681436071990730954930769758106792920349077");
        mnt6_Fr::inv = 0x7165ffff;
    }
    mnt6_Fr::num_bits = 298;
    mnt6_Fr::euler = bigint_r("237961143084630662876674624826524225772562439621347362697777564288105131408977900241879040");
    mnt6_Fr::s = 17;
    mnt6_Fr::t = bigint_r("3630998887399759870554727551674258816109656366292531779446068791017229177993437198515");
    mnt6_Fr::t_minus_1_over_2 = bigint_r("1815499443699879935277363775837129408054828183146265889723034395508614588996718599257");
    mnt6_Fr::multiplicative_generator = mnt6_Fr("17");
    mnt6_Fr::root_of_unity = mnt6_Fr("264706250571800080758069302369654305530125675521263976034054878017580902343339784464690243");
    mnt6_Fr::nqr = mnt6_Fr("17");
    mnt6_Fr::nqr_to_t = mnt6_Fr("264706250571800080758069302369654305530125675521263976034054878017580902343339784464690243");
 
    /* parameters for base field Fq */
    mnt6_modulus_q = bigint_q("475922286169261325753349249653048451545124878552823515553267735739164647307408490559963137");
    assert(mnt6_Fq::modulus_is_valid());
    if (sizeof(mp_limb_t) == 8)
    {
        mnt6_Fq::Rsquared = bigint_q("163983144722506446826715124368972380525894397127205577781234305496325861831001705438796139");
        mnt6_Fq::Rcubed = bigint_q("207236281459091063710247635236340312578688659363066707916716212805695955118593239854980171");
        mnt6_Fq::inv = 0xbb4334a3ffffffff;
    }
    if (sizeof(mp_limb_t) == 4)
    {
        mnt6_Fq::Rsquared = bigint_q("163983144722506446826715124368972380525894397127205577781234305496325861831001705438796139");
        mnt6_Fq::Rcubed = bigint_q("207236281459091063710247635236340312578688659363066707916716212805695955118593239854980171");
        mnt6_Fq::inv = 0xffffffff;
    }
    mnt6_Fq::num_bits = 298;
    mnt6_Fq::euler = bigint_q("237961143084630662876674624826524225772562439276411757776633867869582323653704245279981568");
    mnt6_Fq::s = 34;
    mnt6_Fq::t = bigint_q("27702323054502562488973446286577291993024111641153199339359284829066871159442729");
    mnt6_Fq::t_minus_1_over_2 = bigint_q("13851161527251281244486723143288645996512055820576599669679642414533435579721364");
    mnt6_Fq::multiplicative_generator = mnt6_Fq("10");
    mnt6_Fq::root_of_unity = mnt6_Fq("120638817826913173458768829485690099845377008030891618010109772937363554409782252579816313");
    mnt6_Fq::nqr = mnt6_Fq("5");
    mnt6_Fq::nqr_to_t = mnt6_Fq("406220604243090401056429458730298145937262552508985450684842547562990900634752279902740880");
 
    /* parameters for twist field Fq3 */
    mnt6_Fq3::euler = bigint<3*mnt6_q_limbs>("53898680178554951715397245154796036139463891589001478629193136369124915637741423690184935056189295242736833704290747216410090671804540908400210778934462129625646263095398323485795557551284190224166851571615834194321908328559167529729507439069424158411618728014749106176");
    mnt6_Fq3::s = 34;
    mnt6_Fq3::t = bigint<3*mnt6_q_limbs>("6274632199033507112809136178669989590936327770934612330653836993631547740397674926811006741620285348354004521888069251599964996777072188956687550402067383940523288107407084140669968625447269322370045302856694231080113482726640944570478452261237446033817102203");
    mnt6_Fq3::t_minus_1_over_2 = bigint<3*mnt6_q_limbs>("3137316099516753556404568089334994795468163885467306165326918496815773870198837463405503370810142674177002260944034625799982498388536094478343775201033691970261644053703542070334984312723634661185022651428347115540056741363320472285239226130618723016908551101");
    mnt6_Fq3::non_residue = mnt6_Fq("5");
    mnt6_Fq3::nqr = mnt6_Fq3(mnt6_Fq("5"),mnt6_Fq("0"),mnt6_Fq("0"));
    mnt6_Fq3::nqr_to_t = mnt6_Fq3(mnt6_Fq("154361449678783505076984156275977937654331103361174469632346230549735979552469642799720052"),mnt6_Fq("0"),mnt6_Fq("0"));
    mnt6_Fq3::Frobenius_coeffs_c1[0] = mnt6_Fq("1");
    mnt6_Fq3::Frobenius_coeffs_c1[1] = mnt6_Fq("471738898967521029133040851318449165997304108729558973770077319830005517129946578866686956");
    mnt6_Fq3::Frobenius_coeffs_c1[2] = mnt6_Fq("4183387201740296620308398334599285547820769823264541783190415909159130177461911693276180");
    mnt6_Fq3::Frobenius_coeffs_c2[0] = mnt6_Fq("1");
    mnt6_Fq3::Frobenius_coeffs_c2[1] = mnt6_Fq("4183387201740296620308398334599285547820769823264541783190415909159130177461911693276180");
    mnt6_Fq3::Frobenius_coeffs_c2[2] = mnt6_Fq("471738898967521029133040851318449165997304108729558973770077319830005517129946578866686956");
 
    /* parameters for Fq6 */
    mnt6_Fq6::non_residue = mnt6_Fq("5");
    mnt6_Fq6::Frobenius_coeffs_c1[0] = mnt6_Fq("1");
    mnt6_Fq6::Frobenius_coeffs_c1[1] = mnt6_Fq("471738898967521029133040851318449165997304108729558973770077319830005517129946578866686957");
    mnt6_Fq6::Frobenius_coeffs_c1[2] = mnt6_Fq("471738898967521029133040851318449165997304108729558973770077319830005517129946578866686956");
    mnt6_Fq6::Frobenius_coeffs_c1[3] = mnt6_Fq("475922286169261325753349249653048451545124878552823515553267735739164647307408490559963136");
    mnt6_Fq6::Frobenius_coeffs_c1[4] = mnt6_Fq("4183387201740296620308398334599285547820769823264541783190415909159130177461911693276180");
    mnt6_Fq6::Frobenius_coeffs_c1[5] = mnt6_Fq("4183387201740296620308398334599285547820769823264541783190415909159130177461911693276181");
    mnt6_Fq6::my_Fp2::non_residue = mnt6_Fq3::non_residue;
 
    /* choice of short Weierstrass curve and its twist */
    mnt6_G1::coeff_a = mnt6_Fq("11");
    mnt6_G1::coeff_b = mnt6_Fq("106700080510851735677967319632585352256454251201367587890185989362936000262606668469523074");
    mnt6_twist = mnt6_Fq3(mnt6_Fq::zero(), mnt6_Fq::one(), mnt6_Fq::zero());
    mnt6_twist_coeff_a = mnt6_Fq3(mnt6_Fq::zero(), mnt6_Fq::zero(),
                                  mnt6_G1::coeff_a);
    mnt6_twist_coeff_b = mnt6_Fq3(mnt6_G1::coeff_b * mnt6_Fq3::non_residue,
                                  mnt6_Fq::zero(), mnt6_Fq::zero());
    mnt6_G2::twist = mnt6_twist;
    mnt6_G2::coeff_a = mnt6_twist_coeff_a;
    mnt6_G2::coeff_b = mnt6_twist_coeff_b;
    mnt6_twist_mul_by_a_c0 = mnt6_G1::coeff_a * mnt6_Fq3::non_residue;
    mnt6_twist_mul_by_a_c1 = mnt6_G1::coeff_a * mnt6_Fq3::non_residue;
    mnt6_twist_mul_by_a_c2 = mnt6_G1::coeff_a;
    mnt6_twist_mul_by_b_c0 = mnt6_G1::coeff_b * mnt6_Fq3::non_residue;
    mnt6_twist_mul_by_b_c1 = mnt6_G1::coeff_b * mnt6_Fq3::non_residue;
    mnt6_twist_mul_by_b_c2 = mnt6_G1::coeff_b * mnt6_Fq3::non_residue;
    mnt6_twist_mul_by_q_X = mnt6_Fq("4183387201740296620308398334599285547820769823264541783190415909159130177461911693276180");
    mnt6_twist_mul_by_q_Y = mnt6_Fq("475922286169261325753349249653048451545124878552823515553267735739164647307408490559963136");
 
    /* choice of group G1 */
    mnt6_G1::G1_zero = mnt6_G1(mnt6_Fq::zero(),
                               mnt6_Fq::one(),
                               mnt6_Fq::zero());
    mnt6_G1::G1_one = mnt6_G1(mnt6_Fq("336685752883082228109289846353937104185698209371404178342968838739115829740084426881123453"),
                              mnt6_Fq("402596290139780989709332707716568920777622032073762749862342374583908837063963736098549800"),
                              mnt6_Fq::one());
    mnt6_G1::initialized = true;
 
    mnt6_G1::wnaf_window_table.resize(0);
    mnt6_G1::wnaf_window_table.push_back(11);
    mnt6_G1::wnaf_window_table.push_back(24);
    mnt6_G1::wnaf_window_table.push_back(60);
    mnt6_G1::wnaf_window_table.push_back(127);
 
    mnt6_G1::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 3.96]
    mnt6_G1::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [3.96, 9.67]
    mnt6_G1::fixed_base_exp_window_table.push_back(4);
    // window 3 is unbeaten in [9.67, 25.13]
    mnt6_G1::fixed_base_exp_window_table.push_back(10);
    // window 4 is unbeaten in [25.13, 60.31]
    mnt6_G1::fixed_base_exp_window_table.push_back(25);
    // window 5 is unbeaten in [60.31, 146.07]
    mnt6_G1::fixed_base_exp_window_table.push_back(60);
    // window 6 is unbeaten in [146.07, 350.09]
    mnt6_G1::fixed_base_exp_window_table.push_back(146);
    // window 7 is unbeaten in [350.09, 844.54]
    mnt6_G1::fixed_base_exp_window_table.push_back(350);
    // window 8 is unbeaten in [844.54, 1839.64]
    mnt6_G1::fixed_base_exp_window_table.push_back(845);
    // window 9 is unbeaten in [1839.64, 3904.26]
    mnt6_G1::fixed_base_exp_window_table.push_back(1840);
    // window 10 is unbeaten in [3904.26, 11309.42]
    mnt6_G1::fixed_base_exp_window_table.push_back(3904);
    // window 11 is unbeaten in [11309.42, 24015.57]
    mnt6_G1::fixed_base_exp_window_table.push_back(11309);
    // window 12 is unbeaten in [24015.57, 72288.57]
    mnt6_G1::fixed_base_exp_window_table.push_back(24016);
    // window 13 is unbeaten in [72288.57, 138413.22]
    mnt6_G1::fixed_base_exp_window_table.push_back(72289);
    // window 14 is unbeaten in [138413.22, 156390.30]
    mnt6_G1::fixed_base_exp_window_table.push_back(138413);
    // window 15 is unbeaten in [156390.30, 562560.50]
    mnt6_G1::fixed_base_exp_window_table.push_back(156390);
    // window 16 is unbeaten in [562560.50, 1036742.02]
    mnt6_G1::fixed_base_exp_window_table.push_back(562560);
    // window 17 is unbeaten in [1036742.02, 2053818.86]
    mnt6_G1::fixed_base_exp_window_table.push_back(1036742);
    // window 18 is unbeaten in [2053818.86, 4370223.95]
    mnt6_G1::fixed_base_exp_window_table.push_back(2053819);
    // window 19 is unbeaten in [4370223.95, 8215703.81]
    mnt6_G1::fixed_base_exp_window_table.push_back(4370224);
    // window 20 is unbeaten in [8215703.81, 42682375.43]
    mnt6_G1::fixed_base_exp_window_table.push_back(8215704);
    // window 21 is never the best
    mnt6_G1::fixed_base_exp_window_table.push_back(0);
    // window 22 is unbeaten in [42682375.43, inf]
    mnt6_G1::fixed_base_exp_window_table.push_back(42682375);
 
    /* choice of group G2 */
    mnt6_G2::G2_zero = mnt6_G2(mnt6_Fq3::zero(),
                               mnt6_Fq3::one(),
                               mnt6_Fq3::zero());
    mnt6_G2::G2_one = mnt6_G2(mnt6_Fq3(mnt6_Fq("421456435772811846256826561593908322288509115489119907560382401870203318738334702321297427"),
                                       mnt6_Fq("103072927438548502463527009961344915021167584706439945404959058962657261178393635706405114"),
                                       mnt6_Fq("143029172143731852627002926324735183809768363301149009204849580478324784395590388826052558")),
                              mnt6_Fq3(mnt6_Fq("464673596668689463130099227575639512541218133445388869383893594087634649237515554342751377"),
                                       mnt6_Fq("100642907501977375184575075967118071807821117960152743335603284583254620685343989304941678"),
                                       mnt6_Fq("123019855502969896026940545715841181300275180157288044663051565390506010149881373807142903")),
                              mnt6_Fq3::one());
    mnt6_G2::initialized = true;
 
    mnt6_G2::wnaf_window_table.resize(0);
    mnt6_G2::wnaf_window_table.push_back(5);
    mnt6_G2::wnaf_window_table.push_back(15);
    mnt6_G2::wnaf_window_table.push_back(39);
    mnt6_G2::wnaf_window_table.push_back(109);
 
    mnt6_G2::fixed_base_exp_window_table.resize(0);
    // window 1 is unbeaten in [-inf, 4.25]
    mnt6_G2::fixed_base_exp_window_table.push_back(1);
    // window 2 is unbeaten in [4.25, 10.22]
    mnt6_G2::fixed_base_exp_window_table.push_back(4);
    // window 3 is unbeaten in [10.22, 24.85]
    mnt6_G2::fixed_base_exp_window_table.push_back(10);
    // window 4 is unbeaten in [24.85, 60.06]
    mnt6_G2::fixed_base_exp_window_table.push_back(25);
    // window 5 is unbeaten in [60.06, 143.61]
    mnt6_G2::fixed_base_exp_window_table.push_back(60);
    // window 6 is unbeaten in [143.61, 345.66]
    mnt6_G2::fixed_base_exp_window_table.push_back(144);
    // window 7 is unbeaten in [345.66, 818.56]
    mnt6_G2::fixed_base_exp_window_table.push_back(346);
    // window 8 is unbeaten in [818.56, 1782.06]
    mnt6_G2::fixed_base_exp_window_table.push_back(819);
    // window 9 is unbeaten in [1782.06, 4002.45]
    mnt6_G2::fixed_base_exp_window_table.push_back(1782);
    // window 10 is unbeaten in [4002.45, 10870.18]
    mnt6_G2::fixed_base_exp_window_table.push_back(4002);
    // window 11 is unbeaten in [10870.18, 18022.51]
    mnt6_G2::fixed_base_exp_window_table.push_back(10870);
    // window 12 is unbeaten in [18022.51, 43160.74]
    mnt6_G2::fixed_base_exp_window_table.push_back(18023);
    // window 13 is unbeaten in [43160.74, 149743.32]
    mnt6_G2::fixed_base_exp_window_table.push_back(43161);
    // window 14 is never the best
    mnt6_G2::fixed_base_exp_window_table.push_back(0);
    // window 15 is unbeaten in [149743.32, 551844.13]
    mnt6_G2::fixed_base_exp_window_table.push_back(149743);
    // window 16 is unbeaten in [551844.13, 1041827.91]
    mnt6_G2::fixed_base_exp_window_table.push_back(551844);
    // window 17 is unbeaten in [1041827.91, 1977371.53]
    mnt6_G2::fixed_base_exp_window_table.push_back(1041828);
    // window 18 is unbeaten in [1977371.53, 3703619.51]
    mnt6_G2::fixed_base_exp_window_table.push_back(1977372);
    // window 19 is unbeaten in [3703619.51, 7057236.87]
    mnt6_G2::fixed_base_exp_window_table.push_back(3703620);
    // window 20 is unbeaten in [7057236.87, 38554491.67]
    mnt6_G2::fixed_base_exp_window_table.push_back(7057237);
    // window 21 is never the best
    mnt6_G2::fixed_base_exp_window_table.push_back(0);
    // window 22 is unbeaten in [38554491.67, inf]
    mnt6_G2::fixed_base_exp_window_table.push_back(38554492);
 
    /* pairing parameters */
    mnt6_ate_loop_count = bigint_q("689871209842287392837045615510547309923794944");
    mnt6_ate_is_loop_count_neg = true;
    mnt6_final_exponent = bigint<6*mnt6_q_limbs>("24416320138090509697890595414313438768353977489862543935904010715439066975957855922532159264213056712140358746422742237328406558352706591021642230618060502855451264045397444793186876199015256781648746888625527075466063075011307800862173764236311342105211681121426931616843635215852236649271569251468773714424208521977615548771268520882870120900360322044218806712027729351845307690474985502587527753847200130592058098363641559341826790559426614919168");
    mnt6_final_exponent_last_chunk_abs_of_w0 = bigint_q("689871209842287392837045615510547309923794944");
    mnt6_final_exponent_last_chunk_is_w0_neg = true;
    mnt6_final_exponent_last_chunk_w1 = bigint_q("1");
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ inner_product()

template<typename T >

T libff::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 )

A convenience function for calculating a pure inner product, where the more complicated methods are not required.

◆ input_bool()

void libff::input_bool	(	std::istream &	in,
		bool &	b )

inline

◆ input_bool_vector()

void libff::input_bool_vector	(	std::istream &	in,
		std::vector< bool > &	v )

inline

◆ int_list_to_bits()

bit_vector libff::int_list_to_bits	(	const std::initializer_list< unsigned long > &	l,
		const size_t	wordsize )

Definition at line 71 of file utils.cpp.

{
    bit_vector res(wordsize*l.size());
    for (size_t i = 0; i < l.size(); ++i)
    {
        for (size_t j = 0; j < wordsize; ++j)
        {
            res[i*wordsize + j] = (*(l.begin()+i) & (1ul<<(wordsize-1-j)));
        }
    }
    return res;
}

◆ is_little_endian()

bool libff::is_little_endian ( )

Definition at line 89 of file utils.cpp.

{
    uint64_t a = 0x12345678;
    unsigned char *c = (unsigned char*)(&a);
    return (*c = 0x78);
}

◆ leave_block()

void libff::leave_block	(	const std::string &	msg,
		const bool	indent )

Definition at line 282 of file profiling.cpp.

{
    if (inhibit_profiling_counters)
    {
        return;
    }
 
#ifndef MULTICORE
    assert(*(--block_names.end()) == msg);
#endif
    block_names.pop_back();
 
    ++invocation_counts[msg];
 
    long long t = get_nsec_time();
    last_times[msg] = (t - enter_times[msg]);
    cumulative_times[msg] += (t - enter_times[msg]);
 
    long long cpu_t = get_nsec_cpu_time();
    last_cpu_times[msg] = (cpu_t - enter_cpu_times[msg]);
 
#ifdef PROFILE_OP_COUNTS
    for (std::pair<std::string, long long*> p : op_data_points)
    {
        cumulative_op_counts[std::make_pair(msg, p.first)] += *(p.second)-op_counts[std::make_pair(msg, p.first)];
    }
#endif
 
    if (inhibit_profiling_info)
    {
        return;
    }
 
#ifdef MULTICORE
#pragma omp critical
#endif
    {
        if (indent)
        {
            --indentation;
        }
 
        print_indent();
        printf("(leave) %-35s\t", msg.c_str());
        print_times_from_last_and_start(t, enter_times[msg], cpu_t, enter_cpu_times[msg]);
        print_op_profiling(msg);
        printf("\n");
        fflush(stdout);
    }
}

Here is the call graph for this function:

◆ log2()

size_t libff::log2 ( size_t n )

Definition at line 32 of file utils.cpp.

{
    size_t r = ((n & (n-1)) == 0 ? 0 : 1); // add 1 if n is not power of 2
 
    while (n > 1)
    {
        n >>= 1;
        r++;
    }
 
    return r;
}

◆ mixed_addition_step_for_flipped_miller_loop() [1/4]

void libff::mixed_addition_step_for_flipped_miller_loop	(	const alt_bn128_G2	base,
		alt_bn128_G2 &	current,
		alt_bn128_ate_ell_coeffs &	c )

Definition at line 267 of file alt_bn128_pairing.cpp.

{
    const alt_bn128_Fq2 X1 = current.X, Y1 = current.Y, Z1 = current.Z;
    const alt_bn128_Fq2 &x2 = base.X, &y2 = base.Y;
 
    const alt_bn128_Fq2 D = X1 - x2 * Z1;          // D = X1 - X2*Z1
    const alt_bn128_Fq2 E = Y1 - y2 * Z1;          // E = Y1 - Y2*Z1
    const alt_bn128_Fq2 F = D.squared();           // F = D^2
    const alt_bn128_Fq2 G = E.squared();           // G = E^2
    const alt_bn128_Fq2 H = D*F;                   // H = D*F
    const alt_bn128_Fq2 I = X1 * F;                // I = X1 * F
    const alt_bn128_Fq2 J = H + Z1*G - (I+I);      // J = H + Z1*G - (I+I)
 
    current.X = D * J;                           // X3 = D*J
    current.Y = E * (I-J)-(H * Y1);              // Y3 = E*(I-J)-(H*Y1)
    current.Z = Z1 * H;                          // Z3 = Z1*H
    c.ell_0 = alt_bn128_twist * (E * x2 - D * y2); // ell_0 = xi * (E * X2 - D * Y2)
    c.ell_VV = - E;                              // ell_VV = - E (later: * xP)
    c.ell_VW = D;                                // ell_VW = D (later: * yP    )
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mixed_addition_step_for_flipped_miller_loop() [2/4]

void libff::mixed_addition_step_for_flipped_miller_loop	(	const extended_edwards_G2_projective &	base,
		extended_edwards_G2_projective &	current,
		edwards_Fq3_conic_coefficients &	cc )

Definition at line 541 of file edwards_pairing.cpp.

{
    const edwards_Fq3 &X1 = current.X, &Y1 = current.Y, &Z1 = current.Z, &T1 = current.T;
    const edwards_Fq3 &X2 = base.X, &Y2 =  base.Y, &T2 = base.T;
 
    const edwards_Fq3 A = X1*X2;               // A    = X1*X2
    const edwards_Fq3 B = Y1*Y2;               // B    = Y1*Y2
    const edwards_Fq3 C = Z1*T2;               // C    = Z1*T2
    const edwards_Fq3 E = T1+C;                // E    = T1+C
    const edwards_Fq3 F = (X1-Y1)*(X2+Y2)+B-A; // F    = (X1-Y1)*(X2+Y2)+B-A
    // G = B + twisted_edwards_a * A
    const edwards_Fq3 G = B + edwards_G2::mul_by_a(A); // edwards_param_twist_coeff_a is 1*X for us
    const edwards_Fq3 H = T1-C;                // H    = T1-C
    const edwards_Fq3 I = T1*T2;               // I    = T1*T2
 
    // c_ZZ = delta_3* ((T1-X1)*(T2+X2)-I+A)
    cc.c_ZZ = edwards_G2::mul_by_a((T1-X1)*(T2+X2)-I+A); // edwards_param_twist_coeff_a is 1*X for us
 
    cc.c_XY = X1-X2*Z1+F;             // c_XY = X1*Z2-X2*Z1+F
    cc.c_XZ = (Y1-T1)*(Y2+T2)-B+I-H;  // c_XZ = (Y1-T1)*(Y2+T2)-B+I-H
    current.X = E*F;                  // X3   = E*F
    current.Y = G*H;                  // Y3   = G*H
    current.Z = F*G;                  // Z3   = F*G
    current.T = E*H;                  // T3   = E*H
 
#ifdef DEBUG
    current.test_invariant();
#endif
}

Here is the call graph for this function:

◆ mixed_addition_step_for_flipped_miller_loop() [3/4]

void libff::mixed_addition_step_for_flipped_miller_loop	(	const mnt4_Fq2	base_X,
		const mnt4_Fq2	base_Y,
		const mnt4_Fq2	base_Y_squared,
		extended_mnt4_G2_projective &	current,
		mnt4_ate_add_coeffs &	ac )

Definition at line 438 of file mnt4_pairing.cpp.

{
    const mnt4_Fq2 X1 = current.X, Y1 = current.Y, Z1 = current.Z, T1 = current.T;
    const mnt4_Fq2 &x2 = base_X,    &y2 =  base_Y, &y2_squared = base_Y_squared;
 
    const mnt4_Fq2 B = x2 * T1; // B = x2 * T1
    const mnt4_Fq2 D = ((y2 + Z1).squared() - y2_squared - T1) * T1; // D = ((y2 + Z1)^2 - y2squared - T1) * T1
    const mnt4_Fq2 H = B - X1; // H = B - X1
    const mnt4_Fq2 I = H.squared(); // I = H^2
    const mnt4_Fq2 E = I + I + I + I; // E = 4*I
    const mnt4_Fq2 J = H * E; // J = H * E
    const mnt4_Fq2 V = X1 * E; // V = X1 * E
    const mnt4_Fq2 L1 = D - (Y1 + Y1); // L1 = D - 2 * Y1
 
    current.X = L1.squared() - J - (V+V); // X3 = L1^2 - J - 2*V
    current.Y = L1 * (V-current.X) - (Y1+Y1) * J; // Y3 = L1 * (V-X3) - 2*Y1 * J
    current.Z = (Z1+H).squared() - T1 - I; // Z3 = (Z1 + H)^2 - T1 - I
    current.T = current.Z.squared(); // T3 = Z3^2
 
    ac.c_L1 = L1;
    ac.c_RZ = current.Z;
#ifdef DEBUG
    current.test_invariant();
#endif
}

Here is the call graph for this function:

◆ mixed_addition_step_for_flipped_miller_loop() [4/4]

void libff::mixed_addition_step_for_flipped_miller_loop	(	const mnt6_Fq3	base_X,
		const mnt6_Fq3	base_Y,
		const mnt6_Fq3	base_Y_squared,
		extended_mnt6_G2_projective &	current,
		mnt6_ate_add_coeffs &	ac )

Definition at line 444 of file mnt6_pairing.cpp.

{
    const mnt6_Fq3 X1 = current.X, Y1 = current.Y, Z1 = current.Z, T1 = current.T;
    const mnt6_Fq3 &x2 = base_X,    &y2 =  base_Y, &y2_squared = base_Y_squared;
 
    const mnt6_Fq3 B = x2 * T1; // B = x2 * T1
    const mnt6_Fq3 D = ((y2 + Z1).squared() - y2_squared - T1) * T1; // D = ((y2 + Z1)^2 - y2squared - T1) * T1
    const mnt6_Fq3 H = B - X1; // H = B - X1
    const mnt6_Fq3 I = H.squared(); // I = H^2
    const mnt6_Fq3 E = I + I + I + I; // E = 4*I
    const mnt6_Fq3 J = H * E; // J = H * E
    const mnt6_Fq3 V = X1 * E; // V = X1 * E
    const mnt6_Fq3 L1 = D - (Y1 + Y1); // L1 = D - 2 * Y1
 
    current.X = L1.squared() - J - (V+V); // X3 = L1^2 - J - 2*V
    current.Y = L1 * (V-current.X) - (Y1+Y1) * J; // Y3 = L1 * (V-X3) - 2*Y1 * J
    current.Z = (Z1+H).squared() - T1 - I; // Z3 = (Z1 + H)^2 - T1 - I
    current.T = current.Z.squared(); // T3 = Z3^2
 
    ac.c_L1 = L1;
    ac.c_RZ = current.Z;
#ifdef DEBUG
    current.test_invariant();
#endif
}

Here is the call graph for this function:

◆ mixed_addition_step_for_miller_loop()

void libff::mixed_addition_step_for_miller_loop	(	const extended_edwards_G1_projective &	base,
		extended_edwards_G1_projective &	current,
		edwards_Fq_conic_coefficients &	cc )

Definition at line 316 of file edwards_pairing.cpp.

{
    const edwards_Fq &X1 = current.X, &Y1 = current.Y, &Z1 = current.Z, &T1 = current.T;
    const edwards_Fq &X2 = base.X, &Y2 =  base.Y, &T2 = base.T;
 
    const edwards_Fq A = X1*X2;               // A    = X1*X2
    const edwards_Fq B = Y1*Y2;               // B    = Y1*Y2
    const edwards_Fq C = Z1*T2;               // C    = Z1*T2
    const edwards_Fq D = T1;                  // D    = T1*Z2
    const edwards_Fq E = D+C;                 // E    = D+C
    const edwards_Fq F = (X1-Y1)*(X2+Y2)+B-A; // F    = (X1-Y1)*(X2+Y2)+B-A
    const edwards_Fq G = B + A;               // G    = B + A (edwards_a=1)
    const edwards_Fq H = D-C;                 // H    = D-C
    const edwards_Fq I = T1*T2;               // I    = T1*T2
 
    cc.c_ZZ = (T1-X1)*(T2+X2)-I+A;    // c_ZZ = (T1-X1)*(T2+X2)-I+A
    cc.c_XY = X1-X2*Z1+F;             // c_XY = X1*Z2-X2*Z1+F
    cc.c_XZ = (Y1-T1)*(Y2+T2)-B+I-H;  // c_XZ = (Y1-T1)*(Y2+T2)-B+I-H
    current.X = E*F;                  // X3   = E*F
    current.Y = G*H;                  // Y3   = G*H
    current.Z = F*G;                  // Z3   = F*G
    current.T = E*H;                  // T3   = E*H
 
#ifdef DEBUG
    current.test_invariant();
#endif
}

Here is the caller graph for this function:

◆ mnt4_affine_ate_miller_loop()

mnt4_Fq4 libff::mnt4_affine_ate_miller_loop	(	const mnt4_affine_ate_G1_precomputation &	prec_P,
		const mnt4_affine_ate_G2_precomputation &	prec_Q )

Definition at line 323 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_affine_ate_miller_loop");
 
    mnt4_Fq4 f = mnt4_Fq4::one();
 
    bool found_nonzero = false;
    size_t idx = 0;
    const bigint<mnt4_Fr::num_limbs> &loop_count = mnt4_ate_loop_count;
 
    std::vector<long> NAF = find_wnaf(1, loop_count);
    for (long i = NAF.size() - 1; i >= 0; --i)
    {
        if (!found_nonzero)
        {
            /* this skips the MSB itself */
            found_nonzero |= (NAF[i] != 0);
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           mnt4_param_p (skipping leading zeros) in MSB to LSB
           order */
        mnt4_affine_ate_coeffs c = prec_Q.coeffs[idx++];
 
        mnt4_Fq4 g_RR_at_P = mnt4_Fq4(prec_P.PY_twist_squared,
                                      - prec_P.PX * c.gamma_twist + c.gamma_X - c.old_RY);
        f = f.squared().mul_by_023(g_RR_at_P);
 
        if (NAF[i] != 0)
        {
            mnt4_affine_ate_coeffs c = prec_Q.coeffs[idx++];
            mnt4_Fq4 g_RQ_at_P;
            if (NAF[i] > 0)
            {
                g_RQ_at_P = mnt4_Fq4(prec_P.PY_twist_squared,
                                     - prec_P.PX * c.gamma_twist + c.gamma_X - prec_Q.QY);
            }
            else
            {
                g_RQ_at_P = mnt4_Fq4(prec_P.PY_twist_squared,
                                     - prec_P.PX * c.gamma_twist + c.gamma_X + prec_Q.QY);
            }
            f = f.mul_by_023(g_RQ_at_P);
        }
    }
 
    /* TODO: maybe handle neg
       if (mnt4_ate_is_loop_count_neg)
       {
       // TODO:
       mnt4_affine_ate_coeffs ac = prec_Q.coeffs[idx++];
       mnt4_Fq4 g_RnegR_at_P = mnt4_Fq4(prec_P.PY_twist_squared,
       - prec_P.PX * c.gamma_twist + c.gamma_X - c.old_RY);
       f = (f * g_RnegR_at_P).inverse();
       }
    */
 
    leave_block("Call to mnt4_affine_ate_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_affine_ate_precompute_G1()

mnt4_affine_ate_G1_precomputation libff::mnt4_affine_ate_precompute_G1 ( const mnt4_G1 & P )

Definition at line 227 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_affine_ate_precompute_G1");
 
    mnt4_G1 Pcopy = P;
    Pcopy.to_affine_coordinates();
 
    mnt4_affine_ate_G1_precomputation result;
    result.PX = Pcopy.X;
    result.PY = Pcopy.Y;
    result.PY_twist_squared = Pcopy.Y * mnt4_twist.squared();
 
    leave_block("Call to mnt4_affine_ate_precompute_G1");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_affine_ate_precompute_G2()

mnt4_affine_ate_G2_precomputation libff::mnt4_affine_ate_precompute_G2 ( const mnt4_G2 & Q )

Definition at line 243 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_affine_ate_precompute_G2");
 
    mnt4_G2 Qcopy(Q);
    Qcopy.to_affine_coordinates();
 
    mnt4_affine_ate_G2_precomputation result;
    result.QX = Qcopy.X;
    result.QY = Qcopy.Y;
 
    mnt4_Fq2 RX = Qcopy.X;
    mnt4_Fq2 RY = Qcopy.Y;
 
    const bigint<mnt4_Fr::num_limbs> &loop_count = mnt4_ate_loop_count;
    bool found_nonzero = false;
 
    std::vector<long> NAF = find_wnaf(1, loop_count);
    for (long i = NAF.size() - 1; i >= 0; --i)
    {
        if (!found_nonzero)
        {
            /* this skips the MSB itself */
            found_nonzero |= (NAF[i] != 0);
            continue;
        }
 
        mnt4_affine_ate_coeffs c;
        c.old_RX = RX;
        c.old_RY = RY;
        mnt4_Fq2 old_RX_2 = c.old_RX.squared();
        c.gamma = (old_RX_2 + old_RX_2 + old_RX_2 + mnt4_twist_coeff_a) * (c.old_RY + c.old_RY).inverse();
        c.gamma_twist = c.gamma * mnt4_twist;
        c.gamma_X = c.gamma * c.old_RX;
        result.coeffs.push_back(c);
 
        RX = c.gamma.squared() - (c.old_RX+c.old_RX);
        RY = c.gamma * (c.old_RX - RX) - c.old_RY;
 
        if (NAF[i] != 0)
        {
            mnt4_affine_ate_coeffs c;
            c.old_RX = RX;
            c.old_RY = RY;
            if (NAF[i] > 0)
            {
                c.gamma = (c.old_RY - result.QY) * (c.old_RX - result.QX).inverse();
            }
            else
            {
                c.gamma = (c.old_RY + result.QY) * (c.old_RX - result.QX).inverse();
            }
            c.gamma_twist = c.gamma * mnt4_twist;
            c.gamma_X = c.gamma * result.QX;
            result.coeffs.push_back(c);
 
            RX = c.gamma.squared() - (c.old_RX+result.QX);
            RY = c.gamma * (c.old_RX - RX) - c.old_RY;
        }
    }
 
    /* TODO: maybe handle neg
       if (mnt4_ate_is_loop_count_neg)
       {
       mnt4_ate_add_coeffs ac;
       mnt4_affine_ate_dbl_coeffs c;
       c.old_RX = RX;
       c.old_RY = -RY;
       old_RX_2 = c.old_RY.squared();
       c.gamma = (old_RX_2 + old_RX_2 + old_RX_2 + mnt4_coeff_a) * (c.old_RY + c.old_RY).inverse();
       c.gamma_twist = c.gamma * mnt4_twist;
       c.gamma_X = c.gamma * c.old_RX;
       result.coeffs.push_back(c);
       }
    */
 
    leave_block("Call to mnt4_affine_ate_precompute_G2");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_affine_reduced_pairing()

mnt4_GT libff::mnt4_affine_reduced_pairing	(	const mnt4_G1 &	P,
		const mnt4_G2 &	Q )

Definition at line 731 of file mnt4_pairing.cpp.

{
    const mnt4_affine_ate_G1_precomputation prec_P = mnt4_affine_ate_precompute_G1(P);
    const mnt4_affine_ate_G2_precomputation prec_Q = mnt4_affine_ate_precompute_G2(Q);
    const mnt4_Fq4 f = mnt4_affine_ate_miller_loop(prec_P, prec_Q);
    const mnt4_GT result = mnt4_final_exponentiation(f);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_ate_double_miller_loop()

mnt4_Fq4 libff::mnt4_ate_double_miller_loop	(	const mnt4_ate_G1_precomp &	prec_P1,
		const mnt4_ate_G2_precomp &	prec_Q1,
		const mnt4_ate_G1_precomp &	prec_P2,
		const mnt4_ate_G2_precomp &	prec_Q2 )

Definition at line 600 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_ate_double_miller_loop");
 
    mnt4_Fq2 L1_coeff1 = mnt4_Fq2(prec_P1.PX, mnt4_Fq::zero()) - prec_Q1.QX_over_twist;
    mnt4_Fq2 L1_coeff2 = mnt4_Fq2(prec_P2.PX, mnt4_Fq::zero()) - prec_Q2.QX_over_twist;
 
    mnt4_Fq4 f = mnt4_Fq4::one();
 
    bool found_one = false;
    size_t dbl_idx = 0;
    size_t add_idx = 0;
 
    const bigint<mnt4_Fr::num_limbs> &loop_count = mnt4_ate_loop_count;
    for (long i = loop_count.max_bits() - 1; i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
 
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           mnt4_param_p (skipping leading zeros) in MSB to LSB
           order */
        mnt4_ate_dbl_coeffs dc1 = prec_Q1.dbl_coeffs[dbl_idx];
        mnt4_ate_dbl_coeffs dc2 = prec_Q2.dbl_coeffs[dbl_idx];
        ++dbl_idx;
 
        mnt4_Fq4 g_RR_at_P1 = mnt4_Fq4(- dc1.c_4C - dc1.c_J * prec_P1.PX_twist + dc1.c_L,
                                       dc1.c_H * prec_P1.PY_twist);
 
        mnt4_Fq4 g_RR_at_P2 = mnt4_Fq4(- dc2.c_4C - dc2.c_J * prec_P2.PX_twist + dc2.c_L,
                                       dc2.c_H * prec_P2.PY_twist);
 
        f = f.squared() * g_RR_at_P1 * g_RR_at_P2;
 
        if (bit)
        {
            mnt4_ate_add_coeffs ac1 = prec_Q1.add_coeffs[add_idx];
            mnt4_ate_add_coeffs ac2 = prec_Q2.add_coeffs[add_idx];
            ++add_idx;
 
            mnt4_Fq4 g_RQ_at_P1 = mnt4_Fq4(ac1.c_RZ * prec_P1.PY_twist,
                                           -(prec_Q1.QY_over_twist * ac1.c_RZ + L1_coeff1 * ac1.c_L1));
            mnt4_Fq4 g_RQ_at_P2 = mnt4_Fq4(ac2.c_RZ * prec_P2.PY_twist,
                                           -(prec_Q2.QY_over_twist * ac2.c_RZ + L1_coeff2 * ac2.c_L1));
 
            f = f * g_RQ_at_P1 * g_RQ_at_P2;
        }
    }
 
    if (mnt4_ate_is_loop_count_neg)
    {
        mnt4_ate_add_coeffs ac1 = prec_Q1.add_coeffs[add_idx];
        mnt4_ate_add_coeffs ac2 = prec_Q2.add_coeffs[add_idx];
        ++add_idx;
        mnt4_Fq4 g_RnegR_at_P1 = mnt4_Fq4(ac1.c_RZ * prec_P1.PY_twist,
                                          -(prec_Q1.QY_over_twist * ac1.c_RZ + L1_coeff1 * ac1.c_L1));
        mnt4_Fq4 g_RnegR_at_P2 = mnt4_Fq4(ac2.c_RZ * prec_P2.PY_twist,
                                          -(prec_Q2.QY_over_twist * ac2.c_RZ + L1_coeff2 * ac2.c_L1));
 
        f = (f * g_RnegR_at_P1 * g_RnegR_at_P2).inverse();
    }
 
    leave_block("Call to mnt4_ate_double_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_ate_miller_loop()

mnt4_Fq4 libff::mnt4_ate_miller_loop	(	const mnt4_ate_G1_precomp &	prec_P,
		const mnt4_ate_G2_precomp &	prec_Q )

Definition at line 544 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_ate_miller_loop");
 
    mnt4_Fq2 L1_coeff = mnt4_Fq2(prec_P.PX, mnt4_Fq::zero()) - prec_Q.QX_over_twist;
 
    mnt4_Fq4 f = mnt4_Fq4::one();
 
    bool found_one = false;
    size_t dbl_idx = 0;
    size_t add_idx = 0;
 
    const bigint<mnt4_Fr::num_limbs> &loop_count = mnt4_ate_loop_count;
    for (long i = loop_count.max_bits() - 1; i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
 
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           mnt4_param_p (skipping leading zeros) in MSB to LSB
           order */
        mnt4_ate_dbl_coeffs dc = prec_Q.dbl_coeffs[dbl_idx++];
 
        mnt4_Fq4 g_RR_at_P = mnt4_Fq4(- dc.c_4C - dc.c_J * prec_P.PX_twist + dc.c_L,
                                      dc.c_H * prec_P.PY_twist);
        f = f.squared() * g_RR_at_P;
        if (bit)
        {
            mnt4_ate_add_coeffs ac = prec_Q.add_coeffs[add_idx++];
 
            mnt4_Fq4 g_RQ_at_P = mnt4_Fq4(ac.c_RZ * prec_P.PY_twist,
                                          -(prec_Q.QY_over_twist * ac.c_RZ + L1_coeff * ac.c_L1));
            f = f * g_RQ_at_P;
        }
    }
 
    if (mnt4_ate_is_loop_count_neg)
    {
        mnt4_ate_add_coeffs ac = prec_Q.add_coeffs[add_idx++];
        mnt4_Fq4 g_RnegR_at_P = mnt4_Fq4(ac.c_RZ * prec_P.PY_twist,
                                         -(prec_Q.QY_over_twist * ac.c_RZ + L1_coeff * ac.c_L1));
        f = (f * g_RnegR_at_P).inverse();
    }
 
    leave_block("Call to mnt4_ate_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_ate_pairing()

mnt4_Fq4 libff::mnt4_ate_pairing	(	const mnt4_G1 &	P,
		const mnt4_G2 &	Q )

Definition at line 676 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_ate_pairing");
    mnt4_ate_G1_precomp prec_P = mnt4_ate_precompute_G1(P);
    mnt4_ate_G2_precomp prec_Q = mnt4_ate_precompute_G2(Q);
    mnt4_Fq4 result = mnt4_ate_miller_loop(prec_P, prec_Q);
    leave_block("Call to mnt4_ate_pairing");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_ate_precompute_G1()

mnt4_ate_G1_precomp libff::mnt4_ate_precompute_G1 ( const mnt4_G1 & P )

Definition at line 466 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_ate_precompute_G1");
 
    mnt4_G1 Pcopy = P;
    Pcopy.to_affine_coordinates();
 
    mnt4_ate_G1_precomp result;
    result.PX = Pcopy.X;
    result.PY = Pcopy.Y;
    result.PX_twist = Pcopy.X * mnt4_twist;
    result.PY_twist = Pcopy.Y * mnt4_twist;
 
    leave_block("Call to mnt4_ate_precompute_G1");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_ate_precompute_G2()

mnt4_ate_G2_precomp libff::mnt4_ate_precompute_G2 ( const mnt4_G2 & Q )

Definition at line 483 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_ate_precompute_G2");
 
    mnt4_G2 Qcopy(Q);
    Qcopy.to_affine_coordinates();
 
    mnt4_ate_G2_precomp result;
    result.QX = Qcopy.X;
    result.QY = Qcopy.Y;
    result.QY2 = Qcopy.Y.squared();
    result.QX_over_twist = Qcopy.X * mnt4_twist.inverse();
    result.QY_over_twist = Qcopy.Y * mnt4_twist.inverse();
 
    extended_mnt4_G2_projective R;
    R.X = Qcopy.X;
    R.Y = Qcopy.Y;
    R.Z = mnt4_Fq2::one();
    R.T = mnt4_Fq2::one();
 
    const bigint<mnt4_Fr::num_limbs> &loop_count = mnt4_ate_loop_count;
    bool found_one = false;
 
    for (long i = loop_count.max_bits() - 1; i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        mnt4_ate_dbl_coeffs dc;
        doubling_step_for_flipped_miller_loop(R, dc);
        result.dbl_coeffs.push_back(dc);
        if (bit)
        {
            mnt4_ate_add_coeffs ac;
            mixed_addition_step_for_flipped_miller_loop(result.QX, result.QY, result.QY2, R, ac);
            result.add_coeffs.push_back(ac);
        }
    }
 
    if (mnt4_ate_is_loop_count_neg)
    {
        mnt4_Fq2 RZ_inv = R.Z.inverse();
        mnt4_Fq2 RZ2_inv = RZ_inv.squared();
        mnt4_Fq2 RZ3_inv = RZ2_inv * RZ_inv;
        mnt4_Fq2 minus_R_affine_X = R.X * RZ2_inv;
        mnt4_Fq2 minus_R_affine_Y = - R.Y * RZ3_inv;
        mnt4_Fq2 minus_R_affine_Y2 = minus_R_affine_Y.squared();
        mnt4_ate_add_coeffs ac;
        mixed_addition_step_for_flipped_miller_loop(minus_R_affine_X, minus_R_affine_Y, minus_R_affine_Y2, R, ac);
        result.add_coeffs.push_back(ac);
    }
 
    leave_block("Call to mnt4_ate_precompute_G2");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_ate_reduced_pairing()

mnt4_GT libff::mnt4_ate_reduced_pairing	(	const mnt4_G1 &	P,
		const mnt4_G2 &	Q )

Definition at line 686 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_ate_reduced_pairing");
    const mnt4_Fq4 f = mnt4_ate_pairing(P, Q);
    const mnt4_GT result = mnt4_final_exponentiation(f);
    leave_block("Call to mnt4_ate_reduced_pairing");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_double_miller_loop()

mnt4_Fq4 libff::mnt4_double_miller_loop	(	const mnt4_G1_precomp &	prec_P1,
		const mnt4_G2_precomp &	prec_Q1,
		const mnt4_G1_precomp &	prec_P2,
		const mnt4_G2_precomp &	prec_Q2 )

Definition at line 711 of file mnt4_pairing.cpp.

{
    return mnt4_ate_double_miller_loop(prec_P1, prec_Q1, prec_P2, prec_Q2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_final_exponentiation()

mnt4_GT libff::mnt4_final_exponentiation ( const mnt4_Fq4 & elt )

Definition at line 213 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_final_exponentiation");
    const mnt4_Fq4 elt_inv = elt.inverse();
    const mnt4_Fq4 elt_to_first_chunk = mnt4_final_exponentiation_first_chunk(elt, elt_inv);
    const mnt4_Fq4 elt_inv_to_first_chunk = mnt4_final_exponentiation_first_chunk(elt_inv, elt);
    mnt4_GT result = mnt4_final_exponentiation_last_chunk(elt_to_first_chunk, elt_inv_to_first_chunk);
    leave_block("Call to mnt4_final_exponentiation");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_final_exponentiation_first_chunk()

mnt4_Fq4 libff::mnt4_final_exponentiation_first_chunk	(	const mnt4_Fq4 &	elt,
		const mnt4_Fq4 &	elt_inv )

Definition at line 198 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_final_exponentiation_first_chunk");
 
    /* (q^2-1) */
 
    /* elt_q2 = elt^(q^2) */
    const mnt4_Fq4 elt_q2 = elt.Frobenius_map(2);
    /* elt_q3_over_elt = elt^(q^2-1) */
    const mnt4_Fq4 elt_q2_over_elt = elt_q2 * elt_inv;
 
    leave_block("Call to mnt4_final_exponentiation_first_chunk");
    return elt_q2_over_elt;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_final_exponentiation_last_chunk()

mnt4_Fq4 libff::mnt4_final_exponentiation_last_chunk	(	const mnt4_Fq4 &	elt,
		const mnt4_Fq4 &	elt_inv )

Definition at line 180 of file mnt4_pairing.cpp.

{
    enter_block("Call to mnt4_final_exponentiation_last_chunk");
    const mnt4_Fq4 elt_q = elt.Frobenius_map(1);
    mnt4_Fq4 w1_part = elt_q.cyclotomic_exp(mnt4_final_exponent_last_chunk_w1);
    mnt4_Fq4 w0_part;
    if (mnt4_final_exponent_last_chunk_is_w0_neg)
    {
        w0_part = elt_inv.cyclotomic_exp(mnt4_final_exponent_last_chunk_abs_of_w0);
    } else {
        w0_part = elt.cyclotomic_exp(mnt4_final_exponent_last_chunk_abs_of_w0);
    }
    mnt4_Fq4 result = w1_part * w0_part;
    leave_block("Call to mnt4_final_exponentiation_last_chunk");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_miller_loop()

mnt4_Fq4 libff::mnt4_miller_loop	(	const mnt4_G1_precomp &	prec_P,
		const mnt4_G2_precomp &	prec_Q )

Definition at line 705 of file mnt4_pairing.cpp.

{
    return mnt4_ate_miller_loop(prec_P, prec_Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_pairing()

mnt4_Fq4 libff::mnt4_pairing	(	const mnt4_G1 &	P,
		const mnt4_G2 &	Q )

Definition at line 719 of file mnt4_pairing.cpp.

{
    return mnt4_ate_pairing(P, Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_precompute_G1()

mnt4_G1_precomp libff::mnt4_precompute_G1 ( const mnt4_G1 & P )

Definition at line 695 of file mnt4_pairing.cpp.

{
    return mnt4_ate_precompute_G1(P);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_precompute_G2()

mnt4_G2_precomp libff::mnt4_precompute_G2 ( const mnt4_G2 & Q )

Definition at line 700 of file mnt4_pairing.cpp.

{
    return mnt4_ate_precompute_G2(Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt4_reduced_pairing()

mnt4_GT libff::mnt4_reduced_pairing	(	const mnt4_G1 &	P,
		const mnt4_G2 &	Q )

Definition at line 725 of file mnt4_pairing.cpp.

{
    return mnt4_ate_reduced_pairing(P, Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_affine_ate_miller_loop()

mnt6_Fq6 libff::mnt6_affine_ate_miller_loop	(	const mnt6_affine_ate_G1_precomputation &	prec_P,
		const mnt6_affine_ate_G2_precomputation &	prec_Q )

Definition at line 328 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_affine_ate_miller_loop");
 
    mnt6_Fq6 f = mnt6_Fq6::one();
 
    const bigint<mnt6_Fr::num_limbs> &loop_count = mnt6_ate_loop_count;
    bool found_nonzero = false;
    size_t idx = 0;
 
    std::vector<long> NAF = find_wnaf(1, loop_count);
    for (long i = NAF.size() - 1; i >= 0; --i)
    {
        if (!found_nonzero)
        {
            /* this skips the MSB itself */
            found_nonzero |= (NAF[i] != 0);
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           mnt6_param_p (skipping leading zeros) in MSB to LSB
           order */
        mnt6_affine_ate_coeffs c = prec_Q.coeffs[idx++];
 
        mnt6_Fq6 g_RR_at_P = mnt6_Fq6(prec_P.PY_twist_squared,
                                      - prec_P.PX * c.gamma_twist + c.gamma_X - c.old_RY);
        f = f.squared().mul_by_2345(g_RR_at_P);
 
        if (NAF[i] != 0)
        {
            mnt6_affine_ate_coeffs c = prec_Q.coeffs[idx++];
            mnt6_Fq6 g_RQ_at_P;
            if (NAF[i] > 0)
            {
                g_RQ_at_P = mnt6_Fq6(prec_P.PY_twist_squared,
                                     - prec_P.PX * c.gamma_twist + c.gamma_X - prec_Q.QY);
            }
            else
            {
                g_RQ_at_P = mnt6_Fq6(prec_P.PY_twist_squared,
                                     - prec_P.PX * c.gamma_twist + c.gamma_X + prec_Q.QY);
            }
            f = f.mul_by_2345(g_RQ_at_P);
        }
 
    }
 
    /* TODO: maybe handle neg
    if (mnt6_ate_is_loop_count_neg)
    {
        // TODO:
        mnt6_affine_ate_coeffs ac = prec_Q.coeffs[idx++];
        mnt6_Fq6 g_RnegR_at_P = mnt6_Fq6(prec_P.PY_twist_squared,
                                          - prec_P.PX * c.gamma_twist + c.gamma_X - c.old_RY);
        f = (f * g_RnegR_at_P).inverse();
    }
    */
 
    leave_block("Call to mnt6_affine_ate_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_affine_ate_precompute_G1()

mnt6_affine_ate_G1_precomputation libff::mnt6_affine_ate_precompute_G1 ( const mnt6_G1 & P )

Definition at line 232 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_affine_ate_precompute_G1");
 
    mnt6_G1 Pcopy = P;
    Pcopy.to_affine_coordinates();
 
    mnt6_affine_ate_G1_precomputation result;
    result.PX = Pcopy.X;
    result.PY = Pcopy.Y;
    result.PY_twist_squared = Pcopy.Y * mnt6_twist.squared();
 
    leave_block("Call to mnt6_affine_ate_precompute_G1");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_affine_ate_precompute_G2()

mnt6_affine_ate_G2_precomputation libff::mnt6_affine_ate_precompute_G2 ( const mnt6_G2 & Q )

Definition at line 248 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_affine_ate_precompute_G2");
 
    mnt6_G2 Qcopy(Q);
    Qcopy.to_affine_coordinates();
 
    mnt6_affine_ate_G2_precomputation result;
    result.QX = Qcopy.X;
    result.QY = Qcopy.Y;
 
    mnt6_Fq3 RX = Qcopy.X;
    mnt6_Fq3 RY = Qcopy.Y;
 
    const bigint<mnt6_Fr::num_limbs> &loop_count = mnt6_ate_loop_count;
    bool found_nonzero = false;
 
    std::vector<long> NAF = find_wnaf(1, loop_count);
    for (long i = NAF.size() - 1; i >= 0; --i)
    {
        if (!found_nonzero)
        {
            /* this skips the MSB itself */
            found_nonzero |= (NAF[i] != 0);
            continue;
        }
 
        mnt6_affine_ate_coeffs c;
        c.old_RX = RX;
        c.old_RY = RY;
        mnt6_Fq3 old_RX_2 = c.old_RX.squared();
        c.gamma = (old_RX_2 + old_RX_2 + old_RX_2 + mnt6_twist_coeff_a) * (c.old_RY + c.old_RY).inverse();
        c.gamma_twist = c.gamma * mnt6_twist;
        c.gamma_X = c.gamma * c.old_RX;
        result.coeffs.push_back(c);
 
        RX = c.gamma.squared() - (c.old_RX+c.old_RX);
        RY = c.gamma * (c.old_RX - RX) - c.old_RY;
 
        if (NAF[i] != 0)
        {
            mnt6_affine_ate_coeffs c;
            c.old_RX = RX;
            c.old_RY = RY;
            if (NAF[i] > 0)
            {
                c.gamma = (c.old_RY - result.QY) * (c.old_RX - result.QX).inverse();
            }
            else
            {
                c.gamma = (c.old_RY + result.QY) * (c.old_RX - result.QX).inverse();
            }
            c.gamma_twist = c.gamma * mnt6_twist;
            c.gamma_X = c.gamma * result.QX;
            result.coeffs.push_back(c);
 
            RX = c.gamma.squared() - (c.old_RX+result.QX);
            RY = c.gamma * (c.old_RX - RX) - c.old_RY;
        }
    }
 
    /* TODO: maybe handle neg
    if (mnt6_ate_is_loop_count_neg)
    {
        mnt6_ate_add_coeffs ac;
        mnt6_affine_ate_dbl_coeffs c;
        c.old_RX = RX;
        c.old_RY = -RY;
        old_RX_2 = c.old_RY.squared();
        c.gamma = (old_RX_2 + old_RX_2 + old_RX_2 + mnt6_coeff_a) * (c.old_RY + c.old_RY).inverse();
        c.gamma_twist = c.gamma * mnt6_twist;
        c.gamma_X = c.gamma * c.old_RX;
        result.coeffs.push_back(c);
    }
    */
 
    leave_block("Call to mnt6_affine_ate_precompute_G2");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_affine_reduced_pairing()

mnt6_GT libff::mnt6_affine_reduced_pairing	(	const mnt6_G1 &	P,
		const mnt6_G2 &	Q )

Definition at line 743 of file mnt6_pairing.cpp.

{
    const mnt6_affine_ate_G1_precomputation prec_P = mnt6_affine_ate_precompute_G1(P);
    const mnt6_affine_ate_G2_precomputation prec_Q = mnt6_affine_ate_precompute_G2(Q);
    const mnt6_Fq6 f = mnt6_affine_ate_miller_loop(prec_P, prec_Q);
    const mnt6_GT result = mnt6_final_exponentiation(f);
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_ate_double_miller_loop()

mnt6_Fq6 libff::mnt6_ate_double_miller_loop	(	const mnt6_ate_G1_precomp &	prec_P1,
		const mnt6_ate_G2_precomp &	prec_Q1,
		const mnt6_ate_G1_precomp &	prec_P2,
		const mnt6_ate_G2_precomp &	prec_Q2 )

Definition at line 611 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_ate_double_miller_loop");
 
    mnt6_Fq3 L1_coeff1 = mnt6_Fq3(prec_P1.PX, mnt6_Fq::zero(), mnt6_Fq::zero()) - prec_Q1.QX_over_twist;
    mnt6_Fq3 L1_coeff2 = mnt6_Fq3(prec_P2.PX, mnt6_Fq::zero(), mnt6_Fq::zero()) - prec_Q2.QX_over_twist;
 
    mnt6_Fq6 f = mnt6_Fq6::one();
 
    bool found_one = false;
    size_t dbl_idx = 0;
    size_t add_idx = 0;
 
    const bigint<mnt6_Fr::num_limbs> &loop_count = mnt6_ate_loop_count;
 
    for (long i = loop_count.max_bits() - 1; i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
 
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           mnt6_param_p (skipping leading zeros) in MSB to LSB
           order */
        mnt6_ate_dbl_coeffs dc1 = prec_Q1.dbl_coeffs[dbl_idx];
        mnt6_ate_dbl_coeffs dc2 = prec_Q2.dbl_coeffs[dbl_idx];
        ++dbl_idx;
 
        mnt6_Fq6 g_RR_at_P1 = mnt6_Fq6(- dc1.c_4C - dc1.c_J * prec_P1.PX_twist + dc1.c_L,
                                       dc1.c_H * prec_P1.PY_twist);
 
        mnt6_Fq6 g_RR_at_P2 = mnt6_Fq6(- dc2.c_4C - dc2.c_J * prec_P2.PX_twist + dc2.c_L,
                                       dc2.c_H * prec_P2.PY_twist);
 
        f = f.squared() * g_RR_at_P1 * g_RR_at_P2;
 
        if (bit)
        {
            mnt6_ate_add_coeffs ac1 = prec_Q1.add_coeffs[add_idx];
            mnt6_ate_add_coeffs ac2 = prec_Q2.add_coeffs[add_idx];
            ++add_idx;
 
            mnt6_Fq6 g_RQ_at_P1 = mnt6_Fq6(ac1.c_RZ * prec_P1.PY_twist,
                                           -(prec_Q1.QY_over_twist * ac1.c_RZ + L1_coeff1 * ac1.c_L1));
            mnt6_Fq6 g_RQ_at_P2 = mnt6_Fq6(ac2.c_RZ * prec_P2.PY_twist,
                                           -(prec_Q2.QY_over_twist * ac2.c_RZ + L1_coeff2 * ac2.c_L1));
 
            f = f * g_RQ_at_P1 * g_RQ_at_P2;
        }
    }
 
    if (mnt6_ate_is_loop_count_neg)
    {
        mnt6_ate_add_coeffs ac1 = prec_Q1.add_coeffs[add_idx];
        mnt6_ate_add_coeffs ac2 = prec_Q2.add_coeffs[add_idx];
        ++add_idx;
        mnt6_Fq6 g_RnegR_at_P1 = mnt6_Fq6(ac1.c_RZ * prec_P1.PY_twist,
                                          -(prec_Q1.QY_over_twist * ac1.c_RZ + L1_coeff1 * ac1.c_L1));
        mnt6_Fq6 g_RnegR_at_P2 = mnt6_Fq6(ac2.c_RZ * prec_P2.PY_twist,
                                          -(prec_Q2.QY_over_twist * ac2.c_RZ + L1_coeff2 * ac2.c_L1));
 
        f = (f * g_RnegR_at_P1 * g_RnegR_at_P2).inverse();
    }
 
    leave_block("Call to mnt6_ate_double_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_ate_miller_loop()

mnt6_Fq6 libff::mnt6_ate_miller_loop	(	const mnt6_ate_G1_precomp &	prec_P,
		const mnt6_ate_G2_precomp &	prec_Q )

Definition at line 553 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_ate_miller_loop");
 
    mnt6_Fq3 L1_coeff = mnt6_Fq3(prec_P.PX, mnt6_Fq::zero(), mnt6_Fq::zero()) - prec_Q.QX_over_twist;
 
    mnt6_Fq6 f = mnt6_Fq6::one();
 
    bool found_one = false;
    size_t dbl_idx = 0;
    size_t add_idx = 0;
 
    const bigint<mnt6_Fr::num_limbs> &loop_count = mnt6_ate_loop_count;
 
    for (long i = loop_count.max_bits() - 1; i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
 
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        /* code below gets executed for all bits (EXCEPT the MSB itself) of
           mnt6_param_p (skipping leading zeros) in MSB to LSB
           order */
        mnt6_ate_dbl_coeffs dc = prec_Q.dbl_coeffs[dbl_idx++];
 
        mnt6_Fq6 g_RR_at_P = mnt6_Fq6(- dc.c_4C - dc.c_J * prec_P.PX_twist + dc.c_L,
                                      dc.c_H * prec_P.PY_twist);
        f = f.squared() * g_RR_at_P;
 
        if (bit)
        {
            mnt6_ate_add_coeffs ac = prec_Q.add_coeffs[add_idx++];
            mnt6_Fq6 g_RQ_at_P = mnt6_Fq6(ac.c_RZ * prec_P.PY_twist,
                                          -(prec_Q.QY_over_twist * ac.c_RZ + L1_coeff * ac.c_L1));
            f = f * g_RQ_at_P;
        }
 
    }
 
    if (mnt6_ate_is_loop_count_neg)
    {
        mnt6_ate_add_coeffs ac = prec_Q.add_coeffs[add_idx++];
        mnt6_Fq6 g_RnegR_at_P = mnt6_Fq6(ac.c_RZ * prec_P.PY_twist,
                                         -(prec_Q.QY_over_twist * ac.c_RZ + L1_coeff * ac.c_L1));
        f = (f * g_RnegR_at_P).inverse();
    }
 
    leave_block("Call to mnt6_ate_miller_loop");
 
    return f;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_ate_pairing()

mnt6_Fq6 libff::mnt6_ate_pairing	(	const mnt6_G1 &	P,
		const mnt6_G2 &	Q )

Definition at line 688 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_ate_pairing");
    mnt6_ate_G1_precomp prec_P = mnt6_ate_precompute_G1(P);
    mnt6_ate_G2_precomp prec_Q = mnt6_ate_precompute_G2(Q);
    mnt6_Fq6 result = mnt6_ate_miller_loop(prec_P, prec_Q);
    leave_block("Call to mnt6_ate_pairing");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_ate_precompute_G1()

mnt6_ate_G1_precomp libff::mnt6_ate_precompute_G1 ( const mnt6_G1 & P )

Definition at line 472 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_ate_precompute_G1");
 
    mnt6_G1 Pcopy = P;
    Pcopy.to_affine_coordinates();
 
    mnt6_ate_G1_precomp result;
    result.PX = Pcopy.X;
    result.PY = Pcopy.Y;
    result.PX_twist = Pcopy.X * mnt6_twist;
    result.PY_twist = Pcopy.Y * mnt6_twist;
 
    leave_block("Call to mnt6_ate_precompute_G1");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_ate_precompute_G2()

mnt6_ate_G2_precomp libff::mnt6_ate_precompute_G2 ( const mnt6_G2 & Q )

Definition at line 489 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_ate_precompute_G2");
 
    mnt6_G2 Qcopy(Q);
    Qcopy.to_affine_coordinates();
 
    mnt6_Fq3 mnt6_twist_inv = mnt6_twist.inverse(); // could add to global params if needed
 
    mnt6_ate_G2_precomp result;
    result.QX = Qcopy.X;
    result.QY = Qcopy.Y;
    result.QY2 = Qcopy.Y.squared();
    result.QX_over_twist = Qcopy.X * mnt6_twist_inv;
    result.QY_over_twist = Qcopy.Y * mnt6_twist_inv;
 
    extended_mnt6_G2_projective R;
    R.X = Qcopy.X;
    R.Y = Qcopy.Y;
    R.Z = mnt6_Fq3::one();
    R.T = mnt6_Fq3::one();
 
    const bigint<mnt6_Fr::num_limbs> &loop_count = mnt6_ate_loop_count;
    bool found_one = false;
    for (long i = loop_count.max_bits() - 1; i >= 0; --i)
    {
        const bool bit = loop_count.test_bit(i);
 
        if (!found_one)
        {
            /* this skips the MSB itself */
            found_one |= bit;
            continue;
        }
 
        mnt6_ate_dbl_coeffs dc;
        doubling_step_for_flipped_miller_loop(R, dc);
        result.dbl_coeffs.push_back(dc);
 
        if (bit)
        {
            mnt6_ate_add_coeffs ac;
            mixed_addition_step_for_flipped_miller_loop(result.QX, result.QY, result.QY2, R, ac);
            result.add_coeffs.push_back(ac);
        }
    }
 
    if (mnt6_ate_is_loop_count_neg)
    {
        mnt6_Fq3 RZ_inv = R.Z.inverse();
        mnt6_Fq3 RZ2_inv = RZ_inv.squared();
        mnt6_Fq3 RZ3_inv = RZ2_inv * RZ_inv;
        mnt6_Fq3 minus_R_affine_X = R.X * RZ2_inv;
        mnt6_Fq3 minus_R_affine_Y = - R.Y * RZ3_inv;
        mnt6_Fq3 minus_R_affine_Y2 = minus_R_affine_Y.squared();
        mnt6_ate_add_coeffs ac;
        mixed_addition_step_for_flipped_miller_loop(minus_R_affine_X, minus_R_affine_Y, minus_R_affine_Y2, R, ac);
        result.add_coeffs.push_back(ac);
    }
 
    leave_block("Call to mnt6_ate_precompute_G2");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_ate_reduced_pairing()

mnt6_GT libff::mnt6_ate_reduced_pairing	(	const mnt6_G1 &	P,
		const mnt6_G2 &	Q )

Definition at line 698 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_ate_reduced_pairing");
    const mnt6_Fq6 f = mnt6_ate_pairing(P, Q);
    const mnt6_GT result = mnt6_final_exponentiation(f);
    leave_block("Call to mnt6_ate_reduced_pairing");
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_double_miller_loop()

mnt6_Fq6 libff::mnt6_double_miller_loop	(	const mnt6_G1_precomp &	prec_P1,
		const mnt6_G2_precomp &	prec_Q1,
		const mnt6_G1_precomp &	prec_P2,
		const mnt6_G2_precomp &	prec_Q2 )

Definition at line 723 of file mnt6_pairing.cpp.

{
    return mnt6_ate_double_miller_loop(prec_P1, prec_Q1, prec_P2, prec_Q2);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_final_exponentiation()

mnt6_GT libff::mnt6_final_exponentiation ( const mnt6_Fq6 & elt )

Definition at line 218 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_final_exponentiation");
    const mnt6_Fq6 elt_inv = elt.inverse();
    const mnt6_Fq6 elt_to_first_chunk = mnt6_final_exponentiation_first_chunk(elt, elt_inv);
    const mnt6_Fq6 elt_inv_to_first_chunk = mnt6_final_exponentiation_first_chunk(elt_inv, elt);
    mnt6_GT result = mnt6_final_exponentiation_last_chunk(elt_to_first_chunk, elt_inv_to_first_chunk);
    leave_block("Call to mnt6_final_exponentiation");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_final_exponentiation_first_chunk()

mnt6_Fq6 libff::mnt6_final_exponentiation_first_chunk	(	const mnt6_Fq6 &	elt,
		const mnt6_Fq6 &	elt_inv )

Definition at line 200 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_final_exponentiation_first_chunk");
 
    /* (q^3-1)*(q+1) */
 
    /* elt_q3 = elt^(q^3) */
    const mnt6_Fq6 elt_q3 = elt.Frobenius_map(3);
    /* elt_q3_over_elt = elt^(q^3-1) */
    const mnt6_Fq6 elt_q3_over_elt = elt_q3 * elt_inv;
    /* alpha = elt^((q^3-1) * q) */
    const mnt6_Fq6 alpha = elt_q3_over_elt.Frobenius_map(1);
    /* beta = elt^((q^3-1)*(q+1) */
    const mnt6_Fq6 beta = alpha * elt_q3_over_elt;
    leave_block("Call to mnt6_final_exponentiation_first_chunk");
    return beta;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_final_exponentiation_last_chunk()

mnt6_Fq6 libff::mnt6_final_exponentiation_last_chunk	(	const mnt6_Fq6 &	elt,
		const mnt6_Fq6 &	elt_inv )

Definition at line 182 of file mnt6_pairing.cpp.

{
    enter_block("Call to mnt6_final_exponentiation_last_chunk");
    const mnt6_Fq6 elt_q = elt.Frobenius_map(1);
    mnt6_Fq6 w1_part = elt_q.cyclotomic_exp(mnt6_final_exponent_last_chunk_w1);
    mnt6_Fq6 w0_part;
    if (mnt6_final_exponent_last_chunk_is_w0_neg)
    {
        w0_part = elt_inv.cyclotomic_exp(mnt6_final_exponent_last_chunk_abs_of_w0);
    } else {
        w0_part = elt.cyclotomic_exp(mnt6_final_exponent_last_chunk_abs_of_w0);
    }
    mnt6_Fq6 result = w1_part * w0_part;
    leave_block("Call to mnt6_final_exponentiation_last_chunk");
 
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_miller_loop()

mnt6_Fq6 libff::mnt6_miller_loop	(	const mnt6_G1_precomp &	prec_P,
		const mnt6_G2_precomp &	prec_Q )

Definition at line 717 of file mnt6_pairing.cpp.

{
    return mnt6_ate_miller_loop(prec_P, prec_Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_pairing()

mnt6_Fq6 libff::mnt6_pairing	(	const mnt6_G1 &	P,
		const mnt6_G2 &	Q )

Definition at line 731 of file mnt6_pairing.cpp.

{
    return mnt6_ate_pairing(P, Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_precompute_G1()

mnt6_G1_precomp libff::mnt6_precompute_G1 ( const mnt6_G1 & P )

Definition at line 707 of file mnt6_pairing.cpp.

{
    return mnt6_ate_precompute_G1(P);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_precompute_G2()

mnt6_G2_precomp libff::mnt6_precompute_G2 ( const mnt6_G2 & Q )

Definition at line 712 of file mnt6_pairing.cpp.

{
    return mnt6_ate_precompute_G2(Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mnt6_reduced_pairing()

mnt6_GT libff::mnt6_reduced_pairing	(	const mnt6_G1 &	P,
		const mnt6_G2 &	Q )

Definition at line 737 of file mnt6_pairing.cpp.

{
    return mnt6_ate_reduced_pairing(P, Q);
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ multi_exp()

template<typename T , typename FieldT , multi_exp_method Method>

T libff::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 )

Computes the sum \sum_i scalar_start[i] * vec_start[i] using the selected method. Input is split into the given number of chunks, and, when compiled with MULTICORE, the chunks are processed in parallel.

Here is the caller graph for this function:

◆ multi_exp_with_mixed_addition()

template<typename T , typename FieldT , multi_exp_method Method>

T libff::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 )

A variant of multi_exp that takes advantage of the method mixed_add (instead of the operator '+'). Assumes input is in special form, and includes special pre-processing for scalars equal to 0 or 1.

◆ op_profiling_enter()

void libff::op_profiling_enter ( const std::string & msg )

Definition at line 237 of file profiling.cpp.

{
    for (std::pair<std::string, long long*> p : op_data_points)
    {
        op_counts[std::make_pair(msg, p.first)] = *(p.second);
    }
}

Here is the caller graph for this function:

◆ operator*() [1/30]

template<mp_size_t m>

alt_bn128_G1 libff::operator*	(	const bigint< m > &	lhs,
		const alt_bn128_G1 &	rhs )

Definition at line 79 of file alt_bn128_g1.hpp.

{
    return scalar_mul<alt_bn128_G1, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [2/30]

template<mp_size_t m>

alt_bn128_G2 libff::operator*	(	const bigint< m > &	lhs,
		const alt_bn128_G2 &	rhs )

Definition at line 83 of file alt_bn128_g2.hpp.

{
    return scalar_mul<alt_bn128_G2, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [3/30]

template<mp_size_t m>

bn128_G1 libff::operator*	(	const bigint< m > &	lhs,
		const bn128_G1 &	rhs )

Definition at line 83 of file bn128_g1.hpp.

{
    return scalar_mul<bn128_G1, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [4/30]

template<mp_size_t m>

bn128_G2 libff::operator*	(	const bigint< m > &	lhs,
		const bn128_G2 &	rhs )

Definition at line 84 of file bn128_g2.hpp.

{
    return scalar_mul<bn128_G2, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [5/30]

template<mp_size_t m>

edwards_G1 libff::operator*	(	const bigint< m > &	lhs,
		const edwards_G1 &	rhs )

Definition at line 81 of file edwards_g1.hpp.

{
    return scalar_mul<edwards_G1, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [6/30]

template<mp_size_t m>

edwards_G2 libff::operator*	(	const bigint< m > &	lhs,
		const edwards_G2 &	rhs )

Definition at line 87 of file edwards_g2.hpp.

{
    return scalar_mul<edwards_G2, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [7/30]

template<mp_size_t m>

mnt4_G1 libff::operator*	(	const bigint< m > &	lhs,
		const mnt4_G1 &	rhs )

Definition at line 87 of file mnt4_g1.hpp.

{
    return scalar_mul<mnt4_G1, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [8/30]

template<mp_size_t m>

mnt4_G2 libff::operator*	(	const bigint< m > &	lhs,
		const mnt4_G2 &	rhs )

Definition at line 92 of file mnt4_g2.hpp.

{
    return scalar_mul<mnt4_G2, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [9/30]

template<mp_size_t m>

mnt6_G1 libff::operator*	(	const bigint< m > &	lhs,
		const mnt6_G1 &	rhs )

Definition at line 87 of file mnt6_g1.hpp.

{
    return scalar_mul<mnt6_G1, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [10/30]

template<mp_size_t m>

mnt6_G2 libff::operator*	(	const bigint< m > &	lhs,
		const mnt6_G2 &	rhs )

Definition at line 92 of file mnt6_g2.hpp.

{
    return scalar_mul<mnt6_G2, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator*() [11/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp12_2over3over2_model< n, modulus > libff::operator*	(	const Fp2_model< n, modulus > &	lhs,
		const Fp12_2over3over2_model< n, modulus > &	rhs )

◆ operator*() [12/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp4_model< n, modulus > libff::operator*	(	const Fp2_model< n, modulus > &	lhs,
		const Fp4_model< n, modulus > &	rhs )

◆ operator*() [13/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp6_3over2_model< n, modulus > libff::operator*	(	const Fp2_model< n, modulus > &	lhs,
		const Fp6_3over2_model< n, modulus > &	rhs )

◆ operator*() [14/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp12_2over3over2_model< n, modulus > libff::operator*	(	const Fp6_3over2_model< n, modulus > &	lhs,
		const Fp12_2over3over2_model< n, modulus > &	rhs )

◆ operator*() [15/30]

template<mp_size_t m, const bigint< m > & modulus_p>

alt_bn128_G1 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const alt_bn128_G1 &	rhs )

Definition at line 85 of file alt_bn128_g1.hpp.

{
    return scalar_mul<alt_bn128_G1, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [16/30]

template<mp_size_t m, const bigint< m > & modulus_p>

alt_bn128_G2 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const alt_bn128_G2 &	rhs )

Definition at line 89 of file alt_bn128_g2.hpp.

{
    return scalar_mul<alt_bn128_G2, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [17/30]

template<mp_size_t m, const bigint< m > & modulus_p>

bn128_G1 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const bn128_G1 &	rhs )

Definition at line 89 of file bn128_g1.hpp.

{
    return scalar_mul<bn128_G1, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [18/30]

template<mp_size_t m, const bigint< m > & modulus_p>

bn128_G2 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const bn128_G2 &	rhs )

Definition at line 90 of file bn128_g2.hpp.

{
    return scalar_mul<bn128_G2, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [19/30]

template<mp_size_t m, const bigint< m > & modulus_p>

edwards_G1 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const edwards_G1 &	rhs )

Definition at line 87 of file edwards_g1.hpp.

{
    return scalar_mul<edwards_G1, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [20/30]

template<mp_size_t m, const bigint< m > & modulus_p>

edwards_G2 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const edwards_G2 &	rhs )

Definition at line 93 of file edwards_g2.hpp.

{
   return scalar_mul<edwards_G2, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [21/30]

template<mp_size_t m, const bigint< m > & modulus_p>

mnt4_G1 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const mnt4_G1 &	rhs )

Definition at line 93 of file mnt4_g1.hpp.

{
    return scalar_mul<mnt4_G1, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [22/30]

template<mp_size_t m, const bigint< m > & modulus_p>

mnt4_G2 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const mnt4_G2 &	rhs )

Definition at line 98 of file mnt4_g2.hpp.

{
    return scalar_mul<mnt4_G2, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [23/30]

template<mp_size_t m, const bigint< m > & modulus_p>

mnt6_G1 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const mnt6_G1 &	rhs )

Definition at line 93 of file mnt6_g1.hpp.

{
    return scalar_mul<mnt6_G1, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [24/30]

template<mp_size_t m, const bigint< m > & modulus_p>

mnt6_G2 libff::operator*	(	const Fp_model< m, modulus_p > &	lhs,
		const mnt6_G2 &	rhs )

Definition at line 98 of file mnt6_g2.hpp.

{
    return scalar_mul<mnt6_G2, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator*() [25/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp12_2over3over2_model< n, modulus > libff::operator*	(	const Fp_model< n, modulus > &	lhs,
		const Fp12_2over3over2_model< n, modulus > &	rhs )

◆ operator*() [26/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp2_model< n, modulus > libff::operator*	(	const Fp_model< n, modulus > &	lhs,
		const Fp2_model< n, modulus > &	rhs )

◆ operator*() [27/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp3_model< n, modulus > libff::operator*	(	const Fp_model< n, modulus > &	lhs,
		const Fp3_model< n, modulus > &	rhs )

◆ operator*() [28/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp4_model< n, modulus > libff::operator*	(	const Fp_model< n, modulus > &	lhs,
		const Fp4_model< n, modulus > &	rhs )

◆ operator*() [29/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp6_2over3_model< n, modulus > libff::operator*	(	const Fp_model< n, modulus > &	lhs,
		const Fp6_2over3_model< n, modulus > &	rhs )

◆ operator*() [30/30]

template<mp_size_t n, const bigint< n > & modulus>

Fp6_3over2_model< n, modulus > libff::operator*	(	const Fp_model< n, modulus > &	lhs,
		const Fp6_3over2_model< n, modulus > &	rhs )

◆ operator<<() [1/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	,
		const Fp12_2over3over2_model< n, modulus > &	)

◆ operator<<() [2/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	,
		const Fp2_model< n, modulus > &	)

◆ operator<<() [3/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	,
		const Fp3_model< n, modulus > &	)

◆ operator<<() [4/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	,
		const Fp4_model< n, modulus > &	)

◆ operator<<() [5/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	,
		const Fp6_2over3_model< n, modulus > &	)

◆ operator<<() [6/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	,
		const Fp6_3over2_model< n, modulus > &	)

◆ operator<<() [7/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	,
		const Fp_model< n, modulus > &	)

◆ operator<<() [8/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const alt_bn128_ate_ell_coeffs &	c )

Definition at line 47 of file alt_bn128_pairing.cpp.

{
    out << c.ell_0 << OUTPUT_SEPARATOR << c.ell_VW << OUTPUT_SEPARATOR << c.ell_VV;
    return out;
}

◆ operator<<() [9/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const alt_bn128_ate_G1_precomp &	prec_P )

Definition at line 24 of file alt_bn128_pairing.cpp.

{
    out << prec_P.PX << OUTPUT_SEPARATOR << prec_P.PY;
 
    return out;
}

◆ operator<<() [10/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const alt_bn128_ate_G2_precomp &	prec_Q )

Definition at line 71 of file alt_bn128_pairing.cpp.

{
    out << prec_Q.QX << OUTPUT_SEPARATOR << prec_Q.QY << "\n";
    out << prec_Q.coeffs.size() << "\n";
    for (const alt_bn128_ate_ell_coeffs &c : prec_Q.coeffs)
    {
        out << c << OUTPUT_NEWLINE;
    }
    return out;
}

◆ operator<<() [11/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const alt_bn128_G1 &	g )

Definition at line 408 of file alt_bn128_g1.cpp.

{
    alt_bn128_G1 copy(g);
    copy.to_affine_coordinates();
 
    out << (copy.is_zero() ? 1 : 0) << OUTPUT_SEPARATOR;
#ifdef NO_PT_COMPRESSION
    out << copy.X << OUTPUT_SEPARATOR << copy.Y;
#else
    /* storing LSB of Y */
    out << copy.X << OUTPUT_SEPARATOR << (copy.Y.as_bigint().data[0] & 1);
#endif
 
    return out;
}

◆ operator<<() [12/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const alt_bn128_G2 &	g )

Definition at line 422 of file alt_bn128_g2.cpp.

{
    alt_bn128_G2 copy(g);
    copy.to_affine_coordinates();
    out << (copy.is_zero() ? 1 : 0) << OUTPUT_SEPARATOR;
#ifdef NO_PT_COMPRESSION
    out << copy.X << OUTPUT_SEPARATOR << copy.Y;
#else
    /* storing LSB of Y */
    out << copy.X << OUTPUT_SEPARATOR << (copy.Y.c0.as_bigint().data[0] & 1);
#endif
 
    return out;
}

◆ operator<<() [13/51]

template<mp_size_t n>

std::ostream & libff::operator<<	(	std::ostream &	out,
		const bigint< n > &	b )

◆ operator<<() [14/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const bn128_ate_G1_precomp &	prec_P )

Definition at line 29 of file bn128_pairing.cpp.

{
    for (size_t i = 0; i < 3; ++i)
    {
#ifndef BINARY_OUTPUT
        out << prec_P.P[i] << "\n";
#else
        out.write((char*) &prec_P.P[i], sizeof(prec_P.P[i]));
#endif
    }
    return out;
}

◆ operator<<() [15/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const bn128_ate_G2_precomp &	prec_Q )

Definition at line 81 of file bn128_pairing.cpp.

{
    for (size_t i = 0; i < 3; ++i)
    {
#ifndef BINARY_OUTPUT
        out << prec_Q.Q[i].a_ << "\n";
        out << prec_Q.Q[i].b_ << "\n";
#else
        out.write((char*) &prec_Q.Q[i].a_, sizeof(prec_Q.Q[i].a_));
        out.write((char*) &prec_Q.Q[i].b_, sizeof(prec_Q.Q[i].b_));
#endif
    }
 
    out << prec_Q.coeffs.size() << "\n";
 
    for (size_t i = 0; i < prec_Q.coeffs.size(); ++i)
    {
#ifndef BINARY_OUTPUT
        out << prec_Q.coeffs[i].a_.a_ << "\n";
        out << prec_Q.coeffs[i].a_.b_ << "\n";
        out << prec_Q.coeffs[i].b_.a_ << "\n";
        out << prec_Q.coeffs[i].b_.b_ << "\n";
        out << prec_Q.coeffs[i].c_.a_ << "\n";
        out << prec_Q.coeffs[i].c_.b_ << "\n";
#else
        out.write((char*) &prec_Q.coeffs[i].a_.a_, sizeof(prec_Q.coeffs[i].a_.a_));
        out.write((char*) &prec_Q.coeffs[i].a_.b_, sizeof(prec_Q.coeffs[i].a_.b_));
        out.write((char*) &prec_Q.coeffs[i].b_.a_, sizeof(prec_Q.coeffs[i].b_.a_));
        out.write((char*) &prec_Q.coeffs[i].b_.b_, sizeof(prec_Q.coeffs[i].b_.b_));
        out.write((char*) &prec_Q.coeffs[i].c_.a_, sizeof(prec_Q.coeffs[i].c_.a_));
        out.write((char*) &prec_Q.coeffs[i].c_.b_, sizeof(prec_Q.coeffs[i].c_.b_));
#endif
    }
 
    return out;
}

◆ operator<<() [16/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const bn128_G1 &	g )

Definition at line 355 of file bn128_g1.cpp.

{
    bn128_G1 gcopy(g);
    gcopy.to_affine_coordinates();
 
    out << (gcopy.is_zero() ? '1' : '0') << OUTPUT_SEPARATOR;
 
#ifdef NO_PT_COMPRESSION
    /* no point compression case */
#ifndef BINARY_OUTPUT
    out << gcopy.X << OUTPUT_SEPARATOR << gcopy.Y;
#else
    out.write((char*) &gcopy.X, sizeof(gcopy.X));
    out.write((char*) &gcopy.Y, sizeof(gcopy.Y));
#endif
 
#else
    /* point compression case */
#ifndef BINARY_OUTPUT
    out << gcopy.X;
#else
    out.write((char*) &gcopy.X, sizeof(gcopy.X));
#endif
    out << OUTPUT_SEPARATOR << (((unsigned char*)&gcopy.Y)[0] & 1 ? '1' : '0');
#endif
 
    return out;
}

◆ operator<<() [17/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const bn128_G2 &	g )

Definition at line 386 of file bn128_g2.cpp.

{
    bn128_G2 gcopy(g);
    gcopy.to_affine_coordinates();
 
    out << (gcopy.is_zero() ? '1' : '0') << OUTPUT_SEPARATOR;
 
#ifdef NO_PT_COMPRESSION
    /* no point compression case */
#ifndef BINARY_OUTPUT
    out << gcopy.X.a_ << OUTPUT_SEPARATOR << gcopy.X.b_ << OUTPUT_SEPARATOR;
    out << gcopy.Y.a_ << OUTPUT_SEPARATOR << gcopy.Y.b_;
#else
    out.write((char*) &gcopy.X.a_, sizeof(gcopy.X.a_));
    out.write((char*) &gcopy.X.b_, sizeof(gcopy.X.b_));
    out.write((char*) &gcopy.Y.a_, sizeof(gcopy.Y.a_));
    out.write((char*) &gcopy.Y.b_, sizeof(gcopy.Y.b_));
#endif
 
#else
    /* point compression case */
#ifndef BINARY_OUTPUT
    out << gcopy.X.a_ << OUTPUT_SEPARATOR << gcopy.X.b_;
#else
    out.write((char*) &gcopy.X.a_, sizeof(gcopy.X.a_));
    out.write((char*) &gcopy.X.b_, sizeof(gcopy.X.b_));
#endif
    out << OUTPUT_SEPARATOR << (((unsigned char*)&gcopy.Y.a_)[0] & 1 ? '1' : '0');
#endif
 
    return out;
}

◆ operator<<() [18/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const bn128_GT &	g )

Definition at line 47 of file bn128_gt.cpp.

{
#ifndef BINARY_OUTPUT
    out << g.elem.a_ << OUTPUT_SEPARATOR << g.elem.b_;
#else
    out.write((char*) &g.elem.a_, sizeof(g.elem.a_));
    out.write((char*) &g.elem.b_, sizeof(g.elem.b_));
#endif
    return out;
}

◆ operator<<() [19/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const edwards_ate_G1_precomp &	prec_P )

Definition at line 156 of file edwards_pairing.cpp.

{
    out << prec_P.P_XY << OUTPUT_SEPARATOR << prec_P.P_XZ << OUTPUT_SEPARATOR << prec_P.P_ZZplusYZ;
 
    return out;
}

◆ operator<<() [20/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const edwards_ate_G2_precomp &	prec_Q )

Definition at line 116 of file edwards_pairing.cpp.

{
    out << prec_Q.size() << "\n";
    for (const edwards_Fq3_conic_coefficients &cc : prec_Q)
    {
        out << cc << OUTPUT_NEWLINE;
    }
 
    return out;
}

◆ operator<<() [21/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const edwards_Fq3_conic_coefficients &	cc )

Definition at line 100 of file edwards_pairing.cpp.

{
    out << cc.c_ZZ << OUTPUT_SEPARATOR << cc.c_XY << OUTPUT_SEPARATOR << cc.c_XZ;
    return out;
}

◆ operator<<() [22/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const edwards_Fq_conic_coefficients &	cc )

Definition at line 25 of file edwards_pairing.cpp.

{
    out << cc.c_ZZ << OUTPUT_SEPARATOR << cc.c_XY << OUTPUT_SEPARATOR << cc.c_XZ;
    return out;
}

◆ operator<<() [23/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const edwards_G1 &	g )

Definition at line 307 of file edwards_g1.cpp.

{
    edwards_G1 copy(g);
    copy.to_affine_coordinates();
#ifdef NO_PT_COMPRESSION
    out << copy.X << OUTPUT_SEPARATOR << copy.Y;
#else
    /* storing LSB of Y */
    out << copy.X << OUTPUT_SEPARATOR << (copy.Y.as_bigint().data[0] & 1);
#endif
 
    return out;
}

◆ operator<<() [24/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const edwards_G2 &	g )

Definition at line 339 of file edwards_g2.cpp.

{
    edwards_G2 copy(g);
    copy.to_affine_coordinates();
#ifdef NO_PT_COMPRESSION
    out << copy.X << OUTPUT_SEPARATOR << copy.Y;
#else
    /* storing LSB of Y */
    out << copy.X << OUTPUT_SEPARATOR << (copy.Y.c0.as_bigint().data[0] & 1);
#endif
    return out;
}

◆ operator<<() [25/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const edwards_tate_G1_precomp &	prec_P )

Definition at line 41 of file edwards_pairing.cpp.

{
    out << prec_P.size() << "\n";
    for (const edwards_Fq_conic_coefficients &cc : prec_P)
    {
        out << cc << OUTPUT_NEWLINE;
    }
 
    return out;
}

◆ operator<<() [26/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const edwards_tate_G2_precomp &	prec_Q )

Definition at line 79 of file edwards_pairing.cpp.

{
    out << prec_Q.y0 << OUTPUT_SEPARATOR << prec_Q.eta;
    return out;
}

◆ operator<<() [27/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt4_ate_add_coeffs &	ac )

Definition at line 86 of file mnt4_pairing.cpp.

{
    out << ac.c_L1 << OUTPUT_SEPARATOR << ac.c_RZ;
    return out;
}

◆ operator<<() [28/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt4_ate_dbl_coeffs &	dc )

Definition at line 61 of file mnt4_pairing.cpp.

{
    out << dc.c_H << OUTPUT_SEPARATOR << dc.c_4C << OUTPUT_SEPARATOR << dc.c_J << OUTPUT_SEPARATOR << dc.c_L;
    return out;
}

◆ operator<<() [29/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt4_ate_G1_precomp &	prec_P )

Definition at line 33 of file mnt4_pairing.cpp.

{
    out << prec_P.PX << OUTPUT_SEPARATOR << prec_P.PY << OUTPUT_SEPARATOR << prec_P.PX_twist << OUTPUT_SEPARATOR << prec_P.PY_twist;
 
    return out;
}

◆ operator<<() [30/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt4_ate_G2_precomp &	prec_Q )

Definition at line 111 of file mnt4_pairing.cpp.

{
    out << prec_Q.QX << OUTPUT_SEPARATOR
        << prec_Q.QY << OUTPUT_SEPARATOR
        << prec_Q.QY2  << OUTPUT_SEPARATOR
        << prec_Q.QX_over_twist << OUTPUT_SEPARATOR
        << prec_Q.QY_over_twist << "\n";
    out << prec_Q.dbl_coeffs.size() << "\n";
    for (const mnt4_ate_dbl_coeffs &dc : prec_Q.dbl_coeffs)
    {
        out << dc << OUTPUT_NEWLINE;
    }
    out << prec_Q.add_coeffs.size() << "\n";
    for (const mnt4_ate_add_coeffs &ac : prec_Q.add_coeffs)
    {
        out << ac << OUTPUT_NEWLINE;
    }
 
    return out;
}

◆ operator<<() [31/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt4_G1 &	g )

Definition at line 393 of file mnt4_g1.cpp.

{
    mnt4_G1 copy(g);
    copy.to_affine_coordinates();
 
    out << (copy.is_zero() ? 1 : 0) << OUTPUT_SEPARATOR;
#ifdef NO_PT_COMPRESSION
    out << copy.X << OUTPUT_SEPARATOR << copy.Y;
#else
    /* storing LSB of Y */
    out << copy.X << OUTPUT_SEPARATOR << (copy.Y.as_bigint().data[0] & 1);
#endif
 
    return out;
}

◆ operator<<() [32/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt4_G2 &	g )

Definition at line 417 of file mnt4_g2.cpp.

{
    mnt4_G2 copy(g);
    copy.to_affine_coordinates();
 
    out << (copy.is_zero() ? 1 : 0) << OUTPUT_SEPARATOR;
#ifdef NO_PT_COMPRESSION
    out << copy.X << OUTPUT_SEPARATOR << copy.Y;
#else
    /* storing LSB of Y */
    out << copy.X << OUTPUT_SEPARATOR << (copy.Y.c0.as_bigint().data[0] & 1);
#endif
 
    return out;
}

◆ operator<<() [33/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt6_ate_add_coeffs &	ac )

Definition at line 86 of file mnt6_pairing.cpp.

{
    out << ac.c_L1 << OUTPUT_SEPARATOR << ac.c_RZ;
    return out;
}

◆ operator<<() [34/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt6_ate_dbl_coeffs &	dc )

Definition at line 61 of file mnt6_pairing.cpp.

{
    out << dc.c_H << OUTPUT_SEPARATOR << dc.c_4C << OUTPUT_SEPARATOR << dc.c_J << OUTPUT_SEPARATOR << dc.c_L;
    return out;
}

◆ operator<<() [35/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt6_ate_G1_precomp &	prec_P )

Definition at line 33 of file mnt6_pairing.cpp.

{
    out << prec_P.PX << OUTPUT_SEPARATOR << prec_P.PY << OUTPUT_SEPARATOR << prec_P.PX_twist << OUTPUT_SEPARATOR << prec_P.PY_twist;
 
    return out;
}

◆ operator<<() [36/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt6_ate_G2_precomp &	prec_Q )

Definition at line 113 of file mnt6_pairing.cpp.

{
    out << prec_Q.QX << OUTPUT_SEPARATOR
        << prec_Q.QY << OUTPUT_SEPARATOR
        << prec_Q.QY2  << OUTPUT_SEPARATOR
        << prec_Q.QX_over_twist << OUTPUT_SEPARATOR
        << prec_Q.QY_over_twist << "\n";
    out << prec_Q.dbl_coeffs.size() << "\n";
    for (const mnt6_ate_dbl_coeffs &dc : prec_Q.dbl_coeffs)
    {
        out << dc << OUTPUT_NEWLINE;
    }
    out << prec_Q.add_coeffs.size() << "\n";
    for (const mnt6_ate_add_coeffs &ac : prec_Q.add_coeffs)
    {
        out << ac << OUTPUT_NEWLINE;
    }
 
    return out;
}

◆ operator<<() [37/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt6_G1 &	g )

Definition at line 393 of file mnt6_g1.cpp.

{
    mnt6_G1 copy(g);
    copy.to_affine_coordinates();
 
    out << (copy.is_zero() ? 1 : 0) << OUTPUT_SEPARATOR;
#ifdef NO_PT_COMPRESSION
    out << copy.X << OUTPUT_SEPARATOR << copy.Y;
#else
    /* storing LSB of Y */
    out << copy.X << OUTPUT_SEPARATOR << (copy.Y.as_bigint().data[0] & 1);
#endif
 
    return out;
}

◆ operator<<() [38/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const mnt6_G2 &	g )

Definition at line 424 of file mnt6_g2.cpp.

{
    mnt6_G2 copy(g);
    copy.to_affine_coordinates();
 
    out << (copy.is_zero() ? 1 : 0) << OUTPUT_SEPARATOR;
#ifdef NO_PT_COMPRESSION
    out << copy.X << OUTPUT_SEPARATOR << copy.Y;
#else
    /* storing LSB of Y */
    out << copy.X << OUTPUT_SEPARATOR << (copy.Y.c0.as_bigint().data[0] & 1);
#endif
 
    return out;
}

◆ operator<<() [39/51]

template<typename T1 , typename T2 >

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::map< T1, T2 > &	m )

◆ operator<<() [40/51]

template<typename T >

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::set< T > &	s )

◆ operator<<() [41/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< alt_bn128_G1 > &	v )

Definition at line 471 of file alt_bn128_g1.cpp.

{
    out << v.size() << "\n";
    for (const alt_bn128_G1& t : v)
    {
        out << t << OUTPUT_NEWLINE;
    }
 
    return out;
}

◆ operator<<() [42/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< bn128_G1 > &	v )

Definition at line 476 of file bn128_g1.cpp.

{
    out << v.size() << "\n";
    for (const bn128_G1& t : v)
    {
        out << t << OUTPUT_NEWLINE;
    }
    return out;
}

◆ operator<<() [43/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< edwards_G1 > &	v )

Definition at line 364 of file edwards_g1.cpp.

{
    out << v.size() << "\n";
    for (const edwards_G1& t : v)
    {
        out << t << OUTPUT_NEWLINE;
    }
 
    return out;
}

◆ operator<<() [44/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< Fp12_2over3over2_model< n, modulus > > &	v )

◆ operator<<() [45/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< Fp2_model< n, modulus > > &	v )

◆ operator<<() [46/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< Fp3_model< n, modulus > > &	v )

◆ operator<<() [47/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< Fp6_2over3_model< n, modulus > > &	v )

◆ operator<<() [48/51]

template<mp_size_t n, const bigint< n > & modulus>

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< Fp6_3over2_model< n, modulus > > &	v )

◆ operator<<() [49/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< mnt4_G1 > &	v )

Definition at line 456 of file mnt4_g1.cpp.

{
    out << v.size() << "\n";
    for (const mnt4_G1& t : v)
    {
        out << t << OUTPUT_NEWLINE;
    }
 
    return out;
}

◆ operator<<() [50/51]

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< mnt6_G1 > &	v )

Definition at line 456 of file mnt6_g1.cpp.

{
    out << v.size() << "\n";
    for (const mnt6_G1& t : v)
    {
        out << t << OUTPUT_NEWLINE;
    }
 
    return out;
}

◆ operator<<() [51/51]

template<typename T >

std::ostream & libff::operator<<	(	std::ostream &	out,
		const std::vector< T > &	v )

◆ operator>>() [1/51]

std::istream & libff::operator>>	(	std::istream &	in,
		alt_bn128_ate_ell_coeffs &	c )

Definition at line 53 of file alt_bn128_pairing.cpp.

{
    in >> c.ell_0;
    consume_OUTPUT_SEPARATOR(in);
    in >> c.ell_VW;
    consume_OUTPUT_SEPARATOR(in);
    in >> c.ell_VV;
 
    return in;
}

◆ operator>>() [2/51]

std::istream & libff::operator>>	(	std::istream &	in,
		alt_bn128_ate_G1_precomp &	prec_P )

Definition at line 31 of file alt_bn128_pairing.cpp.

{
    in >> prec_P.PX;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_P.PY;
 
    return in;
}

◆ operator>>() [3/51]

std::istream & libff::operator>>	(	std::istream &	in,
		alt_bn128_ate_G2_precomp &	prec_Q )

Definition at line 82 of file alt_bn128_pairing.cpp.

{
    in >> prec_Q.QX;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.QY;
    consume_newline(in);
 
    prec_Q.coeffs.clear();
    size_t s;
    in >> s;
 
    consume_newline(in);
 
    prec_Q.coeffs.reserve(s);
 
    for (size_t i = 0; i < s; ++i)
    {
        alt_bn128_ate_ell_coeffs c;
        in >> c;
        consume_OUTPUT_NEWLINE(in);
        prec_Q.coeffs.emplace_back(c);
    }
 
    return in;
}

◆ operator>>() [4/51]

std::istream & libff::operator>>	(	std::istream &	in,
		alt_bn128_G1 &	g )

Definition at line 424 of file alt_bn128_g1.cpp.

{
    char is_zero;
    alt_bn128_Fq tX, tY;
 
#ifdef NO_PT_COMPRESSION
    in >> is_zero >> tX >> tY;
    is_zero -= '0';
#else
    in.read((char*)&is_zero, 1); // this reads is_zero;
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
    unsigned char Y_lsb;
    in >> tX;
    consume_OUTPUT_SEPARATOR(in);
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    // y = +/- sqrt(x^3 + b)
    if (!is_zero)
    {
        alt_bn128_Fq tX2 = tX.squared();
        alt_bn128_Fq tY2 = tX2*tX + alt_bn128_coeff_b;
        tY = tY2.sqrt();
 
        if ((tY.as_bigint().data[0] & 1) != Y_lsb)
        {
            tY = -tY;
        }
    }
#endif
    // using Jacobian coordinates
    if (!is_zero)
    {
        g.X = tX;
        g.Y = tY;
        g.Z = alt_bn128_Fq::one();
    }
    else
    {
        g = alt_bn128_G1::zero();
    }
 
    return in;
}

◆ operator>>() [5/51]

std::istream & libff::operator>>	(	std::istream &	in,
		alt_bn128_G2 &	g )

Definition at line 437 of file alt_bn128_g2.cpp.

{
    char is_zero;
    alt_bn128_Fq2 tX, tY;
 
#ifdef NO_PT_COMPRESSION
    in >> is_zero >> tX >> tY;
    is_zero -= '0';
#else
    in.read((char*)&is_zero, 1); // this reads is_zero;
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
    unsigned char Y_lsb;
    in >> tX;
    consume_OUTPUT_SEPARATOR(in);
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    // y = +/- sqrt(x^3 + b)
    if (!is_zero)
    {
        alt_bn128_Fq2 tX2 = tX.squared();
        alt_bn128_Fq2 tY2 = tX2 * tX + alt_bn128_twist_coeff_b;
        tY = tY2.sqrt();
 
        if ((tY.c0.as_bigint().data[0] & 1) != Y_lsb)
        {
            tY = -tY;
        }
    }
#endif
    // using projective coordinates
    if (!is_zero)
    {
        g.X = tX;
        g.Y = tY;
        g.Z = alt_bn128_Fq2::one();
    }
    else
    {
        g = alt_bn128_G2::zero();
    }
 
    return in;
}

◆ operator>>() [6/51]

template<mp_size_t n>

std::istream & libff::operator>>	(	std::istream &	in,
		bigint< n > &	b )

◆ operator>>() [7/51]

std::istream & libff::operator>>	(	std::istream &	in,
		bn128_ate_G1_precomp &	prec_P )

Definition at line 42 of file bn128_pairing.cpp.

{
    for (size_t i = 0; i < 3; ++i)
    {
#ifndef BINARY_OUTPUT
        in >> prec_P.P[i];
        consume_newline(in);
#else
        in.read((char*) &prec_P.P[i], sizeof(prec_P.P[i]));
#endif
    }
    return in;
}

◆ operator>>() [8/51]

std::istream & libff::operator>>	(	std::istream &	in,
		bn128_ate_G2_precomp &	prec_Q )

Definition at line 118 of file bn128_pairing.cpp.

{
    for (size_t i = 0; i < 3; ++i)
    {
#ifndef BINARY_OUTPUT
        in >> prec_Q.Q[i].a_;
        consume_newline(in);
        in >> prec_Q.Q[i].b_;
        consume_newline(in);
#else
        in.read((char*) &prec_Q.Q[i].a_, sizeof(prec_Q.Q[i].a_));
        in.read((char*) &prec_Q.Q[i].b_, sizeof(prec_Q.Q[i].b_));
#endif
    }
 
    size_t count;
    in >> count;
    consume_newline(in);
    prec_Q.coeffs.resize(count);
    for (size_t i = 0; i < count; ++i)
    {
#ifndef BINARY_OUTPUT
        in >> prec_Q.coeffs[i].a_.a_;
        consume_newline(in);
        in >> prec_Q.coeffs[i].a_.b_;
        consume_newline(in);
        in >> prec_Q.coeffs[i].b_.a_;
        consume_newline(in);
        in >> prec_Q.coeffs[i].b_.b_;
        consume_newline(in);
        in >> prec_Q.coeffs[i].c_.a_;
        consume_newline(in);
        in >> prec_Q.coeffs[i].c_.b_;
        consume_newline(in);
#else
        in.read((char*) &prec_Q.coeffs[i].a_.a_, sizeof(prec_Q.coeffs[i].a_.a_));
        in.read((char*) &prec_Q.coeffs[i].a_.b_, sizeof(prec_Q.coeffs[i].a_.b_));
        in.read((char*) &prec_Q.coeffs[i].b_.a_, sizeof(prec_Q.coeffs[i].b_.a_));
        in.read((char*) &prec_Q.coeffs[i].b_.b_, sizeof(prec_Q.coeffs[i].b_.b_));
        in.read((char*) &prec_Q.coeffs[i].c_.a_, sizeof(prec_Q.coeffs[i].c_.a_));
        in.read((char*) &prec_Q.coeffs[i].c_.b_, sizeof(prec_Q.coeffs[i].c_.b_));
#endif
    }
    return in;
}

◆ operator>>() [9/51]

std::istream & libff::operator>>	(	std::istream &	in,
		bn128_G1 &	g )

Definition at line 415 of file bn128_g1.cpp.

{
    char is_zero;
    in.read((char*)&is_zero, 1); // this reads is_zero;
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
#ifdef NO_PT_COMPRESSION
    /* no point compression case */
#ifndef BINARY_OUTPUT
    in >> g.X;
    consume_OUTPUT_SEPARATOR(in);
    in >> g.Y;
#else
    in.read((char*) &g.X, sizeof(g.X));
    in.read((char*) &g.Y, sizeof(g.Y));
#endif
 
#else
    /* point compression case */
    bn::Fp tX;
#ifndef BINARY_OUTPUT
    in >> tX;
#else
    in.read((char*)&tX, sizeof(tX));
#endif
    consume_OUTPUT_SEPARATOR(in);
    unsigned char Y_lsb;
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    // y = +/- sqrt(x^3 + b)
    if (!is_zero)
    {
        g.X = tX;
        bn::Fp tX2, tY2;
        bn::Fp::square(tX2, tX);
        bn::Fp::mul(tY2, tX2, tX);
        bn::Fp::add(tY2, tY2, bn128_coeff_b);
 
        g.Y = bn128_G1::sqrt(tY2);
        if ((((unsigned char*)&g.Y)[0] & 1) != Y_lsb)
        {
            bn::Fp::neg(g.Y, g.Y);
        }
    }
#endif
 
    /* finalize */
    if (!is_zero)
    {
        g.Z = bn::Fp(1);
    }
    else
    {
        g = bn128_G1::zero();
    }
 
    return in;
}

◆ operator>>() [10/51]

std::istream & libff::operator>>	(	std::istream &	in,
		bn128_G2 &	g )

Definition at line 419 of file bn128_g2.cpp.

{
    char is_zero;
    in.read((char*)&is_zero, 1); // this reads is_zero;
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
#ifdef NO_PT_COMPRESSION
    /* no point compression case */
#ifndef BINARY_OUTPUT
    in >> g.X.a_;
    consume_OUTPUT_SEPARATOR(in);
    in >> g.X.b_;
    consume_OUTPUT_SEPARATOR(in);
    in >> g.Y.a_;
    consume_OUTPUT_SEPARATOR(in);
    in >> g.Y.b_;
#else
    in.read((char*) &g.X.a_, sizeof(g.X.a_));
    in.read((char*) &g.X.b_, sizeof(g.X.b_));
    in.read((char*) &g.Y.a_, sizeof(g.Y.a_));
    in.read((char*) &g.Y.b_, sizeof(g.Y.b_));
#endif
 
#else
    /* point compression case */
    bn::Fp2 tX;
#ifndef BINARY_OUTPUT
    in >> tX.a_;
    consume_OUTPUT_SEPARATOR(in);
    in >> tX.b_;
#else
    in.read((char*)&tX.a_, sizeof(tX.a_));
    in.read((char*)&tX.b_, sizeof(tX.b_));
#endif
    consume_OUTPUT_SEPARATOR(in);
    unsigned char Y_lsb;
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    // y = +/- sqrt(x^3 + b)
    if (!is_zero)
    {
        g.X = tX;
        bn::Fp2 tX2, tY2;
        bn::Fp2::square(tX2, tX);
        bn::Fp2::mul(tY2, tX2, tX);
        bn::Fp2::add(tY2, tY2, bn128_twist_coeff_b);
 
        g.Y = bn128_G2::sqrt(tY2);
        if ((((unsigned char*)&g.Y.a_)[0] & 1) != Y_lsb)
        {
            bn::Fp2::neg(g.Y, g.Y);
        }
    }
#endif
 
    /* finalize */
    if (!is_zero)
    {
        g.Z = bn::Fp2(bn::Fp(1), bn::Fp(0));
    }
    else
    {
        g = bn128_G2::zero();
    }
 
    return in;
}

◆ operator>>() [11/51]

std::istream & libff::operator>>	(	std::istream &	in,
		bn128_GT &	g )

Definition at line 58 of file bn128_gt.cpp.

{
#ifndef BINARY_OUTPUT
    in >> g.elem.a_;
    consume_OUTPUT_SEPARATOR(in);
    in >> g.elem.b_;
#else
    in.read((char*) &g.elem.a_, sizeof(g.elem.a_));
    in.read((char*) &g.elem.b_, sizeof(g.elem.b_));
#endif
    return in;
}

◆ operator>>() [12/51]

std::istream & libff::operator>>	(	std::istream &	in,
		edwards_ate_G1_precomp &	prec_P )

Definition at line 163 of file edwards_pairing.cpp.

{
    in >> prec_P.P_XY >> prec_P.P_XZ >> prec_P.P_ZZplusYZ;
 
    return in;
}

◆ operator>>() [13/51]

std::istream & libff::operator>>	(	std::istream &	in,
		edwards_ate_G2_precomp &	prec_Q )

Definition at line 127 of file edwards_pairing.cpp.

{
    prec_Q.clear();
 
    size_t s;
    in >> s;
 
    consume_newline(in);
 
    prec_Q.reserve(s);
 
    for (size_t i = 0; i < s; ++i)
    {
        edwards_Fq3_conic_coefficients cc;
        in >> cc;
        consume_OUTPUT_NEWLINE(in);
        prec_Q.emplace_back(cc);
    }
 
    return in;
}

Here is the call graph for this function:

◆ operator>>() [14/51]

std::istream & libff::operator>>	(	std::istream &	in,
		edwards_Fq3_conic_coefficients &	cc )

Definition at line 106 of file edwards_pairing.cpp.

{
    in >> cc.c_ZZ;
    consume_OUTPUT_SEPARATOR(in);
    in >> cc.c_XY;
    consume_OUTPUT_SEPARATOR(in);
    in >> cc.c_XZ;
    return in;
}

◆ operator>>() [15/51]

std::istream & libff::operator>>	(	std::istream &	in,
		edwards_Fq_conic_coefficients &	cc )

Definition at line 31 of file edwards_pairing.cpp.

{
    in >> cc.c_ZZ;
    consume_OUTPUT_SEPARATOR(in);
    in >> cc.c_XY;
    consume_OUTPUT_SEPARATOR(in);
    in >> cc.c_XZ;
    return in;
}

◆ operator>>() [16/51]

std::istream & libff::operator>>	(	std::istream &	in,
		edwards_G1 &	g )

Definition at line 321 of file edwards_g1.cpp.

{
    edwards_Fq tX, tY;
 
#ifdef NO_PT_COMPRESSION
    in >> tX;
    consume_OUTPUT_SEPARATOR(in);
    in >> tY;
#else
    /*
      a x^2 + y^2 = 1 + d x^2 y^2
      y = sqrt((1-ax^2)/(1-dx^2))
    */
    unsigned char Y_lsb;
    in >> tX;
 
    consume_OUTPUT_SEPARATOR(in);
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    edwards_Fq tX2 = tX.squared();
    edwards_Fq tY2 = (edwards_Fq::one() - tX2) * // a = 1 for G1 (not a twist)
        (edwards_Fq::one() - edwards_coeff_d * tX2).inverse();
    tY = tY2.sqrt();
 
    if ((tY.as_bigint().data[0] & 1) != Y_lsb)
    {
        tY = -tY;
    }
#endif
 
    // using inverted coordinates
    g.X = tY;
    g.Y = tX;
    g.Z = tX * tY;
 
#ifdef USE_MIXED_ADDITION
    g.to_special();
#endif
 
    return in;
}

◆ operator>>() [17/51]

std::istream & libff::operator>>	(	std::istream &	in,
		edwards_G2 &	g )

Definition at line 352 of file edwards_g2.cpp.

{
    edwards_Fq3 tX, tY;
 
#ifdef NO_PT_COMPRESSION
    in >> tX;
    consume_OUTPUT_SEPARATOR(in);
    in >> tY;
#else
    /*
      a x^2 + y^2 = 1 + d x^2 y^2
      y = sqrt((1-ax^2)/(1-dx^2))
    */
    unsigned char Y_lsb;
    in >> tX;
    consume_OUTPUT_SEPARATOR(in);
 
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    edwards_Fq3 tX2 = tX.squared();
    const edwards_Fq3 tY2 =
        (edwards_Fq3::one() - edwards_G2::mul_by_a(tX2)) *
        (edwards_Fq3::one() - edwards_G2::mul_by_d(tX2)).inverse();
    tY = tY2.sqrt();
 
    if ((tY.c0.as_bigint().data[0] & 1) != Y_lsb)
    {
        tY = -tY;
    }
#endif
 
    // using inverted coordinates
    g.X = tY;
    g.Y = tX;
    g.Z = tX * tY;
 
#ifdef USE_MIXED_ADDITION
    g.to_special();
#endif
 
    return in;
}

◆ operator>>() [18/51]

std::istream & libff::operator>>	(	std::istream &	in,
		edwards_tate_G1_precomp &	prec_P )

Definition at line 52 of file edwards_pairing.cpp.

{
    prec_P.clear();
 
    size_t s;
    in >> s;
 
    consume_newline(in);
    prec_P.reserve(s);
 
    for (size_t i = 0; i < s; ++i)
    {
        edwards_Fq_conic_coefficients cc;
        in >> cc;
        consume_OUTPUT_NEWLINE(in);
        prec_P.emplace_back(cc);
    }
 
    return in;
}

Here is the call graph for this function:

◆ operator>>() [19/51]

std::istream & libff::operator>>	(	std::istream &	in,
		edwards_tate_G2_precomp &	prec_Q )

Definition at line 85 of file edwards_pairing.cpp.

{
    in >> prec_Q.y0;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.eta;
    return in;
}

◆ operator>>() [20/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		Fp12_2over3over2_model< n, modulus > &	el )

◆ operator>>() [21/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		Fp2_model< n, modulus > &	el )

◆ operator>>() [22/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		Fp3_model< n, modulus > &	el )

◆ operator>>() [23/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		Fp4_model< n, modulus > &	el )

◆ operator>>() [24/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		Fp6_2over3_model< n, modulus > &	el )

◆ operator>>() [25/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		Fp6_3over2_model< n, modulus > &	el )

◆ operator>>() [26/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		Fp_model< n, modulus > &	p )

◆ operator>>() [27/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt4_ate_add_coeffs &	ac )

Definition at line 92 of file mnt4_pairing.cpp.

{
    in >> ac.c_L1;
    consume_OUTPUT_SEPARATOR(in);
    in >> ac.c_RZ;
    return in;
}

◆ operator>>() [28/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt4_ate_dbl_coeffs &	dc )

Definition at line 67 of file mnt4_pairing.cpp.

{
    in >> dc.c_H;
    consume_OUTPUT_SEPARATOR(in);
    in >> dc.c_4C;
    consume_OUTPUT_SEPARATOR(in);
    in >> dc.c_J;
    consume_OUTPUT_SEPARATOR(in);
    in >> dc.c_L;
 
    return in;
}

◆ operator>>() [29/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt4_ate_G1_precomp &	prec_P )

Definition at line 40 of file mnt4_pairing.cpp.

{
    in >> prec_P.PX;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_P.PY;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_P.PX_twist;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_P.PY_twist;
 
    return in;
}

◆ operator>>() [30/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt4_ate_G2_precomp &	prec_Q )

Definition at line 132 of file mnt4_pairing.cpp.

{
    in >> prec_Q.QX;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.QY;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.QY2;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.QX_over_twist;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.QY_over_twist;
    consume_newline(in);
 
    prec_Q.dbl_coeffs.clear();
    size_t dbl_s;
    in >> dbl_s;
    consume_newline(in);
 
    prec_Q.dbl_coeffs.reserve(dbl_s);
 
    for (size_t i = 0; i < dbl_s; ++i)
    {
        mnt4_ate_dbl_coeffs dc;
        in >> dc;
        consume_OUTPUT_NEWLINE(in);
        prec_Q.dbl_coeffs.emplace_back(dc);
    }
 
    prec_Q.add_coeffs.clear();
    size_t add_s;
    in >> add_s;
    consume_newline(in);
 
    prec_Q.add_coeffs.reserve(add_s);
 
    for (size_t i = 0; i < add_s; ++i)
    {
        mnt4_ate_add_coeffs ac;
        in >> ac;
        consume_OUTPUT_NEWLINE(in);
        prec_Q.add_coeffs.emplace_back(ac);
    }
 
    return in;
}

◆ operator>>() [31/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt4_G1 &	g )

Definition at line 409 of file mnt4_g1.cpp.

{
    char is_zero;
    mnt4_Fq tX, tY;
 
#ifdef NO_PT_COMPRESSION
    in >> is_zero >> tX >> tY;
    is_zero -= '0';
#else
    in.read((char*)&is_zero, 1);
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
    unsigned char Y_lsb;
    in >> tX;
    consume_OUTPUT_SEPARATOR(in);
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    // y = +/- sqrt(x^3 + a*x + b)
    if (!is_zero)
    {
        mnt4_Fq tX2 = tX.squared();
        mnt4_Fq tY2 = (tX2 + mnt4_G1::coeff_a) * tX + mnt4_G1::coeff_b;
        tY = tY2.sqrt();
 
        if ((tY.as_bigint().data[0] & 1) != Y_lsb)
        {
            tY = -tY;
        }
    }
#endif
    // using projective coordinates
    if (!is_zero)
    {
        g.X = tX;
        g.Y = tY;
        g.Z = mnt4_Fq::one();
    }
    else
    {
        g = mnt4_G1::zero();
    }
 
    return in;
}

◆ operator>>() [32/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt4_G2 &	g )

Definition at line 433 of file mnt4_g2.cpp.

{
    char is_zero;
    mnt4_Fq2 tX, tY;
 
#ifdef NO_PT_COMPRESSION
    in >> is_zero >> tX >> tY;
    is_zero -= '0';
#else
    in.read((char*)&is_zero, 1); // this reads is_zero;
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
    unsigned char Y_lsb;
    in >> tX;
    consume_OUTPUT_SEPARATOR(in);
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    // y = +/- sqrt(x^3 + a*x + b)
    if (!is_zero)
    {
        mnt4_Fq2 tX2 = tX.squared();
        mnt4_Fq2 tY2 = (tX2 + mnt4_twist_coeff_a ) * tX + mnt4_twist_coeff_b;
        tY = tY2.sqrt();
 
        if ((tY.c0.as_bigint().data[0] & 1) != Y_lsb)
        {
            tY = -tY;
        }
    }
#endif
    // using projective coordinates
    if (!is_zero)
    {
        g.X = tX;
        g.Y = tY;
        g.Z = mnt4_Fq2::one();
    }
    else
    {
        g = mnt4_G2::zero();
    }
 
    return in;
}

◆ operator>>() [33/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt6_ate_add_coeffs &	ac )

Definition at line 92 of file mnt6_pairing.cpp.

{
    in >> ac.c_L1;
    consume_OUTPUT_SEPARATOR(in);
    in >> ac.c_RZ;
 
    return in;
}

◆ operator>>() [34/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt6_ate_dbl_coeffs &	dc )

Definition at line 67 of file mnt6_pairing.cpp.

{
    in >> dc.c_H;
    consume_OUTPUT_SEPARATOR(in);
    in >> dc.c_4C;
    consume_OUTPUT_SEPARATOR(in);
    in >> dc.c_J;
    consume_OUTPUT_SEPARATOR(in);
    in >> dc.c_L;
 
    return in;
}

◆ operator>>() [35/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt6_ate_G1_precomp &	prec_P )

Definition at line 40 of file mnt6_pairing.cpp.

{
    in >> prec_P.PX;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_P.PY;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_P.PX_twist;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_P.PY_twist;
 
    return in;
}

◆ operator>>() [36/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt6_ate_G2_precomp &	prec_Q )

Definition at line 134 of file mnt6_pairing.cpp.

{
    in >> prec_Q.QX;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.QY;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.QY2;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.QX_over_twist;
    consume_OUTPUT_SEPARATOR(in);
    in >> prec_Q.QY_over_twist;
    consume_newline(in);
 
    prec_Q.dbl_coeffs.clear();
    size_t dbl_s;
    in >> dbl_s;
    consume_newline(in);
 
    prec_Q.dbl_coeffs.reserve(dbl_s);
 
    for (size_t i = 0; i < dbl_s; ++i)
    {
        mnt6_ate_dbl_coeffs dc;
        in >> dc;
        consume_OUTPUT_NEWLINE(in);
        prec_Q.dbl_coeffs.emplace_back(dc);
    }
 
    prec_Q.add_coeffs.clear();
    size_t add_s;
    in >> add_s;
    consume_newline(in);
 
    prec_Q.add_coeffs.reserve(add_s);
 
    for (size_t i = 0; i < add_s; ++i)
    {
        mnt6_ate_add_coeffs ac;
        in >> ac;
        consume_OUTPUT_NEWLINE(in);
        prec_Q.add_coeffs.emplace_back(ac);
    }
 
    return in;
}

◆ operator>>() [37/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt6_G1 &	g )

Definition at line 409 of file mnt6_g1.cpp.

{
    char is_zero;
    mnt6_Fq tX, tY;
 
#ifdef NO_PT_COMPRESSION
    in >> is_zero >> tX >> tY;
    is_zero -= '0';
#else
    in.read((char*)&is_zero, 1); // this reads is_zero;
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
    unsigned char Y_lsb;
    in >> tX;
    consume_OUTPUT_SEPARATOR(in);
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    // y = +/- sqrt(x^3 + a*x + b)
    if (!is_zero)
    {
        mnt6_Fq tX2 = tX.squared();
        mnt6_Fq tY2 = (tX2 + mnt6_G1::coeff_a) * tX + mnt6_G1::coeff_b;
        tY = tY2.sqrt();
 
        if ((tY.as_bigint().data[0] & 1) != Y_lsb)
        {
            tY = -tY;
        }
    }
#endif
    // using projective coordinates
    if (!is_zero)
    {
        g.X = tX;
        g.Y = tY;
        g.Z = mnt6_Fq::one();
    }
    else
    {
        g = mnt6_G1::zero();
    }
 
    return in;
}

◆ operator>>() [38/51]

std::istream & libff::operator>>	(	std::istream &	in,
		mnt6_G2 &	g )

Definition at line 440 of file mnt6_g2.cpp.

{
    char is_zero;
    mnt6_Fq3 tX, tY;
 
#ifdef NO_PT_COMPRESSION
    in >> is_zero >> tX >> tY;
    is_zero -= '0';
#else
    in.read((char*)&is_zero, 1); // this reads is_zero;
    is_zero -= '0';
    consume_OUTPUT_SEPARATOR(in);
 
    unsigned char Y_lsb;
    in >> tX;
    consume_OUTPUT_SEPARATOR(in);
    in.read((char*)&Y_lsb, 1);
    Y_lsb -= '0';
 
    // y = +/- sqrt(x^3 + a*x + b)
    if (!is_zero)
    {
        const mnt6_Fq3 tX2 = tX.squared();
        const mnt6_Fq3 tY2 = (tX2 + mnt6_twist_coeff_a) * tX + mnt6_twist_coeff_b;
        tY = tY2.sqrt();
 
        if ((tY.c0.as_bigint().data[0] & 1) != Y_lsb)
        {
            tY = -tY;
        }
    }
#endif
    // using projective coordinates
    if (!is_zero)
    {
        g.X = tX;
        g.Y = tY;
        g.Z = mnt6_Fq3::one();
    }
    else
    {
        g = mnt6_G2::zero();
    }
 
    return in;
}

◆ operator>>() [39/51]

template<typename T1 , typename T2 >

std::istream & libff::operator>>	(	std::istream &	in,
		std::map< T1, T2 > &	m )

◆ operator>>() [40/51]

template<typename T >

std::istream & libff::operator>>	(	std::istream &	in,
		std::set< T > &	s )

◆ operator>>() [41/51]

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< alt_bn128_G1 > &	v )

Definition at line 482 of file alt_bn128_g1.cpp.

{
    v.clear();
 
    size_t s;
    in >> s;
    consume_newline(in);
 
    v.reserve(s);
 
    for (size_t i = 0; i < s; ++i)
    {
        alt_bn128_G1 g;
        in >> g;
        consume_OUTPUT_NEWLINE(in);
        v.emplace_back(g);
    }
 
    return in;
}

Here is the call graph for this function:

◆ operator>>() [42/51]

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< bn128_G1 > &	v )

Definition at line 486 of file bn128_g1.cpp.

{
    v.clear();
 
    size_t s;
    in >> s;
    consume_newline(in);
    v.reserve(s);
 
    for (size_t i = 0; i < s; ++i)
    {
        bn128_G1 g;
        in >> g;
        consume_OUTPUT_NEWLINE(in);
        v.emplace_back(g);
    }
    return in;
}

Here is the call graph for this function:

◆ operator>>() [43/51]

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< edwards_G1 > &	v )

Definition at line 375 of file edwards_g1.cpp.

{
    v.clear();
 
    size_t s;
    in >> s;
    v.reserve(s);
    consume_newline(in);
 
    for (size_t i = 0; i < s; ++i)
    {
        edwards_G1 g;
        in >> g;
        v.emplace_back(g);
        consume_OUTPUT_NEWLINE(in);
    }
 
    return in;
}

Here is the call graph for this function:

◆ operator>>() [44/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< Fp12_2over3over2_model< n, modulus > > &	v )

◆ operator>>() [45/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< Fp2_model< n, modulus > > &	v )

◆ operator>>() [46/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< Fp3_model< n, modulus > > &	v )

◆ operator>>() [47/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< Fp6_2over3_model< n, modulus > > &	v )

◆ operator>>() [48/51]

template<mp_size_t n, const bigint< n > & modulus>

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< Fp6_3over2_model< n, modulus > > &	v )

◆ operator>>() [49/51]

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< mnt4_G1 > &	v )

Definition at line 467 of file mnt4_g1.cpp.

{
    v.clear();
 
    size_t s;
    in >> s;
 
    consume_newline(in);
 
    v.reserve(s);
 
    for (size_t i = 0; i < s; ++i)
    {
        mnt4_G1 g;
        in >> g;
        consume_OUTPUT_NEWLINE(in);
        v.emplace_back(g);
    }
 
    return in;
}

Here is the call graph for this function:

◆ operator>>() [50/51]

std::istream & libff::operator>>	(	std::istream &	in,
		std::vector< mnt6_G1 > &	v )

Definition at line 467 of file mnt6_g1.cpp.

{
    v.clear();
 
    size_t s;
    in >> s;
    consume_newline(in);
 
    v.reserve(s);
 
    for (size_t i = 0; i < s; ++i)
    {
        mnt6_G1 g;
        in >> g;
        consume_OUTPUT_NEWLINE(in);
        v.emplace_back(g);
    }
 
    return in;
}

Here is the call graph for this function:

◆ operator>>() [51/51]

template<typename T >

std::istream & libff::operator>>	(	std::ostream &	out,
		std::vector< T > &	v )

◆ operator^() [1/8]

template<mp_size_t m>

bn128_GT libff::operator^	(	const bn128_GT &	rhs,
		const bigint< m > &	lhs )

Definition at line 44 of file bn128_gt.hpp.

{
    return power<bn128_GT, m>(rhs, lhs);
}

Here is the call graph for this function:

◆ operator^() [2/8]

template<mp_size_t m, const bigint< m > & modulus_p>

bn128_GT libff::operator^	(	const bn128_GT &	rhs,
		const Fp_model< m, modulus_p > &	lhs )

Definition at line 51 of file bn128_gt.hpp.

{
    return power<bn128_GT, m>(rhs, lhs.as_bigint());
}

Here is the call graph for this function:

◆ operator^() [3/8]

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m>

Fp12_2over3over2_model< n, modulus > libff::operator^	(	const Fp12_2over3over2_model< n, modulus > &	self,
		const bigint< m > &	exponent )

◆ operator^() [4/8]

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m, const bigint< m > & exp_modulus>

Fp12_2over3over2_model< n, modulus > libff::operator^	(	const Fp12_2over3over2_model< n, modulus > &	self,
		const Fp_model< m, exp_modulus > &	exponent )

◆ operator^() [5/8]

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m>

Fp4_model< n, modulus > libff::operator^	(	const Fp4_model< n, modulus > &	self,
		const bigint< m > &	exponent )

◆ operator^() [6/8]

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m, const bigint< m > & modulus_p>

Fp4_model< n, modulus > libff::operator^	(	const Fp4_model< n, modulus > &	self,
		const Fp_model< m, modulus_p > &	exponent )

◆ operator^() [7/8]

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m>

Fp6_2over3_model< n, modulus > libff::operator^	(	const Fp6_2over3_model< n, modulus > &	self,
		const bigint< m > &	exponent )

◆ operator^() [8/8]

template<mp_size_t n, const bigint< n > & modulus, mp_size_t m, const bigint< m > & exp_modulus>

Fp6_2over3_model< n, modulus > libff::operator^	(	const Fp6_2over3_model< n, modulus > &	self,
		const Fp_model< m, exp_modulus > &	exponent )

◆ opt_window_wnaf_exp()

template<typename T , mp_size_t n>

T libff::opt_window_wnaf_exp	(	const T &	base,
		const bigint< n > &	scalar,
		const size_t	scalar_bits )

In additive notation, use wNAF exponentiation (with the window size determined by T) to compute scalar * base.

◆ output_bool()

void libff::output_bool	(	std::ostream &	out,
		const bool	b )

inline

◆ output_bool_vector()

void libff::output_bool_vector	(	std::ostream &	out,
		const std::vector< bool > &	v )

inline

◆ pack_bit_vector_into_field_element_vector() [1/2]

template<typename FieldT >

std::vector< FieldT > libff::pack_bit_vector_into_field_element_vector ( const bit_vector & v )

◆ pack_bit_vector_into_field_element_vector() [2/2]

template<typename FieldT >

std::vector< FieldT > libff::pack_bit_vector_into_field_element_vector	(	const bit_vector &	v,
		const size_t	chunk_bits )

◆ pack_int_vector_into_field_element_vector()

template<typename FieldT >

std::vector< FieldT > libff::pack_int_vector_into_field_element_vector	(	const std::vector< size_t > &	v,
		const size_t	w )

◆ power() [1/2]

template<typename FieldT , mp_size_t m>

FieldT libff::power	(	const FieldT &	base,
		const bigint< m > &	exponent )

Here is the caller graph for this function:

◆ power() [2/2]

template<typename FieldT >

FieldT libff::power	(	const FieldT &	base,
		const unsigned long	exponent )

◆ print_compilation_info()

void libff::print_compilation_info ( )

Definition at line 351 of file profiling.cpp.

{
#ifdef __GNUC__
    printf("g++ version: %s\n", __VERSION__);
    printf("Compiled on %s %s\n", __DATE__, __TIME__);
#endif
#ifdef STATIC
    printf("STATIC: yes\n");
#else
    printf("STATIC: no\n");
#endif
#ifdef MULTICORE
    printf("MULTICORE: yes\n");
#else
    printf("MULTICORE: no\n");
#endif
#ifdef DEBUG
    printf("DEBUG: yes\n");
#else
    printf("DEBUG: no\n");
#endif
#ifdef PROFILE_OP_COUNTS
    printf("PROFILE_OP_COUNTS: yes\n");
#else
    printf("PROFILE_OP_COUNTS: no\n");
#endif
#ifdef _GLIBCXX_DEBUG
    printf("_GLIBCXX_DEBUG: yes\n");
#else
    printf("_GLIBCXX_DEBUG: no\n");
#endif
}

Here is the caller graph for this function:

◆ print_cumulative_op_counts()

void libff::print_cumulative_op_counts ( const bool only_fq )

Definition at line 123 of file profiling.cpp.

{
#ifdef PROFILE_OP_COUNTS
    printf("Dumping operation counts:\n");
    for (auto& msg : invocation_counts)
    {
        printf("  %-45s: ", msg.first.c_str());
        bool first = true;
        for (auto& data_point : op_data_points)
        {
            if (only_fq && data_point.first.compare(0, 2, "Fq") != 0)
            {
                continue;
            }
 
            if (!first)
            {
                printf(", ");
            }
            printf("%-5s = %7.0f (%3zu)",
                   data_point.first.c_str(),
                   1. * cumulative_op_counts[std::make_pair(msg.first, data_point.first)] / msg.second,
                   msg.second);
            first = false;
        }
        printf("\n");
    }
#else
    UNUSED(only_fq);
#endif
}

◆ print_cumulative_time_entry()

void libff::print_cumulative_time_entry	(	const std::string &	key,
		const long long	factor )

Definition at line 106 of file profiling.cpp.

{
    const double total_ms = (cumulative_times.at(key) * 1e-6);
    const size_t cnt = invocation_counts.at(key);
    const double avg_ms = total_ms / cnt;
    printf("   %-45s: %12.5fms = %lld * %0.5fms (%zu invocations, %0.5fms = %lld * %0.5fms per invocation)\n", key.c_str(), total_ms, factor, total_ms/factor, cnt, avg_ms, factor, avg_ms/factor);
}

Here is the caller graph for this function:

◆ print_cumulative_times()

void libff::print_cumulative_times ( const long long factor )

Definition at line 114 of file profiling.cpp.

{
    printf("Dumping times:\n");
    for (auto& kv : cumulative_times)
    {
        print_cumulative_time_entry(kv.first, factor);
    }
}

Here is the call graph for this function:

◆ print_header()

void libff::print_header ( const char * msg )

Definition at line 222 of file profiling.cpp.

{
    printf("\n================================================================================\n");
    printf("%s\n", msg);
    printf("================================================================================\n\n");
}

◆ print_indent()

void libff::print_indent ( )

Definition at line 229 of file profiling.cpp.

{
    for (size_t i = 0; i < indentation; ++i)
    {
        printf("  ");
    }
}

Here is the caller graph for this function:

◆ print_mem()

void libff::print_mem ( const std::string & s )

Definition at line 333 of file profiling.cpp.

{
#ifndef NO_PROCPS
    struct proc_t usage;
    look_up_our_self(&usage);
    if (s.empty())
    {
        printf("* Peak vsize (physical memory+swap) in mebibytes: %lu\n", usage.vsize >> 20);
    }
    else
    {
        printf("* Peak vsize (physical memory+swap) in mebibytes (%s): %lu\n", s.c_str(), usage.vsize >> 20);
    }
#else
    printf("* Memory profiling not supported in NO_PROCPS mode\n");
#endif
}

◆ print_op_profiling()

void libff::print_op_profiling ( const std::string & msg )

Definition at line 155 of file profiling.cpp.

{
#ifdef PROFILE_OP_COUNTS
    printf("\n");
    print_indent();
 
    printf("(opcounts) = (");
    bool first = true;
    for (std::pair<std::string, long long*> p : op_data_points)
    {
        if (!first)
        {
            printf(", ");
        }
 
        printf("%s=%lld", p.first.c_str(), *(p.second)-op_counts[std::make_pair(msg, p.first)]);
        first = false;
    }
    printf(")");
#else
    UNUSED(msg);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ print_time()

void libff::print_time ( const char * msg )

Definition at line 200 of file profiling.cpp.

{
    if (inhibit_profiling_info)
    {
        return;
    }
 
    long long now = get_nsec_time();
    long long cpu_now = get_nsec_cpu_time();
 
    printf("%-35s\t", msg);
    print_times_from_last_and_start(now, last_time, cpu_now, last_cpu_time);
#ifdef PROFILE_OP_COUNTS
    print_op_profiling(msg);
#endif
    printf("\n");
 
    fflush(stdout);
    last_time = now;
    last_cpu_time = cpu_now;
}

Here is the call graph for this function:

◆ reserialize()

template<typename T >

T libff::reserialize ( const T & obj )

Here is the caller graph for this function:

◆ scalar_mul()

template<typename GroupT , mp_size_t m>

GroupT libff::scalar_mul	(	const GroupT &	base,
		const bigint< m > &	scalar )

Here is the caller graph for this function:

◆ serialize_bit_vector()

void libff::serialize_bit_vector	(	std::ostream &	out,
		const bit_vector &	v )

Definition at line 108 of file utils.cpp.

{
    out << v.size() << "\n";
    for (size_t i = 0; i < v.size(); ++i)
    {
        out << v[i] << "\n";
    }
}

◆ SHA512_rng()

template<typename FieldT >

FieldT libff::SHA512_rng ( const uint64_t idx )

Here is the caller graph for this function:

◆ size_in_bits()

template<typename T >

size_t libff::size_in_bits ( const std::vector< T > & v )

◆ start_profiling()

void libff::start_profiling ( )

Definition at line 56 of file profiling.cpp.

{
    printf("Reset time counters for profiling\n");
 
    last_time = start_time = get_nsec_time();
    last_cpu_time = start_cpu_time = get_nsec_cpu_time();
}

Here is the call graph for this function:

Here is the caller graph for this function:

◆ to_twos_complement()

size_t libff::to_twos_complement	(	int	i,
		size_t	w )

Definition at line 47 of file utils.cpp.

{
    assert(i >= -(1l<<(w-1)));
    assert(i < (1l<<(w-1)));
    return (i >= 0) ? i : i + (1l<<w);
}

◆ UNUSED()

template<typename ... Types>

void libff::UNUSED ( Types && ... )

Definition at line 43 of file utils.hpp.

43{}

◆ windowed_exp()

template<typename T , typename FieldT >

T libff::windowed_exp	(	const size_t	scalar_size,
		const size_t	window,
		const window_table< T > &	powers_of_g,
		const FieldT &	pow )

Variable Documentation

◆ alt_bn128_ate_is_loop_count_neg

bool libff::alt_bn128_ate_is_loop_count_neg

Definition at line 26 of file alt_bn128_init.cpp.

◆ alt_bn128_ate_loop_count

bigint< alt_bn128_q_limbs > libff::alt_bn128_ate_loop_count

Definition at line 25 of file alt_bn128_init.cpp.

◆ alt_bn128_coeff_b

alt_bn128_Fq libff::alt_bn128_coeff_b

Definition at line 17 of file alt_bn128_init.cpp.

◆ alt_bn128_final_exponent

bigint< 12 *alt_bn128_q_limbs > libff::alt_bn128_final_exponent

Definition at line 27 of file alt_bn128_init.cpp.

◆ alt_bn128_final_exponent_is_z_neg

bool libff::alt_bn128_final_exponent_is_z_neg

Definition at line 29 of file alt_bn128_init.cpp.

◆ alt_bn128_final_exponent_z

bigint< alt_bn128_q_limbs > libff::alt_bn128_final_exponent_z

Definition at line 28 of file alt_bn128_init.cpp.

◆ alt_bn128_modulus_q

bigint< alt_bn128_q_limbs > libff::alt_bn128_modulus_q

Definition at line 15 of file alt_bn128_init.cpp.

◆ alt_bn128_modulus_r

bigint< alt_bn128_r_limbs > libff::alt_bn128_modulus_r

Definition at line 14 of file alt_bn128_init.cpp.

◆ alt_bn128_q_bitcount

const mp_size_t libff::alt_bn128_q_bitcount = 254

Definition at line 19 of file alt_bn128_init.hpp.

◆ alt_bn128_q_limbs

const mp_size_t libff::alt_bn128_q_limbs = (alt_bn128_q_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

Definition at line 22 of file alt_bn128_init.hpp.

◆ alt_bn128_r_bitcount

const mp_size_t libff::alt_bn128_r_bitcount = 254

Definition at line 18 of file alt_bn128_init.hpp.

◆ alt_bn128_r_limbs

const mp_size_t libff::alt_bn128_r_limbs = (alt_bn128_r_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

Definition at line 21 of file alt_bn128_init.hpp.

◆ alt_bn128_twist

alt_bn128_Fq2 libff::alt_bn128_twist

Definition at line 18 of file alt_bn128_init.cpp.

◆ alt_bn128_twist_coeff_b

alt_bn128_Fq2 libff::alt_bn128_twist_coeff_b

Definition at line 19 of file alt_bn128_init.cpp.

◆ alt_bn128_twist_mul_by_b_c0

alt_bn128_Fq libff::alt_bn128_twist_mul_by_b_c0

Definition at line 20 of file alt_bn128_init.cpp.

◆ alt_bn128_twist_mul_by_b_c1

alt_bn128_Fq libff::alt_bn128_twist_mul_by_b_c1

Definition at line 21 of file alt_bn128_init.cpp.

◆ alt_bn128_twist_mul_by_q_X

alt_bn128_Fq2 libff::alt_bn128_twist_mul_by_q_X

Definition at line 22 of file alt_bn128_init.cpp.

◆ alt_bn128_twist_mul_by_q_Y

alt_bn128_Fq2 libff::alt_bn128_twist_mul_by_q_Y

Definition at line 23 of file alt_bn128_init.cpp.

◆ block_names

std::vector<std::string> libff::block_names

Definition at line 76 of file profiling.cpp.

◆ bn128_coeff_b

bn::Fp libff::bn128_coeff_b

Definition at line 18 of file bn128_init.cpp.

◆ bn128_Fq2_nqr_to_t

bn::Fp2 libff::bn128_Fq2_nqr_to_t

Definition at line 25 of file bn128_init.cpp.

◆ bn128_Fq2_s

size_t libff::bn128_Fq2_s

Definition at line 24 of file bn128_init.cpp.

◆ bn128_Fq2_t_minus_1_over_2

mie::Vuint libff::bn128_Fq2_t_minus_1_over_2

Definition at line 26 of file bn128_init.cpp.

◆ bn128_Fq_nqr_to_t

bn::Fp libff::bn128_Fq_nqr_to_t

Definition at line 20 of file bn128_init.cpp.

◆ bn128_Fq_s

size_t libff::bn128_Fq_s

Definition at line 19 of file bn128_init.cpp.

◆ bn128_Fq_t_minus_1_over_2

mie::Vuint libff::bn128_Fq_t_minus_1_over_2

Definition at line 21 of file bn128_init.cpp.

◆ bn128_modulus_q

bigint< bn128_q_limbs > libff::bn128_modulus_q

Definition at line 16 of file bn128_init.cpp.

◆ bn128_modulus_r

bigint< bn128_r_limbs > libff::bn128_modulus_r

Definition at line 15 of file bn128_init.cpp.

◆ bn128_q_bitcount

const mp_size_t libff::bn128_q_bitcount = 254

Definition at line 18 of file bn128_init.hpp.

◆ bn128_q_limbs

const mp_size_t libff::bn128_q_limbs = (bn128_q_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

Definition at line 21 of file bn128_init.hpp.

◆ bn128_r_bitcount

const mp_size_t libff::bn128_r_bitcount = 254

Definition at line 17 of file bn128_init.hpp.

◆ bn128_r_limbs

const mp_size_t libff::bn128_r_limbs = (bn128_r_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

Definition at line 20 of file bn128_init.hpp.

◆ bn128_twist_coeff_b

bn::Fp2 libff::bn128_twist_coeff_b

Definition at line 23 of file bn128_init.cpp.

◆ cumulative_op_counts

std::map<std::pair<std::string, std::string>, long long> libff::cumulative_op_counts

Definition at line 72 of file profiling.cpp.

◆ cumulative_times

std::map< std::string, long long > libff::cumulative_times

Definition at line 67 of file profiling.cpp.

◆ edwards_ate_loop_count

bigint< edwards_q_limbs > libff::edwards_ate_loop_count

Definition at line 31 of file edwards_init.cpp.

◆ edwards_coeff_a

edwards_Fq libff::edwards_coeff_a

Definition at line 17 of file edwards_init.cpp.

◆ edwards_coeff_d

edwards_Fq libff::edwards_coeff_d

Definition at line 18 of file edwards_init.cpp.

◆ edwards_final_exponent

bigint< 6 *edwards_q_limbs > libff::edwards_final_exponent

Definition at line 32 of file edwards_init.cpp.

◆ edwards_final_exponent_last_chunk_abs_of_w0

bigint< edwards_q_limbs > libff::edwards_final_exponent_last_chunk_abs_of_w0

Definition at line 33 of file edwards_init.cpp.

◆ edwards_final_exponent_last_chunk_is_w0_neg

bool libff::edwards_final_exponent_last_chunk_is_w0_neg

Definition at line 34 of file edwards_init.cpp.

◆ edwards_final_exponent_last_chunk_w1

bigint< edwards_q_limbs > libff::edwards_final_exponent_last_chunk_w1

Definition at line 35 of file edwards_init.cpp.

◆ edwards_modulus_q

bigint< edwards_q_limbs > libff::edwards_modulus_q

Definition at line 15 of file edwards_init.cpp.

◆ edwards_modulus_r

bigint< edwards_r_limbs > libff::edwards_modulus_r

Definition at line 14 of file edwards_init.cpp.

◆ edwards_q_bitcount

const mp_size_t libff::edwards_q_bitcount = 183

Definition at line 18 of file edwards_init.hpp.

◆ edwards_q_limbs

const mp_size_t libff::edwards_q_limbs = (edwards_q_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

Definition at line 21 of file edwards_init.hpp.

◆ edwards_r_bitcount

const mp_size_t libff::edwards_r_bitcount = 181

Definition at line 17 of file edwards_init.hpp.

◆ edwards_r_limbs

const mp_size_t libff::edwards_r_limbs = (edwards_r_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

Definition at line 20 of file edwards_init.hpp.

◆ edwards_twist

edwards_Fq3 libff::edwards_twist

Definition at line 19 of file edwards_init.cpp.

◆ edwards_twist_coeff_a

edwards_Fq3 libff::edwards_twist_coeff_a

Definition at line 20 of file edwards_init.cpp.

◆ edwards_twist_coeff_d

edwards_Fq3 libff::edwards_twist_coeff_d

Definition at line 21 of file edwards_init.cpp.

◆ edwards_twist_mul_by_a_c0

edwards_Fq libff::edwards_twist_mul_by_a_c0

Definition at line 22 of file edwards_init.cpp.

◆ edwards_twist_mul_by_a_c1

edwards_Fq libff::edwards_twist_mul_by_a_c1

Definition at line 23 of file edwards_init.cpp.

◆ edwards_twist_mul_by_a_c2

edwards_Fq libff::edwards_twist_mul_by_a_c2

Definition at line 24 of file edwards_init.cpp.

◆ edwards_twist_mul_by_d_c0

edwards_Fq libff::edwards_twist_mul_by_d_c0

Definition at line 25 of file edwards_init.cpp.

◆ edwards_twist_mul_by_d_c1

edwards_Fq libff::edwards_twist_mul_by_d_c1

Definition at line 26 of file edwards_init.cpp.

◆ edwards_twist_mul_by_d_c2

edwards_Fq libff::edwards_twist_mul_by_d_c2

Definition at line 27 of file edwards_init.cpp.

◆ edwards_twist_mul_by_q_Y

edwards_Fq libff::edwards_twist_mul_by_q_Y

Definition at line 28 of file edwards_init.cpp.

◆ edwards_twist_mul_by_q_Z

edwards_Fq libff::edwards_twist_mul_by_q_Z

Definition at line 29 of file edwards_init.cpp.

◆ enter_cpu_times

std::map<std::string, long long> libff::enter_cpu_times

Definition at line 69 of file profiling.cpp.

◆ enter_times

std::map<std::string, long long> libff::enter_times

Definition at line 65 of file profiling.cpp.

◆ indentation

size_t libff::indentation = 0

Definition at line 74 of file profiling.cpp.

◆ inhibit_profiling_counters

bool libff::inhibit_profiling_counters = false

Definition at line 96 of file profiling.cpp.

◆ inhibit_profiling_info

bool libff::inhibit_profiling_info = false

Definition at line 95 of file profiling.cpp.

◆ invocation_counts

std::map< std::string, size_t > libff::invocation_counts

Definition at line 64 of file profiling.cpp.

◆ last_cpu_time

long long libff::last_cpu_time

Definition at line 54 of file profiling.cpp.

◆ last_cpu_times

std::map<std::string, long long> libff::last_cpu_times

Definition at line 70 of file profiling.cpp.

◆ last_time

long long libff::last_time

Definition at line 53 of file profiling.cpp.

◆ last_times

std::map< std::string, long long > libff::last_times

Definition at line 66 of file profiling.cpp.

◆ mnt46_A_bitcount

const mp_size_t libff::mnt46_A_bitcount = 298

Definition at line 19 of file mnt46_common.hpp.

◆ mnt46_A_limbs

const mp_size_t libff::mnt46_A_limbs = (mnt46_A_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

Definition at line 22 of file mnt46_common.hpp.

◆ mnt46_B_bitcount

const mp_size_t libff::mnt46_B_bitcount = 298

Definition at line 20 of file mnt46_common.hpp.

◆ mnt46_B_limbs

const mp_size_t libff::mnt46_B_limbs = (mnt46_B_bitcount+GMP_NUMB_BITS-1)/GMP_NUMB_BITS

Definition at line 23 of file mnt46_common.hpp.

◆ mnt46_modulus_A

bigint< mnt46_A_limbs > libff::mnt46_modulus_A

Definition at line 18 of file mnt46_common.cpp.

◆ mnt46_modulus_B

bigint< mnt46_B_limbs > libff::mnt46_modulus_B

Definition at line 19 of file mnt46_common.cpp.

◆ mnt4_ate_is_loop_count_neg

bool libff::mnt4_ate_is_loop_count_neg

Definition at line 34 of file mnt4_init.cpp.

◆ mnt4_ate_loop_count

bigint< mnt4_q_limbs > libff::mnt4_ate_loop_count

Definition at line 33 of file mnt4_init.cpp.

◆ mnt4_final_exponent

bigint< 4 *mnt4_q_limbs > libff::mnt4_final_exponent

Definition at line 35 of file mnt4_init.cpp.

◆ mnt4_final_exponent_last_chunk_abs_of_w0

bigint< mnt4_q_limbs > libff::mnt4_final_exponent_last_chunk_abs_of_w0

Definition at line 36 of file mnt4_init.cpp.

◆ mnt4_final_exponent_last_chunk_is_w0_neg

bool libff::mnt4_final_exponent_last_chunk_is_w0_neg

Definition at line 37 of file mnt4_init.cpp.

◆ mnt4_final_exponent_last_chunk_w1

bigint< mnt4_q_limbs > libff::mnt4_final_exponent_last_chunk_w1

Definition at line 38 of file mnt4_init.cpp.

◆ mnt4_modulus_q

bigint<mnt4_q_limbs> libff::mnt4_modulus_q

extern

◆ mnt4_modulus_r

bigint<mnt4_r_limbs> libff::mnt4_modulus_r

extern

◆ mnt4_q_bitcount

const mp_size_t libff::mnt4_q_bitcount = mnt46_B_bitcount

Definition at line 27 of file mnt4_init.hpp.

◆ mnt4_q_limbs

const mp_size_t libff::mnt4_q_limbs = mnt46_B_limbs

Definition at line 30 of file mnt4_init.hpp.

◆ mnt4_r_bitcount

const mp_size_t libff::mnt4_r_bitcount = mnt46_A_bitcount

Definition at line 26 of file mnt4_init.hpp.

◆ mnt4_r_limbs

const mp_size_t libff::mnt4_r_limbs = mnt46_A_limbs

Definition at line 29 of file mnt4_init.hpp.

◆ mnt4_twist

mnt4_Fq2 libff::mnt4_twist

Definition at line 23 of file mnt4_init.cpp.

◆ mnt4_twist_coeff_a

mnt4_Fq2 libff::mnt4_twist_coeff_a

Definition at line 24 of file mnt4_init.cpp.

◆ mnt4_twist_coeff_b

mnt4_Fq2 libff::mnt4_twist_coeff_b

Definition at line 25 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_a_c0

mnt4_Fq libff::mnt4_twist_mul_by_a_c0

Definition at line 26 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_a_c1

mnt4_Fq libff::mnt4_twist_mul_by_a_c1

Definition at line 27 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_b_c0

mnt4_Fq libff::mnt4_twist_mul_by_b_c0

Definition at line 28 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_b_c1

mnt4_Fq libff::mnt4_twist_mul_by_b_c1

Definition at line 29 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_q_X

mnt4_Fq libff::mnt4_twist_mul_by_q_X

Definition at line 30 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_q_Y

mnt4_Fq libff::mnt4_twist_mul_by_q_Y

Definition at line 31 of file mnt4_init.cpp.

◆ mnt6_ate_is_loop_count_neg

bool libff::mnt6_ate_is_loop_count_neg

Definition at line 36 of file mnt6_init.cpp.

◆ mnt6_ate_loop_count

bigint< mnt6_q_limbs > libff::mnt6_ate_loop_count

Definition at line 35 of file mnt6_init.cpp.

◆ mnt6_final_exponent

bigint< 6 *mnt6_q_limbs > libff::mnt6_final_exponent

Definition at line 37 of file mnt6_init.cpp.

◆ mnt6_final_exponent_last_chunk_abs_of_w0

bigint< mnt6_q_limbs > libff::mnt6_final_exponent_last_chunk_abs_of_w0

Definition at line 38 of file mnt6_init.cpp.

◆ mnt6_final_exponent_last_chunk_is_w0_neg

bool libff::mnt6_final_exponent_last_chunk_is_w0_neg

Definition at line 39 of file mnt6_init.cpp.

◆ mnt6_final_exponent_last_chunk_w1

bigint< mnt6_q_limbs > libff::mnt6_final_exponent_last_chunk_w1

Definition at line 40 of file mnt6_init.cpp.

◆ mnt6_modulus_q

bigint<mnt6_q_limbs> libff::mnt6_modulus_q

extern

◆ mnt6_modulus_r

bigint<mnt6_r_limbs> libff::mnt6_modulus_r

extern

◆ mnt6_q_bitcount

const mp_size_t libff::mnt6_q_bitcount = mnt46_A_bitcount

Definition at line 27 of file mnt6_init.hpp.

◆ mnt6_q_limbs

const mp_size_t libff::mnt6_q_limbs = mnt46_A_limbs

Definition at line 30 of file mnt6_init.hpp.

◆ mnt6_r_bitcount

const mp_size_t libff::mnt6_r_bitcount = mnt46_B_bitcount

Definition at line 26 of file mnt6_init.hpp.

◆ mnt6_r_limbs

const mp_size_t libff::mnt6_r_limbs = mnt46_B_limbs

Definition at line 29 of file mnt6_init.hpp.

◆ mnt6_twist

mnt6_Fq3 libff::mnt6_twist

Definition at line 23 of file mnt6_init.cpp.

◆ mnt6_twist_coeff_a

mnt6_Fq3 libff::mnt6_twist_coeff_a

Definition at line 24 of file mnt6_init.cpp.

◆ mnt6_twist_coeff_b

mnt6_Fq3 libff::mnt6_twist_coeff_b

Definition at line 25 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_a_c0

mnt6_Fq libff::mnt6_twist_mul_by_a_c0

Definition at line 26 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_a_c1

mnt6_Fq libff::mnt6_twist_mul_by_a_c1

Definition at line 27 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_a_c2

mnt6_Fq libff::mnt6_twist_mul_by_a_c2

Definition at line 28 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_b_c0

mnt6_Fq libff::mnt6_twist_mul_by_b_c0

Definition at line 29 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_b_c1

mnt6_Fq libff::mnt6_twist_mul_by_b_c1

Definition at line 30 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_b_c2

mnt6_Fq libff::mnt6_twist_mul_by_b_c2

Definition at line 31 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_q_X

mnt6_Fq libff::mnt6_twist_mul_by_q_X

Definition at line 32 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_q_Y

mnt6_Fq libff::mnt6_twist_mul_by_q_Y

Definition at line 33 of file mnt6_init.cpp.

◆ op_counts

std::map<std::pair<std::string, std::string>, long long> libff::op_counts

Definition at line 71 of file profiling.cpp.

◆ op_data_points

std::list<std::pair<std::string, long long*> > libff::op_data_points

Initial value:

= {
 
}

Definition at line 78 of file profiling.cpp.

                                                          {
#ifdef PROFILE_OP_COUNTS
    std::make_pair("Fradd", &Fr<default_ec_pp>::add_cnt),
    std::make_pair("Frsub", &Fr<default_ec_pp>::sub_cnt),
    std::make_pair("Frmul", &Fr<default_ec_pp>::mul_cnt),
    std::make_pair("Frinv", &Fr<default_ec_pp>::inv_cnt),
    std::make_pair("Fqadd", &Fq<default_ec_pp>::add_cnt),
    std::make_pair("Fqsub", &Fq<default_ec_pp>::sub_cnt),
    std::make_pair("Fqmul", &Fq<default_ec_pp>::mul_cnt),
    std::make_pair("Fqinv", &Fq<default_ec_pp>::inv_cnt),
    std::make_pair("G1add", &G1<default_ec_pp>::add_cnt),
    std::make_pair("G1dbl", &G1<default_ec_pp>::dbl_cnt),
    std::make_pair("G2add", &G2<default_ec_pp>::add_cnt),
    std::make_pair("G2dbl", &G2<default_ec_pp>::dbl_cnt)
#endif
};

◆ PI

const double libff::PI = 3.141592653589793238460264338328L

Definition at line 22 of file double.cpp.

◆ start_cpu_time

long long libff::start_cpu_time

Definition at line 54 of file profiling.cpp.

◆ start_time

long long libff::start_time

Definition at line 53 of file profiling.cpp.

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ affine_ate_G1_precomp

◆ affine_ate_G2_precomp

◆ alt_bn128_Fq

◆ alt_bn128_Fq12

◆ alt_bn128_Fq2

◆ alt_bn128_Fq6

◆ alt_bn128_Fr

◆ alt_bn128_G1_precomp

◆ alt_bn128_G2_precomp

◆ alt_bn128_GT

◆ bit_vector

◆ bn128_ate_ell_coeffs

◆ bn128_Fq

◆ bn128_Fq12

◆ bn128_Fr

◆ edwards_ate_G2_precomp

◆ edwards_Fq

◆ edwards_Fq3

◆ edwards_Fq6

◆ edwards_Fr

◆ edwards_G1_precomp

◆ edwards_G2_precomp

◆ edwards_GT

◆ edwards_tate_G1_precomp

◆ Fq

◆ Fqe

◆ Fqk

◆ Fr

◆ Fr_vector

◆ G1

◆ G1_precomp

◆ G1_vector

◆ G2

◆ G2_precomp

◆ G2_vector

◆ GT

◆ mnt4_Fq

◆ mnt4_Fq2

◆ mnt4_Fq4

◆ mnt4_Fr

◆ mnt4_G1_precomp

◆ mnt4_G2_precomp

◆ mnt4_GT

◆ mnt6_Fq

◆ mnt6_Fq3

◆ mnt6_Fq6

◆ mnt6_Fr

◆ mnt6_G1_precomp

◆ mnt6_G2_precomp

◆ mnt6_GT

◆ window_table

Enumeration Type Documentation

◆ multi_exp_method

Function Documentation

◆ alt_bn128_affine_reduced_pairing()

◆ alt_bn128_ate_double_miller_loop()

◆ alt_bn128_ate_miller_loop()

◆ alt_bn128_ate_pairing()

◆ alt_bn128_ate_precompute_G1()

◆ alt_bn128_ate_precompute_G2()

◆ alt_bn128_ate_reduced_pairing()

◆ alt_bn128_double_miller_loop()

◆ alt_bn128_exp_by_neg_z()

◆ alt_bn128_final_exponentiation()

◆ alt_bn128_final_exponentiation_first_chunk()

◆ alt_bn128_final_exponentiation_last_chunk()

◆ alt_bn128_miller_loop()

◆ alt_bn128_pairing()

◆ alt_bn128_precompute_G1()

◆ alt_bn128_precompute_G2()

◆ alt_bn128_reduced_pairing()

◆ batch_exp()

◆ batch_exp_with_coeff()

◆ batch_invert()