Namespaces
	ffi

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	bls12_377_ate_ell_coeffs

struct	bls12_377_ate_G1_precomp

struct	bls12_377_ate_G2_precomp

class	bls12_377_G1

class	bls12_377_G2

class	bls12_377_pp

struct	bls12_381_ate_ell_coeffs

struct	bls12_381_ate_G1_precomp

struct	bls12_381_ate_G2_precomp

class	bls12_381_G1

class	bls12_381_G2

class	bls12_381_pp

struct	bn128_ate_G1_precomp

struct	bn128_ate_G2_precomp

class	bn128_G1

class	bn128_G2

class	bn128_GT

class	bn128_pp

struct	bw6_761_ate_ell_coeffs

struct	bw6_761_ate_G1_precomp

struct	bw6_761_ate_G2_precomp

struct	bw6_761_ate_G2_precomp_iteration

class	bw6_761_G1

class	bw6_761_G2

class	bw6_761_pp

class	concurrent_buffer_fifo_spsc

class	concurrent_fifo_spsc

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< bls12_377_r_limbs, bls12_377_modulus_r >	bls12_377_Fr

typedef Fp_model< bls12_377_q_limbs, bls12_377_modulus_q >	bls12_377_Fq

typedef Fp2_model< bls12_377_q_limbs, bls12_377_modulus_q >	bls12_377_Fq2

typedef Fp6_3over2_model< bls12_377_q_limbs, bls12_377_modulus_q >	bls12_377_Fq6

typedef Fp12_2over3over2_model< bls12_377_q_limbs, bls12_377_modulus_q >	bls12_377_Fq12

typedef bls12_377_Fq12	bls12_377_GT

typedef bls12_377_ate_G1_precomp	bls12_377_G1_precomp

typedef bls12_377_ate_G2_precomp	bls12_377_G2_precomp

typedef Fp_model< bls12_381_r_limbs, bls12_381_modulus_r >	bls12_381_Fr

typedef Fp_model< bls12_381_q_limbs, bls12_381_modulus_q >	bls12_381_Fq

typedef Fp2_model< bls12_381_q_limbs, bls12_381_modulus_q >	bls12_381_Fq2

typedef Fp6_3over2_model< bls12_381_q_limbs, bls12_381_modulus_q >	bls12_381_Fq6

typedef Fp12_2over3over2_model< bls12_381_q_limbs, bls12_381_modulus_q >	bls12_381_Fq12

typedef bls12_381_Fq12	bls12_381_GT

typedef bls12_381_ate_G1_precomp	bls12_381_G1_precomp

typedef bls12_381_ate_G2_precomp	bls12_381_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< bw6_761_r_limbs, bw6_761_modulus_r >	bw6_761_Fr

typedef Fp_model< bw6_761_q_limbs, bw6_761_modulus_q >	bw6_761_Fq

typedef Fp3_model< bw6_761_q_limbs, bw6_761_modulus_q >	bw6_761_Fq3

typedef Fp6_2over3_model< bw6_761_q_limbs, bw6_761_modulus_q >	bw6_761_Fq6

typedef bw6_761_Fq6	bw6_761_GT

typedef bw6_761_ate_G1_precomp	bw6_761_G1_precomp

typedef bw6_761_ate_G2_precomp	bw6_761_G2_precomp

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, multi_exp_method_BDLO12_signed }

enum	multi_exp_base_form { multi_exp_base_form_normal, multi_exp_base_form_special }
	Form of base elements passed to multi_exp routines. More...

enum	encoding_t : uint8_t { encoding_binary = 0, encoding_json = 1 }
	Encodings for (de)serialization. More...

enum	form_t : uint8_t { form_plain = 0, form_montgomery = 1 }
	Encodings for (de)serialization. More...

enum	compression_t : uint8_t { compression_off = 0, compression_on = 1 }
	Enable / disable compression in (de)serialization. More...

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

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

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 bls12_377_G1 &g)

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

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

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

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

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

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

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

void	init_bls12_377_params ()

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

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

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

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

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

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

bls12_377_Fq12	bls12_377_final_exponentiation_first_chunk (const bls12_377_Fq12 &elt)

bls12_377_Fq12	bls12_377_exp_by_z (const bls12_377_Fq12 &elt)

bls12_377_Fq12	bls12_377_final_exponentiation_last_chunk (const bls12_377_Fq12 &elt)

bls12_377_GT	bls12_377_final_exponentiation (const bls12_377_Fq12 &elt)

void	bls12_377_doubling_step_for_miller_loop (const bls12_377_Fq two_inv, bls12_377_G2 &current, bls12_377_ate_ell_coeffs &c)

void	bls12_377_mixed_addition_step_for_miller_loop (const bls12_377_G2 &base, bls12_377_G2 &current, bls12_377_ate_ell_coeffs &c)

bls12_377_ate_G1_precomp	bls12_377_ate_precompute_G1 (const bls12_377_G1 &P)

bls12_377_ate_G2_precomp	bls12_377_ate_precompute_G2 (const bls12_377_G2 &Q)

bls12_377_Fq12	bls12_377_ate_miller_loop (const bls12_377_ate_G1_precomp &prec_P, const bls12_377_ate_G2_precomp &prec_Q)

bls12_377_Fq12	bls12_377_ate_double_miller_loop (const bls12_377_ate_G1_precomp &prec_P1, const bls12_377_ate_G2_precomp &prec_Q1, const bls12_377_ate_G1_precomp &prec_P2, const bls12_377_ate_G2_precomp &prec_Q2)

bls12_377_Fq12	bls12_377_ate_pairing (const bls12_377_G1 &P, const bls12_377_G2 &Q)

bls12_377_GT	bls12_377_ate_reduced_pairing (const bls12_377_G1 &P, const bls12_377_G2 &Q)

bls12_377_G1_precomp	bls12_377_precompute_G1 (const bls12_377_G1 &P)

bls12_377_G2_precomp	bls12_377_precompute_G2 (const bls12_377_G2 &Q)

bls12_377_Fq12	bls12_377_miller_loop (const bls12_377_G1_precomp &prec_P, const bls12_377_G2_precomp &prec_Q)

bls12_377_Fq12	bls12_377_double_miller_loop (const bls12_377_G1_precomp &prec_P1, const bls12_377_G2_precomp &prec_Q1, const bls12_377_G1_precomp &prec_P2, const bls12_377_G2_precomp &prec_Q2)

bls12_377_Fq12	bls12_377_pairing (const bls12_377_G1 &P, const bls12_377_G2 &Q)

bls12_377_GT	bls12_377_reduced_pairing (const bls12_377_G1 &P, const bls12_377_G2 &Q)

bls12_377_GT	bls12_377_affine_reduced_pairing (const bls12_377_G1 &P, const bls12_377_G2 &Q)

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

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

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

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

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

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

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

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

void	init_bls12_381_params ()

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

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

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

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

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

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

bls12_381_Fq12	bls12_381_final_exponentiation_first_chunk (const bls12_381_Fq12 &elt)

bls12_381_Fq12	bls12_381_exp_by_z (const bls12_381_Fq12 &elt)

bls12_381_Fq12	bls12_381_final_exponentiation_last_chunk (const bls12_381_Fq12 &elt)

bls12_381_GT	bls12_381_final_exponentiation (const bls12_381_Fq12 &elt)

void	bls12_381_doubling_step_for_miller_loop (const bls12_381_Fq two_inv, bls12_381_G2 &current, bls12_381_ate_ell_coeffs &c)

void	bls12_381_mixed_addition_step_for_miller_loop (const bls12_381_G2 base, bls12_381_G2 &current, bls12_381_ate_ell_coeffs &c)

bls12_381_ate_G1_precomp	bls12_381_ate_precompute_G1 (const bls12_381_G1 &P)

bls12_381_ate_G2_precomp	bls12_381_ate_precompute_G2 (const bls12_381_G2 &Q)

bls12_381_Fq12	bls12_381_ate_miller_loop (const bls12_381_ate_G1_precomp &prec_P, const bls12_381_ate_G2_precomp &prec_Q)

bls12_381_Fq12	bls12_381_ate_double_miller_loop (const bls12_381_ate_G1_precomp &prec_P1, const bls12_381_ate_G2_precomp &prec_Q1, const bls12_381_ate_G1_precomp &prec_P2, const bls12_381_ate_G2_precomp &prec_Q2)

bls12_381_Fq12	bls12_381_ate_pairing (const bls12_381_G1 &P, const bls12_381_G2 &Q)

bls12_381_GT	bls12_381_ate_reduced_pairing (const bls12_381_G1 &P, const bls12_381_G2 &Q)

bls12_381_G1_precomp	bls12_381_precompute_G1 (const bls12_381_G1 &P)

bls12_381_G2_precomp	bls12_381_precompute_G2 (const bls12_381_G2 &Q)

bls12_381_Fq12	bls12_381_miller_loop (const bls12_381_G1_precomp &prec_P, const bls12_381_G2_precomp &prec_Q)

bls12_381_Fq12	bls12_381_double_miller_loop (const bls12_381_G1_precomp &prec_P1, const bls12_381_G2_precomp &prec_Q1, const bls12_381_G1_precomp &prec_P2, const bls12_381_G2_precomp &prec_Q2)

bls12_381_Fq12	bls12_381_pairing (const bls12_381_G1 &P, const bls12_381_G2 &Q)

bls12_381_GT	bls12_381_reduced_pairing (const bls12_381_G1 &P, const bls12_381_G2 &Q)

bls12_381_GT	bls12_381_affine_reduced_pairing (const bls12_381_G1 &P, const bls12_381_G2 &Q)

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

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

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)

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

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

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

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

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

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

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

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

void	init_bw6_761_params ()

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

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

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

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

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

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

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

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

bw6_761_Fq6	bw6_761_final_exponentiation_first_chunk (const bw6_761_Fq6 &elt)

bw6_761_Fq6	bw6_761_exp_by_z (const bw6_761_Fq6 &elt)

bw6_761_Fq6	bw6_761_final_exponentiation_last_chunk (const bw6_761_Fq6 &elt)

bw6_761_GT	bw6_761_final_exponentiation (const bw6_761_Fq6 &elt)

void	doubling_step_for_miller_loop (bw6_761_G2 &current, bw6_761_ate_ell_coeffs &c)

void	mixed_addition_step_for_miller_loop (const bw6_761_G2 base, bw6_761_G2 &current, bw6_761_ate_ell_coeffs &c)

bw6_761_ate_G1_precomp	bw6_761_ate_precompute_G1 (const bw6_761_G1 &P)

bw6_761_ate_G2_precomp	bw6_761_ate_precompute_G2 (const bw6_761_G2 &Q)

bw6_761_Fq6	bw6_761_ate_miller_loop (const bw6_761_ate_G1_precomp &prec_P, const bw6_761_ate_G2_precomp &prec_Q)

bw6_761_Fq6	bw6_761_ate_double_miller_loop (const bw6_761_ate_G1_precomp &prec_P1, const bw6_761_ate_G2_precomp &prec_Q1, const bw6_761_ate_G1_precomp &prec_P2, const bw6_761_ate_G2_precomp &prec_Q2)

bw6_761_Fq6	bw6_761_ate_pairing (const bw6_761_G1 &P, const bw6_761_G2 &Q)

bw6_761_GT	bw6_761_ate_reduced_pairing (const bw6_761_G1 &P, const bw6_761_G2 &Q)

bw6_761_G1_precomp	bw6_761_precompute_G1 (const bw6_761_G1 &P)

bw6_761_G2_precomp	bw6_761_precompute_G2 (const bw6_761_G2 &Q)

bw6_761_Fq6	bw6_761_miller_loop (const bw6_761_G1_precomp &prec_P, const bw6_761_G2_precomp &prec_Q)

bw6_761_Fq6	bw6_761_double_miller_loop (const bw6_761_ate_G1_precomp &prec_P1, const bw6_761_ate_G2_precomp &prec_Q1, const bw6_761_ate_G1_precomp &prec_P2, const bw6_761_ate_G2_precomp &prec_Q2)

bw6_761_Fq6	bw6_761_pairing (const bw6_761_G1 &P, const bw6_761_G2 &Q)

bw6_761_GT	bw6_761_reduced_pairing (const bw6_761_G1 &P, const bw6_761_G2 &Q)

template<encoding_t Enc, form_t Form, compression_t Comp, typename GroupT >
void	group_read (GroupT &v, std::istream &in_s)

template<encoding_t Enc, form_t Form, compression_t Comp, typename GroupT >
void	group_write (const GroupT &v, std::ostream &out_s)

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

template<typename GroupT >
GroupT	g1_curve_point_at_x (const typename GroupT::base_field &x)

template<typename GroupT >
GroupT	g2_curve_point_at_x (const typename GroupT::twist_field &x)

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

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

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)

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)

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 &, const bigint< n > &)

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

template<typename BigIntT >
void	bigint_from_hex (BigIntT &v, const std::string &hex)

template<typename BigIntT >
std::string	bigint_to_hex (const BigIntT &v, bool prefix=false)

template<encoding_t Enc = encoding_binary, form_t Form = form_plain, typename FieldT >
void	field_read (FieldT &v, std::istream &in_s)

template<encoding_t Enc = encoding_binary, form_t Form = form_plain, typename FieldT >
void	field_write (const FieldT &v, std::ostream &out_s)

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

template<typename FieldT >
std::enable_if<!std::is_same< FieldT, Double >::value, bool >::type	has_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::enable_if<!std::is_same< FieldT, Double >::value, FieldT >::type	get_root_of_unity (const size_t n)

template<mp_size_t n>
size_t	field_get_digit (const bigint< n > &v, const size_t digit_size, const size_t digit_index)
	Decompose v into fixed-size digits of digit_size bits each. More...

template<mp_size_t n>
ssize_t	field_get_signed_digit (const bigint< n > &v, const size_t digit_size, const size_t digit_index)
	Decompose v into fixed-size signed digits of digit_size bits each. More...

template<typename FieldT >
void	field_get_signed_digits (std::vector< ssize_t > &digits, const FieldT &v, const size_t digit_size, const size_t num_digits)

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<typename FieldT >
const FieldT::my_Fp &	field_get_component_0 (const FieldT &v)

template<mp_size_t wn, const bigint< wn > & wmodulus, mp_size_t nn, const bigint< nn > & nmodulus>
void	fp_from_fp (Fp_model< wn, wmodulus > &wfp, const Fp_model< nn, nmodulus > &nfp)

template<typename FieldT >
void	print_vector (const std::vector< FieldT > &v)
	print the elements of a vector More...

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 &, Fp_model< n, modulus > &)

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 &, Fp12_2over3over2_model< n, modulus > &)

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 &, Fp2_model< n, modulus > &)

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 &, Fp3_model< n, modulus > &)

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 &, Fp4_model< n, modulus > &)

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 &, Fp6_2over3_model< n, modulus > &)

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 &, Fp6_3over2_model< n, modulus > &)

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, multi_exp_base_form BaseForm = multi_exp_base_form_normal>
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, multi_exp_base_form BaseForm = multi_exp_base_form_normal>
T	multi_exp_filter_one_zero (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)
	Compute window size for the given number of scalars. More...

template<typename T >
window_table< T >	get_window_table (const size_t scalar_size, const size_t window, const T &g)
	Compute table of window sizes. More...

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 (const size_t scalar_size, const size_t window, const window_table< T > &table, const std::vector< FieldT > &v, size_t num_entries)

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<form_t Form, compression_t Comp, typename GroupT , typename FieldT >
GroupT	multi_exp_stream (std::istream &base_elements_in, const std::vector< FieldT > &exponents)

template<form_t Form, compression_t Comp, typename GroupT , typename FieldT >
GroupT	multi_exp_stream_with_precompute (std::istream &precomputed_elements_in, const std::vector< FieldT > &exponents, const size_t precompute_c)

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

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

template<typename T >
size_t	wnaf_opt_window_size (const size_t scalar_bits)
	Compute optimal window size. More...

template<typename T >
T	fixed_window_wnaf_exp (const size_t window_size, const T &base, const std::vector< long > &naf)

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)

uint8_t	char_to_nibble (const char c)

void	hex_to_bytes_reversed (const std::string &hex, void *dest, size_t bytes)

std::string	bytes_to_hex_reversed (const void *bytes, size_t num_bytes, bool prefix=false)
	"prefix" here refers to "0x" More...

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)

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 &&...)
	A variadic template to suppress unused argument warnings. More...

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

const mp_size_t	alt_bn128_q_limbs

bigint< bls12_377_r_limbs >	bls12_377_modulus_r

bls12_377_Fq	bls12_377_coeff_b

bigint< bls12_377_r_limbs >	bls12_377_trace_of_frobenius

bls12_377_Fq2	bls12_377_twist

bls12_377_Fq2	bls12_377_twist_coeff_b

bls12_377_Fq	bls12_377_twist_mul_by_b_c0

bls12_377_Fq	bls12_377_twist_mul_by_b_c1

bls12_377_Fq2	bls12_377_twist_mul_by_q_X

bls12_377_Fq2	bls12_377_twist_mul_by_q_Y

bls12_377_Fq	bls12_377_g1_endomorphism_beta

bigint< bls12_377_r_limbs >	bls12_377_g1_safe_subgroup_check_c1

bigint< bls12_377_r_limbs >	bls12_377_g1_proof_of_safe_subgroup_w

bls12_377_Fq	bls12_377_g1_proof_of_safe_subgroup_non_member_x

bls12_377_Fq	bls12_377_g1_proof_of_safe_subgroup_non_member_y

bls12_377_Fq12	bls12_377_g2_untwist_frobenius_twist_w

bls12_377_Fq12	bls12_377_g2_untwist_frobenius_twist_v

bls12_377_Fq12	bls12_377_g2_untwist_frobenius_twist_w_3

bls12_377_Fq12	bls12_377_g2_untwist_frobenius_twist_v_inverse

bls12_377_Fq12	bls12_377_g2_untwist_frobenius_twist_w_3_inverse

bigint< bls12_377_r_limbs >	bls12_377_g2_mul_by_cofactor_h2_0

bigint< bls12_377_r_limbs >	bls12_377_g2_mul_by_cofactor_h2_1

bigint< bls12_377_q_limbs >	bls12_377_ate_loop_count

bool	bls12_377_ate_is_loop_count_neg

bigint< 12 *bls12_377_q_limbs >	bls12_377_final_exponent

bigint< bls12_377_q_limbs >	bls12_377_final_exponent_z

bool	bls12_377_final_exponent_is_z_neg

const mp_size_t	bls12_377_r_bitcount = 253

const mp_size_t	bls12_377_q_bitcount = 377

const mp_size_t	bls12_377_r_limbs

const mp_size_t	bls12_377_q_limbs

bigint< bls12_377_q_limbs >	bw6_761_modulus_r

bigint< bls12_381_r_limbs >	bls12_381_modulus_r

bigint< bls12_381_q_limbs >	bls12_381_modulus_q

bls12_381_Fq	bls12_381_coeff_b

bigint< bls12_381_r_limbs >	bls12_381_trace_of_frobenius

bls12_381_Fq2	bls12_381_twist

bls12_381_Fq2	bls12_381_twist_coeff_b

bls12_381_Fq	bls12_381_twist_mul_by_b_c0

bls12_381_Fq	bls12_381_twist_mul_by_b_c1

bls12_381_Fq2	bls12_381_twist_mul_by_q_X

bls12_381_Fq2	bls12_381_twist_mul_by_q_Y

bigint< bls12_381_q_limbs >	bls12_381_ate_loop_count

bool	bls12_381_ate_is_loop_count_neg

bigint< 12 *bls12_381_q_limbs >	bls12_381_final_exponent

bigint< bls12_381_q_limbs >	bls12_381_final_exponent_z

bool	bls12_381_final_exponent_is_z_neg

const mp_size_t	bls12_381_r_bitcount = 255

const mp_size_t	bls12_381_q_bitcount = 381

const mp_size_t	bls12_381_r_limbs

const mp_size_t	bls12_381_q_limbs

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

const mp_size_t	bn128_q_limbs

bigint< bw6_761_q_limbs >	bw6_761_modulus_q

bw6_761_Fq	bw6_761_coeff_b

bw6_761_Fq	bw6_761_twist

bw6_761_Fq	bw6_761_twist_coeff_b

bigint< bw6_761_q_limbs >	bw6_761_ate_loop_count1

bigint< bw6_761_q_limbs >	bw6_761_ate_loop_count2

bool	bw6_761_ate_is_loop_count_neg

bigint< bw6_761_q_limbs >	bw6_761_final_exponent_z

bool	bw6_761_final_exponent_is_z_neg

const mp_size_t	bw6_761_r_bitcount = 377

const mp_size_t	bw6_761_q_bitcount = 761

const mp_size_t	bw6_761_r_limbs

const mp_size_t	bw6_761_q_limbs

template<typename GroupT >
decltype(((GroupT *) nullptr) ->X)	curve_point_y_at_x (const decltype(((GroupT *) nullptr) ->X) &x)

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

const mp_size_t	edwards_q_limbs

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

const mp_size_t	mnt46_B_limbs

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

constexpr encoding_t	DEFAULT_ENCODING = encoding_json

constexpr form_t	DEFAULT_FORM = form_plain

constexpr compression_t	DEFAULT_COMPRESSION = compression_on

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 = typedef typename EC_ppT::affine_ate_G1_precomp_type

Definition at line 81 of file public_params.hpp.

◆ affine_ate_G2_precomp

template<typename EC_ppT >

using libff::affine_ate_G2_precomp = typedef typename EC_ppT::affine_ate_G2_precomp_type

Definition at line 83 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 31 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 35 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 32 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 33 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 30 of file alt_bn128_init.hpp.

◆ alt_bn128_G1_precomp

typedef alt_bn128_ate_G1_precomp libff::alt_bn128_G1_precomp

Definition at line 76 of file alt_bn128_pairing.hpp.

◆ alt_bn128_G2_precomp

typedef alt_bn128_ate_G2_precomp libff::alt_bn128_G2_precomp

Definition at line 77 of file alt_bn128_pairing.hpp.

◆ alt_bn128_GT

typedef alt_bn128_Fq12 libff::alt_bn128_GT

Definition at line 36 of file alt_bn128_init.hpp.

◆ bit_vector

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

Definition at line 22 of file utils.hpp.

◆ bls12_377_Fq

typedef Fp_model<bls12_377_q_limbs, bls12_377_modulus_q> libff::bls12_377_Fq

Definition at line 48 of file bls12_377_init.hpp.

◆ bls12_377_Fq12

typedef Fp12_2over3over2_model<bls12_377_q_limbs, bls12_377_modulus_q> libff::bls12_377_Fq12

Definition at line 52 of file bls12_377_init.hpp.

◆ bls12_377_Fq2

typedef Fp2_model<bls12_377_q_limbs, bls12_377_modulus_q> libff::bls12_377_Fq2

Definition at line 49 of file bls12_377_init.hpp.

◆ bls12_377_Fq6

typedef Fp6_3over2_model<bls12_377_q_limbs, bls12_377_modulus_q> libff::bls12_377_Fq6

Definition at line 50 of file bls12_377_init.hpp.

◆ bls12_377_Fr

typedef Fp_model<bls12_377_r_limbs, bls12_377_modulus_r> libff::bls12_377_Fr

Definition at line 47 of file bls12_377_init.hpp.

◆ bls12_377_G1_precomp

typedef bls12_377_ate_G1_precomp libff::bls12_377_G1_precomp

Definition at line 91 of file bls12_377_pairing.hpp.

◆ bls12_377_G2_precomp

typedef bls12_377_ate_G2_precomp libff::bls12_377_G2_precomp

Definition at line 92 of file bls12_377_pairing.hpp.

◆ bls12_377_GT

typedef bls12_377_Fq12 libff::bls12_377_GT

Definition at line 53 of file bls12_377_init.hpp.

◆ bls12_381_Fq

typedef Fp_model<bls12_381_q_limbs, bls12_381_modulus_q> libff::bls12_381_Fq

Definition at line 31 of file bls12_381_init.hpp.

◆ bls12_381_Fq12

typedef Fp12_2over3over2_model<bls12_381_q_limbs, bls12_381_modulus_q> libff::bls12_381_Fq12

Definition at line 35 of file bls12_381_init.hpp.

◆ bls12_381_Fq2

typedef Fp2_model<bls12_381_q_limbs, bls12_381_modulus_q> libff::bls12_381_Fq2

Definition at line 32 of file bls12_381_init.hpp.

◆ bls12_381_Fq6

typedef Fp6_3over2_model<bls12_381_q_limbs, bls12_381_modulus_q> libff::bls12_381_Fq6

Definition at line 33 of file bls12_381_init.hpp.

◆ bls12_381_Fr

typedef Fp_model<bls12_381_r_limbs, bls12_381_modulus_r> libff::bls12_381_Fr

Definition at line 30 of file bls12_381_init.hpp.

◆ bls12_381_G1_precomp

typedef bls12_381_ate_G1_precomp libff::bls12_381_G1_precomp

Definition at line 91 of file bls12_381_pairing.hpp.

◆ bls12_381_G2_precomp

typedef bls12_381_ate_G2_precomp libff::bls12_381_G2_precomp

Definition at line 92 of file bls12_381_pairing.hpp.

◆ bls12_381_GT

typedef bls12_381_Fq12 libff::bls12_381_GT

Definition at line 36 of file bls12_381_init.hpp.

◆ bn128_ate_ell_coeffs

typedef bn::Fp6 libff::bn128_ate_ell_coeffs

Definition at line 32 of file bn128_pairing.hpp.

◆ bn128_Fq

typedef Fp_model<bn128_q_limbs, bn128_modulus_q> libff::bn128_Fq

Definition at line 40 of file bn128_init.hpp.

◆ bn128_Fq12

typedef bn128_GT libff::bn128_Fq12

Definition at line 46 of file bn128_init.hpp.

◆ bn128_Fr

typedef Fp_model<bn128_r_limbs, bn128_modulus_r> libff::bn128_Fr

Definition at line 39 of file bn128_init.hpp.

◆ bw6_761_Fq

typedef Fp_model<bw6_761_q_limbs, bw6_761_modulus_q> libff::bw6_761_Fq

Definition at line 24 of file bw6_761_init.hpp.

◆ bw6_761_Fq3

typedef Fp3_model<bw6_761_q_limbs, bw6_761_modulus_q> libff::bw6_761_Fq3

Definition at line 25 of file bw6_761_init.hpp.

◆ bw6_761_Fq6

typedef Fp6_2over3_model<bw6_761_q_limbs, bw6_761_modulus_q> libff::bw6_761_Fq6

Definition at line 26 of file bw6_761_init.hpp.

◆ bw6_761_Fr

typedef Fp_model<bw6_761_r_limbs, bw6_761_modulus_r> libff::bw6_761_Fr

Definition at line 23 of file bw6_761_init.hpp.

◆ bw6_761_G1_precomp

typedef bw6_761_ate_G1_precomp libff::bw6_761_G1_precomp

Definition at line 80 of file bw6_761_pairing.hpp.

◆ bw6_761_G2_precomp

typedef bw6_761_ate_G2_precomp libff::bw6_761_G2_precomp

Definition at line 81 of file bw6_761_pairing.hpp.

◆ bw6_761_GT

typedef bw6_761_Fq6 libff::bw6_761_GT

Definition at line 27 of file bw6_761_init.hpp.

◆ edwards_ate_G2_precomp

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

Definition at line 77 of file edwards_pairing.hpp.

◆ edwards_Fq

typedef Fp_model<edwards_q_limbs, edwards_modulus_q> libff::edwards_Fq

Definition at line 30 of file edwards_init.hpp.

◆ edwards_Fq3

typedef Fp3_model<edwards_q_limbs, edwards_modulus_q> libff::edwards_Fq3

Definition at line 31 of file edwards_init.hpp.

◆ edwards_Fq6

typedef Fp6_2over3_model<edwards_q_limbs, edwards_modulus_q> libff::edwards_Fq6

Definition at line 32 of file edwards_init.hpp.

◆ edwards_Fr

typedef Fp_model<edwards_r_limbs, edwards_modulus_r> libff::edwards_Fr

Definition at line 29 of file edwards_init.hpp.

◆ edwards_G1_precomp

typedef edwards_ate_G1_precomp libff::edwards_G1_precomp

Definition at line 112 of file edwards_pairing.hpp.

◆ edwards_G2_precomp

typedef edwards_ate_G2_precomp libff::edwards_G2_precomp

Definition at line 113 of file edwards_pairing.hpp.

◆ edwards_GT

typedef edwards_Fq6 libff::edwards_GT

Definition at line 33 of file edwards_init.hpp.

◆ edwards_tate_G1_precomp

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

Definition at line 37 of file edwards_pairing.hpp.

◆ Fq

template<typename EC_ppT >

using libff::Fq = typedef typename EC_ppT::Fq_type

Definition at line 84 of file public_params.hpp.

◆ Fqe

template<typename EC_ppT >

using libff::Fqe = typedef typename EC_ppT::Fqe_type

Definition at line 85 of file public_params.hpp.

◆ Fqk

template<typename EC_ppT >

using libff::Fqk = typedef typename EC_ppT::Fqk_type

Definition at line 86 of file public_params.hpp.

◆ Fr

template<typename EC_ppT >

using libff::Fr = typedef typename EC_ppT::Fp_type

For every curve the user should define corresponding public_params with the following typedefs:

Fp_type G1_type G2_type G1_precomp_type G2_precomp_type affine_ate_G1_precomp_type affine_ate_G2_precomp_type Fq_type Fqe_type Fqk_type GT_type

one should also define the following static elements and methods:

const std::string name;

void init_public_params();

GT<EC_ppT> final_exponentiation(const Fqk<EC_ppT> &elt);

G1_precomp<EC_ppT> precompute_G1(const G1<EC_ppT> &P); G2_precomp<EC_ppT> precompute_G2(const G2<EC_ppT> &Q);

Fqk<EC_ppT> miller_loop( const G1_precomp<EC_ppT> &prec_P, const G2_precomp<EC_ppT> &prec_Q);

affine_ate_G1_precomp<EC_ppT> affine_ate_precompute_G1(const G1<EC_ppT> &P); affine_ate_G2_precomp<EC_ppT> affine_ate_precompute_G2(const G2<EC_ppT> &Q);

Fqk<EC_ppT> affine_ate_miller_loop( const affine_ate_G1_precomp<EC_ppT> &prec_P, const affine_ate_G2_precomp<EC_ppT> &prec_Q); Fqk<EC_ppT> affine_ate_e_over_e_miller_loop( const affine_ate_G1_precomp<EC_ppT> &prec_P1, const affine_ate_G2_precomp<EC_ppT> &prec_Q1, const affine_ate_G1_precomp<EC_ppT> &prec_P2, const affine_ate_G2_precomp<EC_ppT> &prec_Q2); Fqk<EC_ppT> affine_ate_e_times_e_over_e_miller_loop( const affine_ate_G1_precomp<EC_ppT> &prec_P1, const affine_ate_G2_precomp<EC_ppT> &prec_Q1, const affine_ate_G1_precomp<EC_ppT> &prec_P2, const affine_ate_G2_precomp<EC_ppT> &prec_Q2, const affine_ate_G1_precomp<EC_ppT> &prec_P3, const affine_ate_G2_precomp<EC_ppT> &prec_Q3); Fqk<EC_ppT> double_miller_loop( const G1_precomp<EC_ppT> &prec_P1, const G2_precomp<EC_ppT> &prec_Q1, const G1_precomp<EC_ppT> &prec_P2, const G2_precomp<EC_ppT> &prec_Q2);

Fqk<EC_ppT> pairing(const G1<EC_ppT> &P, const G2<EC_ppT> &Q); GT<EC_ppT> reduced_pairing(const G1<EC_ppT> &P, const G2<EC_ppT> &Q); GT<EC_ppT> affine_reduced_pairing(const G1<EC_ppT> &P, const G2<EC_ppT> &Q);

Definition at line 75 of file public_params.hpp.

◆ Fr_vector

template<typename EC_ppT >

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

Definition at line 89 of file public_params.hpp.

◆ G1

template<typename EC_ppT >

using libff::G1 = typedef typename EC_ppT::G1_type

Definition at line 76 of file public_params.hpp.

◆ G1_precomp

template<typename EC_ppT >

using libff::G1_precomp = typedef 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 = typedef std::vector<G1<EC_ppT> >

Definition at line 90 of file public_params.hpp.

◆ G2

template<typename EC_ppT >

using libff::G2 = typedef typename EC_ppT::G2_type

Definition at line 77 of file public_params.hpp.

◆ G2_precomp

template<typename EC_ppT >

using libff::G2_precomp = typedef typename EC_ppT::G2_precomp_type

Definition at line 79 of file public_params.hpp.

◆ G2_vector

template<typename EC_ppT >

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

Definition at line 91 of file public_params.hpp.

◆ GT

template<typename EC_ppT >

using libff::GT = typedef typename EC_ppT::GT_type

Definition at line 87 of file public_params.hpp.

◆ mnt4_Fq

typedef Fp_model<mnt4_q_limbs, mnt4_modulus_q> libff::mnt4_Fq

Definition at line 37 of file mnt4_init.hpp.

◆ mnt4_Fq2

typedef Fp2_model<mnt4_q_limbs, mnt4_modulus_q> libff::mnt4_Fq2

Definition at line 38 of file mnt4_init.hpp.

◆ mnt4_Fq4

typedef Fp4_model<mnt4_q_limbs, mnt4_modulus_q> libff::mnt4_Fq4

Definition at line 39 of file mnt4_init.hpp.

◆ mnt4_Fr

typedef Fp_model<mnt4_r_limbs, mnt4_modulus_r> libff::mnt4_Fr

Definition at line 36 of file mnt4_init.hpp.

◆ mnt4_G1_precomp

typedef mnt4_ate_G1_precomp libff::mnt4_G1_precomp

Definition at line 130 of file mnt4_pairing.hpp.

◆ mnt4_G2_precomp

typedef mnt4_ate_G2_precomp libff::mnt4_G2_precomp

Definition at line 131 of file mnt4_pairing.hpp.

◆ mnt4_GT

typedef mnt4_Fq4 libff::mnt4_GT

Definition at line 40 of file mnt4_init.hpp.

◆ mnt6_Fq

typedef Fp_model<mnt6_q_limbs, mnt6_modulus_q> libff::mnt6_Fq

Definition at line 37 of file mnt6_init.hpp.

◆ mnt6_Fq3

typedef Fp3_model<mnt6_q_limbs, mnt6_modulus_q> libff::mnt6_Fq3

Definition at line 38 of file mnt6_init.hpp.

◆ mnt6_Fq6

typedef Fp6_2over3_model<mnt6_q_limbs, mnt6_modulus_q> libff::mnt6_Fq6

Definition at line 39 of file mnt6_init.hpp.

◆ mnt6_Fr

typedef Fp_model<mnt6_r_limbs, mnt6_modulus_r> libff::mnt6_Fr

Definition at line 36 of file mnt6_init.hpp.

◆ mnt6_G1_precomp

typedef mnt6_ate_G1_precomp libff::mnt6_G1_precomp

Definition at line 130 of file mnt6_pairing.hpp.

◆ mnt6_G2_precomp

typedef mnt6_ate_G2_precomp libff::mnt6_G2_precomp

Definition at line 131 of file mnt6_pairing.hpp.

◆ mnt6_GT

typedef mnt6_Fq6 libff::mnt6_GT

Definition at line 40 of file mnt6_init.hpp.

◆ window_table

template<typename T >

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

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

Definition at line 101 of file multiexp.hpp.

Enumeration Type Documentation

◆ compression_t

enum libff::compression_t : uint8_t

Enable / disable compression in (de)serialization.

Enumerator
compression_off
compression_on

Definition at line 31 of file serialization.hpp.

                    : uint8_t {
     compression_off = 0,
     compression_on = 1,
 };

◆ encoding_t

enum libff::encoding_t : uint8_t

Encodings for (de)serialization.

Enumerator
encoding_binary
encoding_json

Definition at line 19 of file serialization.hpp.

                 : uint8_t {
     encoding_binary = 0, // big endian
     encoding_json = 1,
 };

◆ form_t

enum libff::form_t : uint8_t

Encodings for (de)serialization.

Enumerator
form_plain
form_montgomery

Definition at line 25 of file serialization.hpp.

             : uint8_t {
     form_plain = 0,
     form_montgomery = 1,
 };

◆ multi_exp_base_form

enum libff::multi_exp_base_form

Form of base elements passed to multi_exp routines.

Enumerator
multi_exp_base_form_normal	Incoming base elements are not in special form.
multi_exp_base_form_special	Incoming base elements are in special form (so that implementations can use mixed_add, where appropriate.

Definition at line 45 of file multiexp.hpp.

                          {
     multi_exp_base_form_normal,
     multi_exp_base_form_special,
 };

◆ 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.
multi_exp_method_naive_plain	As multi_exp_method_naive, but uses operator * rather than opt_window_wnaf_exp.
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) Requires that T implements .dbl()
multi_exp_method_BDLO12_signed	Similar to multi_exp_method_BDLO12, but using signed digits.

Definition at line 21 of file multiexp.hpp.

                       {
     multi_exp_method_naive,
     multi_exp_method_naive_plain,
     multi_exp_method_bos_coster,
     multi_exp_method_BDLO12,
     multi_exp_method_BDLO12_signed,
 };

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 453 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 401 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 524 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 325 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 340 of file alt_bn128_pairing.cpp.

 {
     enter_block("Call to alt_bn128_ate_precompute_G2");
  
     alt_bn128_G2 Qcopy(Q);
     Qcopy.to_affine_coordinates();
  
     // could add to global params if needed
     alt_bn128_Fq two_inv = (alt_bn128_Fq("2").inverse());
  
     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 535 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 563 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 141 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 231 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 113 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.coeffs[0], -elt.coeffs[1]);
     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 155 of file alt_bn128_pairing.cpp.

 {
     enter_block("Call to alt_bn128_final_exponentiation_last_chunk");
  
     // clang-format off
     /*
       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
     */
     // clang-format on
  
     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 557 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 572 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 547 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 552 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 577 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() [1/2]

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() [2/2]

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,
		size_t	num_entries
	)

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

◆ batch_to_special()

template<typename T >

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

◆ bigint_from_hex()

template<typename BigIntT >

void libff::bigint_from_hex	(	BigIntT &	v,
		const std::string &	hex
	)

◆ bigint_to_hex()

template<typename BigIntT >

std::string libff::bigint_to_hex	(	const BigIntT &	v,
		bool	prefix = `false`
	)

◆ bitreverse()

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

Definition at line 59 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;
 }

◆ bls12_377_affine_reduced_pairing()

bls12_377_GT libff::bls12_377_affine_reduced_pairing	(	const bls12_377_G1 &	P,
		const bls12_377_G2 &	Q
	)

◆ bls12_377_ate_double_miller_loop()

bls12_377_Fq12 libff::bls12_377_ate_double_miller_loop	(	const bls12_377_ate_G1_precomp &	prec_P1,
		const bls12_377_ate_G2_precomp &	prec_Q1,
		const bls12_377_ate_G1_precomp &	prec_P2,
		const bls12_377_ate_G2_precomp &	prec_Q2
	)

Definition at line 465 of file bls12_377_pairing.cpp.

 {
     enter_block("Call to bls12_377_ate_double_miller_loop");
  
     bls12_377_Fq12 f = bls12_377_Fq12::one();
  
     bool found_one = false;
     size_t idx = 0;
  
     const bigint<bls12_377_Fq::num_limbs> &loop_count =
         bls12_377_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;
         }
  
         // The code below gets executed for all bits (EXCEPT the MSB itself)
         // of the binary representation of bls12_377_ate_loop_count
         // (skipping leading zeros) in MSB to LSB order
         bls12_377_ate_ell_coeffs c1 = prec_Q1.coeffs[idx];
         bls12_377_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) {
             bls12_377_ate_ell_coeffs c1 = prec_Q1.coeffs[idx];
             bls12_377_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);
         }
     }
  
     leave_block("Call to bls12_377_ate_double_miller_loop");
  
     return f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_ate_miller_loop()

bls12_377_Fq12 libff::bls12_377_ate_miller_loop	(	const bls12_377_ate_G1_precomp &	prec_P,
		const bls12_377_ate_G2_precomp &	prec_Q
	)

Definition at line 408 of file bls12_377_pairing.cpp.

 {
     enter_block("Call to bls12_377_ate_miller_loop");
  
     bls12_377_Fq12 f = bls12_377_Fq12::one();
  
     bool found_one = false;
     size_t idx = 0;
  
     const bigint<bls12_377_Fq::num_limbs> &loop_count =
         bls12_377_ate_loop_count;
     bls12_377_ate_ell_coeffs c;
  
     // Added for DEBUG purpose
     // TODO: Remove the 2 variables below
     int nb_double = 0;
     int nb_add = 0;
  
     // The loop length of the Miller algorithm is floor(log_2(u)), where
     // u is the "curve parameter" used to sample the curve from the
     // BLS12 family
     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;
         }
  
         // The code below gets executed for all bits (EXCEPT the MSB itself)
         // of the binary representation of bls12_377_ate_loop_count
         // (skipping leading zeros) in MSB to LSB order
         c = prec_Q.coeffs[idx++];
         f = f.squared();
         // Sparse multiplication in Fq12
         f = f.mul_by_024(c.ell_0, prec_P.PY * c.ell_VW, prec_P.PX * c.ell_VV);
         nb_double++;
  
         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);
             nb_add++;
         }
     }
  
     // Note: bls12_377_ate_is_loop_count_neg = false BUT this is not the case
     // for BLS12-381!
  
     std::cout << "[DEBUG] NB_DOUBLE (Should be 63): " << nb_double
               << " NB_ADD (Should be 7): " << nb_add << std::endl;
     leave_block("Call to bls12_377_ate_miller_loop");
     return f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_ate_pairing()

bls12_377_Fq12 libff::bls12_377_ate_pairing	(	const bls12_377_G1 &	P,
		const bls12_377_G2 &	Q
	)

Definition at line 519 of file bls12_377_pairing.cpp.

 {
     enter_block("Call to bls12_377_ate_pairing");
     bls12_377_ate_G1_precomp prec_P = bls12_377_ate_precompute_G1(P);
     bls12_377_ate_G2_precomp prec_Q = bls12_377_ate_precompute_G2(Q);
     bls12_377_Fq12 result = bls12_377_ate_miller_loop(prec_P, prec_Q);
     leave_block("Call to bls12_377_ate_pairing");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_ate_precompute_G1()

bls12_377_ate_G1_precomp libff::bls12_377_ate_precompute_G1 ( const bls12_377_G1 & P )

Definition at line 333 of file bls12_377_pairing.cpp.

 {
     enter_block("Call to bls12_377_ate_precompute_G1");
  
     bls12_377_G1 Pcopy = P;
     Pcopy.to_affine_coordinates();
  
     bls12_377_ate_G1_precomp result;
     result.PX = Pcopy.X;
     result.PY = Pcopy.Y;
  
     leave_block("Call to bls12_377_ate_precompute_G1");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_ate_precompute_G2()

bls12_377_ate_G2_precomp libff::bls12_377_ate_precompute_G2 ( const bls12_377_G2 & Q )

Definition at line 363 of file bls12_377_pairing.cpp.

 {
     enter_block("Call to bls12_377_ate_precompute_G2");
  
     bls12_377_G2 Qcopy(Q);
     Qcopy.to_affine_coordinates();
  
     // could add to global params if needed
     bls12_377_Fq two_inv = (bls12_377_Fq("2").inverse());
  
     bls12_377_ate_G2_precomp result;
     result.QX = Qcopy.X;
     result.QY = Qcopy.Y;
  
     bls12_377_G2 R;
     R.X = Qcopy.X;
     R.Y = Qcopy.Y;
     R.Z = bls12_377_Fq2::one();
  
     const bigint<bls12_377_Fq::num_limbs> &loop_count =
         bls12_377_ate_loop_count;
     bool found_one = false;
     bls12_377_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;
         }
  
         bls12_377_doubling_step_for_miller_loop(two_inv, R, c);
         result.coeffs.push_back(c);
  
         if (bit) {
             bls12_377_mixed_addition_step_for_miller_loop(Qcopy, R, c);
             result.coeffs.push_back(c);
         }
     }
  
     leave_block("Call to bls12_377_ate_precompute_G2");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_ate_reduced_pairing()

bls12_377_GT libff::bls12_377_ate_reduced_pairing	(	const bls12_377_G1 &	P,
		const bls12_377_G2 &	Q
	)

Definition at line 530 of file bls12_377_pairing.cpp.

 {
     enter_block("Call to bls12_377_ate_reduced_pairing");
     const bls12_377_Fq12 f = bls12_377_ate_pairing(P, Q);
     const bls12_377_GT result = bls12_377_final_exponentiation(f);
     leave_block("Call to bls12_377_ate_reduced_pairing");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_double_miller_loop()

bls12_377_Fq12 libff::bls12_377_double_miller_loop	(	const bls12_377_G1_precomp &	prec_P1,
		const bls12_377_G2_precomp &	prec_Q1,
		const bls12_377_G1_precomp &	prec_P2,
		const bls12_377_G2_precomp &	prec_Q2
	)

Definition at line 558 of file bls12_377_pairing.cpp.

 {
     return bls12_377_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:

◆ bls12_377_doubling_step_for_miller_loop()

void libff::bls12_377_doubling_step_for_miller_loop	(	const bls12_377_Fq	two_inv,
		bls12_377_G2 &	current,
		bls12_377_ate_ell_coeffs &	c
	)

Definition at line 239 of file bls12_377_pairing.cpp.

 {
     // Below we assume that `current` = (X, Y, Z) \in E'(Fp2) is a point
     // in homogeneous projective coordinates.
     const bls12_377_Fq2 X = current.X, Y = current.Y, Z = current.Z;
  
     // Compute the line function
  
     // A = (X * Y)/ 2
     const bls12_377_Fq2 A = two_inv * (X * Y);
     // B = Y^2
     const bls12_377_Fq2 B = Y.squared();
     // C = Z^2
     const bls12_377_Fq2 C = Z.squared();
     // D = 3 * C
     const bls12_377_Fq2 D = C + C + C;
     // E = bls12_377_twist_coeff_b * D
     const bls12_377_Fq2 E = bls12_377_twist_coeff_b * D;
     // F = 3 * E
     const bls12_377_Fq2 F = E + E + E;
     // G = (B + F)/2
     const bls12_377_Fq2 G = two_inv * (B + F);
     // H = (Y + Z)^2 - (B + C) = 2YZ
     const bls12_377_Fq2 H = (Y + Z).squared() - (B + C);
     // I = E - B
     const bls12_377_Fq2 I = E - B;
     // J = X^2
     const bls12_377_Fq2 J = X.squared();
     // E_squared = E^2
     const bls12_377_Fq2 E_squared = E.squared();
  
     // X = A * (B-F)
     //   = ((X * Y)/ 2) * (Y^2 - 3 * (bls12_377_twist_coeff_b * 3 * Z^2)
     //   = ((X * Y)/ 2) * (Y^2 - 9 * (bls12_377_twist_coeff_b * Z^2)
     current.X = A * (B - F);
     // Y = G^2 - 3*E^2
     //   = (Y^2 + 9 * bls12_377_twist_coeff_b * Z^2)/2 -
     //   27*(bls12_377_twist_coeff_b^2 * Z^4)
     current.Y = G.squared() - (E_squared + E_squared + E_squared);
     // Z = B * H
     //   = Y^2 * 2YZ
     //   = 2Y^3 * Z
     current.Z = B * H;
  
     // Note: We use a D-type twist
     //
     // See: Equation (2) https://eprint.iacr.org/2010/526.pdf
     //
     // The tangent line evaluated at the twisting point P = (x_p, y_p) is
     // computed as:
     //   (-2YZ*y_p)vw +                            <-- -H
     //   (3*X^2 * x_p) * v^2 +                     <-- 3*J
     //   bls12_377_twist * bls12_377_twist *       <-- bls12_377_twist * I
     //     (3*bls12_377_twist_coeff_b*Z^2 - Y^2)
     c.ell_VW = -H;
     c.ell_VV = J + J + J;
     c.ell_0 = bls12_377_twist * I;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_exp_by_z()

bls12_377_Fq12 libff::bls12_377_exp_by_z ( const bls12_377_Fq12 & elt )

Definition at line 137 of file bls12_377_pairing.cpp.

 {
     enter_block("Call to bls12_377_exp_by_z");
  
     bls12_377_Fq12 result = elt.cyclotomic_exp(bls12_377_final_exponent_z);
     if (bls12_377_final_exponent_is_z_neg) {
         result = result.unitary_inverse();
     }
  
     leave_block("Call to bls12_377_exp_by_z");
  
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_final_exponentiation()

bls12_377_GT libff::bls12_377_final_exponentiation ( const bls12_377_Fq12 & elt )

Definition at line 217 of file bls12_377_pairing.cpp.

 {
     // We know that:
     // (p^12 - 1) / r = (p^6 - 1) (p^2 + 1) ((p^4 - p^2 + 1) / r)
     //                  |_________________|  |__________________|
     //                       easy part            hard part
     // where:
     // sage: cyclotomic_polynomial(12) # = x^4 - x^2 + 1
     enter_block("Call to bls12_377_final_exponentiation");
  
     // Compute the easy part
     bls12_377_Fq12 first = bls12_377_final_exponentiation_first_chunk(elt);
     // Finish the final exponentiation by computing the hard part
     bls12_377_GT result = bls12_377_final_exponentiation_last_chunk(first);
  
     leave_block("Call to bls12_377_final_exponentiation");
  
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_final_exponentiation_first_chunk()

bls12_377_Fq12 libff::bls12_377_final_exponentiation_first_chunk ( const bls12_377_Fq12 & elt )

Definition at line 109 of file bls12_377_pairing.cpp.

 {
     // The content of this file follows: https://eprint.iacr.org/2016/130.pdf
     //
     // Note: in the alt_bn_128 implementation the libff authors used a trick by
     // Beuchat et al. to compute the first chunk of the exponentiation which
     // seems faster. Look into that and use it if it applies here too.
     //
     // TODO: Look into this.
     enter_block("Call to bls12_377_final_exponentiation_first_chunk");
  
     // elt^(q^6)
     const bls12_377_Fq12 A = elt.Frobenius_map(6);
     // elt^(-1)
     const bls12_377_Fq12 B = elt.inverse();
     // elt^(q^6 - 1)
     const bls12_377_Fq12 C = A * B;
     // (elt^(q^6 - 1))^(q^2) = elt^((q^6 - 1) * (q^2))
     const bls12_377_Fq12 D = C.Frobenius_map(2);
     // elt^((q^6 - 1) * (q^2) + (q^6 - 1)) = elt^((q^6 - 1) * (q^2 + 1))
     const bls12_377_Fq12 result = D * C;
  
     leave_block("Call to bls12_377_final_exponentiation_first_chunk");
  
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_final_exponentiation_last_chunk()

bls12_377_Fq12 libff::bls12_377_final_exponentiation_last_chunk ( const bls12_377_Fq12 & elt )

Definition at line 151 of file bls12_377_pairing.cpp.

 {
     enter_block("Call to bls12_377_final_exponentiation_last_chunk");
  
     // In the following, we follow the Algorithm 1 described in Table 1 of:
     // https://eprint.iacr.org/2016/130.pdf in order to compute the
     // hard part of the final exponentiation
     //
     // Note: As shown Table 3: https://eprint.iacr.org/2016/130.pdf this
     // algorithm isn't optimal since Algorithm 2 allows to have less temp.
     // variables and has a better complexity.
     //
     // In the following we denote by [x] = elt^(x):
     // A = [-2]
     const bls12_377_Fq12 A = elt.cyclotomic_squared().unitary_inverse();
     // B = [z]
     const bls12_377_Fq12 B = bls12_377_exp_by_z(elt);
     // C = [2z]
     const bls12_377_Fq12 C = B.cyclotomic_squared();
     // D = [z-2]
     const bls12_377_Fq12 D = A * B;
     // E = [z^2-2z]
     const bls12_377_Fq12 E = bls12_377_exp_by_z(D);
     // F = [z^3-2z^2]
     const bls12_377_Fq12 F = bls12_377_exp_by_z(E);
     // G = [z^4-2z^3]
     const bls12_377_Fq12 G = bls12_377_exp_by_z(F);
     // H = [z^4-2z^3+2z]
     const bls12_377_Fq12 H = G * C;
     // I = [z^5-2z^4+2z^2]
     const bls12_377_Fq12 I = bls12_377_exp_by_z(H);
     // J = [-z+2]
     const bls12_377_Fq12 J = D.unitary_inverse();
     // K = [z^5-2z^4+2z^2-z+2]
     const bls12_377_Fq12 K = I * J;
     // L = [z^5-2z^4+2z^2-z+3] = [\lambda_0]
     const bls12_377_Fq12 L = K * elt;
     // M = [-1]
     const bls12_377_Fq12 M = elt.unitary_inverse();
     // N = [z^2-2z+1] = [\lambda_3]
     const bls12_377_Fq12 N = E * elt;
     // O = [(z^2-2z+1) * (q^3)]
     const bls12_377_Fq12 O = N.Frobenius_map(3);
     // P = [z^4-2z^3+2z-1] = [\lambda_1]
     const bls12_377_Fq12 P = H * M;
     // Q = [(z^4-2z^3+2z-1) * q]
     const bls12_377_Fq12 Q = P.Frobenius_map(1);
     // R = [z^3-2z^2+z] = [\lambda_2]
     const bls12_377_Fq12 R = F * B;
     // S = [(z^3-2z^2+z) * (q^2)]
     const bls12_377_Fq12 S = R.Frobenius_map(2);
     // T = [(z^2-2z+1) * (q^3) + (z^3-2z^2+z) * (q^2)]
     const bls12_377_Fq12 T = O * S;
     // U = [(z^2-2z+1) * (q^3) + (z^3-2z^2+z) * (q^2) + (z^4-2z^3+2z-1) * q]
     const bls12_377_Fq12 U = T * Q;
     // result = [(z^2-2z+1) * (q^3) + (z^3-2z^2+z) * (q^2) + (z^4-2z^3+2z-1) * q
     // + z^5-2z^4+2z^2-z+3]
     //        = [(p^4 - p^2 + 1)/r].
     const bls12_377_Fq12 result = U * L;
  
     leave_block("Call to bls12_377_final_exponentiation_last_chunk");
  
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_miller_loop()

bls12_377_Fq12 libff::bls12_377_miller_loop	(	const bls12_377_G1_precomp &	prec_P,
		const bls12_377_G2_precomp &	prec_Q
	)

Definition at line 552 of file bls12_377_pairing.cpp.

 {
     return bls12_377_ate_miller_loop(prec_P, prec_Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_mixed_addition_step_for_miller_loop()

void libff::bls12_377_mixed_addition_step_for_miller_loop	(	const bls12_377_G2 &	base,
		bls12_377_G2 &	current,
		bls12_377_ate_ell_coeffs &	c
	)

Definition at line 301 of file bls12_377_pairing.cpp.

 {
     const bls12_377_Fq2 &X1 = current.X, &Y1 = current.Y, &Z1 = current.Z;
     const bls12_377_Fq2 &X2 = base.X, &Y2 = base.Y;
  
     const bls12_377_Fq2 A = Y2 * Z1;
     const bls12_377_Fq2 B = X2 * Z1;
     const bls12_377_Fq2 theta = Y1 - A;
     const bls12_377_Fq2 lambda = X1 - B;
     const bls12_377_Fq2 C = theta.squared();
     const bls12_377_Fq2 D = lambda.squared();
     const bls12_377_Fq2 E = lambda * D;
     const bls12_377_Fq2 F = Z1 * C;
     const bls12_377_Fq2 G = X1 * D;
     const bls12_377_Fq2 H = E + F - (G + G);
     const bls12_377_Fq2 I = Y1 * E;
     const bls12_377_Fq2 J = theta * X2 - lambda * Y2;
  
     current.X = lambda * H;
     current.Y = theta * (G - H) - I;
     current.Z = Z1 * E;
  
     c.ell_0 = bls12_377_twist * J;
     // VV gets multiplied to xP during line evaluation at P
     c.ell_VV = -theta;
     // VW gets multiplied to yP during line evaluation at P
     c.ell_VW = lambda;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_pairing()

bls12_377_Fq12 libff::bls12_377_pairing	(	const bls12_377_G1 &	P,
		const bls12_377_G2 &	Q
	)

Definition at line 567 of file bls12_377_pairing.cpp.

 {
     return bls12_377_ate_pairing(P, Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_precompute_G1()

bls12_377_G1_precomp libff::bls12_377_precompute_G1 ( const bls12_377_G1 & P )

Definition at line 542 of file bls12_377_pairing.cpp.

 {
     return bls12_377_ate_precompute_G1(P);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_precompute_G2()

bls12_377_G2_precomp libff::bls12_377_precompute_G2 ( const bls12_377_G2 & Q )

Definition at line 547 of file bls12_377_pairing.cpp.

 {
     return bls12_377_ate_precompute_G2(Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_377_reduced_pairing()

bls12_377_GT libff::bls12_377_reduced_pairing	(	const bls12_377_G1 &	P,
		const bls12_377_G2 &	Q
	)

Definition at line 572 of file bls12_377_pairing.cpp.

 {
     return bls12_377_ate_reduced_pairing(P, Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_affine_reduced_pairing()

bls12_381_GT libff::bls12_381_affine_reduced_pairing	(	const bls12_381_G1 &	P,
		const bls12_381_G2 &	Q
	)

◆ bls12_381_ate_double_miller_loop()

bls12_381_Fq12 libff::bls12_381_ate_double_miller_loop	(	const bls12_381_ate_G1_precomp &	prec_P1,
		const bls12_381_ate_G2_precomp &	prec_Q1,
		const bls12_381_ate_G1_precomp &	prec_P2,
		const bls12_381_ate_G2_precomp &	prec_Q2
	)

Definition at line 415 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_ate_double_miller_loop");
  
     bls12_381_Fq12 f = bls12_381_Fq12::one();
  
     bool found_one = false;
     size_t idx = 0;
  
     const bigint<bls12_381_Fq::num_limbs> &loop_count =
         bls12_381_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
            bls12_381_param_p (skipping leading zeros) in MSB to LSB
            order */
  
         bls12_381_ate_ell_coeffs c1 = prec_Q1.coeffs[idx];
         bls12_381_ate_ell_coeffs c2 = prec_Q2.coeffs[idx];
         ++idx;
  
         f = f.squared();
  
         f = f.mul_by_045(
             c1.ell_0, prec_P1.PY * c1.ell_VW, prec_P1.PX * c1.ell_VV);
         f = f.mul_by_045(
             c2.ell_0, prec_P2.PY * c2.ell_VW, prec_P2.PX * c2.ell_VV);
  
         if (bit) {
             bls12_381_ate_ell_coeffs c1 = prec_Q1.coeffs[idx];
             bls12_381_ate_ell_coeffs c2 = prec_Q2.coeffs[idx];
             ++idx;
  
             f = f.mul_by_045(
                 c1.ell_0, prec_P1.PY * c1.ell_VW, prec_P1.PX * c1.ell_VV);
             f = f.mul_by_045(
                 c2.ell_0, prec_P2.PY * c2.ell_VW, prec_P2.PX * c2.ell_VV);
         }
     }
  
     if (bls12_381_ate_is_loop_count_neg) {
         f = f.inverse();
     }
  
     leave_block("Call to bls12_381_ate_double_miller_loop");
  
     return f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_ate_miller_loop()

bls12_381_Fq12 libff::bls12_381_ate_miller_loop	(	const bls12_381_ate_G1_precomp &	prec_P,
		const bls12_381_ate_G2_precomp &	prec_Q
	)

Definition at line 369 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_ate_miller_loop");
  
     bls12_381_Fq12 f = bls12_381_Fq12::one();
  
     bool found_one = false;
     size_t idx = 0;
  
     const bigint<bls12_381_Fq::num_limbs> &loop_count =
         bls12_381_ate_loop_count;
     bls12_381_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
            bls12_381_param_p (skipping leading zeros) in MSB to LSB
            order */
  
         c = prec_Q.coeffs[idx++];
         f = f.squared();
         f = f.mul_by_045(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_045(
                 c.ell_0, prec_P.PY * c.ell_VW, prec_P.PX * c.ell_VV);
         }
     }
  
     if (bls12_381_ate_is_loop_count_neg) {
         f = f.inverse();
     }
  
     leave_block("Call to bls12_381_ate_miller_loop");
     return f;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_ate_pairing()

bls12_381_Fq12 libff::bls12_381_ate_pairing	(	const bls12_381_G1 &	P,
		const bls12_381_G2 &	Q
	)

Definition at line 474 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_ate_pairing");
     bls12_381_ate_G1_precomp prec_P = bls12_381_ate_precompute_G1(P);
     bls12_381_ate_G2_precomp prec_Q = bls12_381_ate_precompute_G2(Q);
     bls12_381_Fq12 result = bls12_381_ate_miller_loop(prec_P, prec_Q);
     leave_block("Call to bls12_381_ate_pairing");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_ate_precompute_G1()

bls12_381_ate_G1_precomp libff::bls12_381_ate_precompute_G1 ( const bls12_381_G1 & P )

Definition at line 309 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_ate_precompute_G1");
  
     bls12_381_G1 Pcopy = P;
     Pcopy.to_affine_coordinates();
  
     bls12_381_ate_G1_precomp result;
     result.PX = Pcopy.X;
     result.PY = Pcopy.Y;
  
     leave_block("Call to bls12_381_ate_precompute_G1");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_ate_precompute_G2()

bls12_381_ate_G2_precomp libff::bls12_381_ate_precompute_G2 ( const bls12_381_G2 & Q )

Definition at line 324 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_ate_precompute_G2");
  
     bls12_381_G2 Qcopy(Q);
     Qcopy.to_affine_coordinates();
  
     // could add to global params if needed
     bls12_381_Fq two_inv = (bls12_381_Fq("2").inverse());
  
     bls12_381_ate_G2_precomp result;
     result.QX = Qcopy.X;
     result.QY = Qcopy.Y;
  
     bls12_381_G2 R;
     R.X = Qcopy.X;
     R.Y = Qcopy.Y;
     R.Z = bls12_381_Fq2::one();
  
     const bigint<bls12_381_Fq::num_limbs> &loop_count =
         bls12_381_ate_loop_count;
     bool found_one = false;
     bls12_381_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;
         }
  
         bls12_381_doubling_step_for_miller_loop(two_inv, R, c);
         result.coeffs.push_back(c);
  
         if (bit) {
             bls12_381_mixed_addition_step_for_miller_loop(Qcopy, R, c);
             result.coeffs.push_back(c);
         }
     }
  
     leave_block("Call to bls12_381_ate_precompute_G2");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_ate_reduced_pairing()

bls12_381_GT libff::bls12_381_ate_reduced_pairing	(	const bls12_381_G1 &	P,
		const bls12_381_G2 &	Q
	)

Definition at line 485 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_ate_reduced_pairing");
     const bls12_381_Fq12 f = bls12_381_ate_pairing(P, Q);
     const bls12_381_GT result = bls12_381_final_exponentiation(f);
     leave_block("Call to bls12_381_ate_reduced_pairing");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_double_miller_loop()

bls12_381_Fq12 libff::bls12_381_double_miller_loop	(	const bls12_381_G1_precomp &	prec_P1,
		const bls12_381_G2_precomp &	prec_Q1,
		const bls12_381_G1_precomp &	prec_P2,
		const bls12_381_G2_precomp &	prec_Q2
	)

Definition at line 513 of file bls12_381_pairing.cpp.

 {
     return bls12_381_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:

◆ bls12_381_doubling_step_for_miller_loop()

void libff::bls12_381_doubling_step_for_miller_loop	(	const bls12_381_Fq	two_inv,
		bls12_381_G2 &	current,
		bls12_381_ate_ell_coeffs &	c
	)

Definition at line 230 of file bls12_381_pairing.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_exp_by_z()

bls12_381_Fq12 libff::bls12_381_exp_by_z ( const bls12_381_Fq12 & elt )

Definition at line 142 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_exp_by_z");
  
     bls12_381_Fq12 result = elt.cyclotomic_exp(bls12_381_final_exponent_z);
     if (bls12_381_final_exponent_is_z_neg) {
         result = result.unitary_inverse();
     }
  
     leave_block("Call to bls12_381_exp_by_z");
  
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_final_exponentiation()

bls12_381_GT libff::bls12_381_final_exponentiation ( const bls12_381_Fq12 & elt )

Definition at line 215 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_final_exponentiation");
     /* OLD naive version:
         bls12_381_GT result = elt^bls12_381_final_exponent;
     */
     bls12_381_Fq12 first = bls12_381_final_exponentiation_first_chunk(elt);
     bls12_381_GT result = bls12_381_final_exponentiation_last_chunk(first);
  
     leave_block("Call to bls12_381_final_exponentiation");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_final_exponentiation_first_chunk()

bls12_381_Fq12 libff::bls12_381_final_exponentiation_first_chunk ( const bls12_381_Fq12 & elt )

Definition at line 114 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_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 bls12_381_Fq12 A = bls12_381_Fq12(elt.coeffs[0], -elt.coeffs[1]);
     const bls12_381_Fq12 B = elt.inverse();
     const bls12_381_Fq12 C = A * B;
     const bls12_381_Fq12 D = C.Frobenius_map(2);
     const bls12_381_Fq12 result = D * C;
  
     leave_block("Call to bls12_381_final_exponentiation_first_chunk");
  
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_final_exponentiation_last_chunk()

bls12_381_Fq12 libff::bls12_381_final_exponentiation_last_chunk ( const bls12_381_Fq12 & elt )

Definition at line 156 of file bls12_381_pairing.cpp.

 {
     enter_block("Call to bls12_381_final_exponentiation_last_chunk");
  
     //  https://eprint.iacr.org/2016/130.pdf (Algorithm 1 described in Table 1)
     // elt^(-2)
     const bls12_381_Fq12 A = elt.cyclotomic_squared().unitary_inverse();
     // elt^z
     const bls12_381_Fq12 B = bls12_381_exp_by_z(elt);
     // elt^(2z)
     const bls12_381_Fq12 C = B.cyclotomic_squared();
     // elt^(z-2)
     const bls12_381_Fq12 D = A * B;
     // elt^(z^2-2z)
     const bls12_381_Fq12 E = bls12_381_exp_by_z(D);
     // elt^(z^3-2z^2)
     const bls12_381_Fq12 F = bls12_381_exp_by_z(E);
     // elt^(z^4-2z^3)
     const bls12_381_Fq12 G = bls12_381_exp_by_z(F);
     // elt^(z^4-2z^3+2z)
     const bls12_381_Fq12 H = G * C;
     // elt^(z^5-2z^4+2z^2)
     const bls12_381_Fq12 I = bls12_381_exp_by_z(H);
     // elt^(-z+2)
     const bls12_381_Fq12 J = D.unitary_inverse();
     // elt^(z^5-2z^4+2z^2) * elt^(-z+2)
     const bls12_381_Fq12 K = J * I;
     // elt^(z^5-2z^4+2z^2) * elt^(-z+2) * elt
     const bls12_381_Fq12 L = elt * K;
     // elt^(-1)
     const bls12_381_Fq12 M = elt.unitary_inverse();
     // elt^(z^2-2z) * elt
     const bls12_381_Fq12 N = E * elt;
     // (elt^(z^2-2z) * elt)^(q^3)
     const bls12_381_Fq12 O = N.Frobenius_map(3);
     // elt^(z^4-2z^3+2z) * elt^(-1)
     const bls12_381_Fq12 P = H * M;
     // (elt^(z^4-2z^3+2z) * elt^(-1))^q
     const bls12_381_Fq12 Q = P.Frobenius_map(1);
     // elt^(z^3-2z^2) * elt^z
     const bls12_381_Fq12 R = B * F;
     // (elt^(z^3-2z^2) * elt^z)^(q^2)
     const bls12_381_Fq12 S = R.Frobenius_map(2);
     // (elt^(z^2-2z) * elt)^(q^3) * (elt^(z^3-2z^2) * elt^z)^(q^2)
     const bls12_381_Fq12 T = S * O;
     // (elt^(z^2-2z) * elt)^(q^3) * (elt^(z^3-2z^2) * elt^z)^(q^2) *
     // (elt^(z^4-2z^3+2z) * elt^(-1))^q
     const bls12_381_Fq12 U = T * Q;
     // (elt^(z^2-2z) * elt)^(q^3) * (elt^(z^3-2z^2) * elt^z)^(q^2) *
     // (elt^(z^4-2z^3+2z) * elt^(-1))^q * elt^(z^5-2z^4+2z^2) *
     // elt^(-z+2) * elt
     const bls12_381_Fq12 result = U * L;
  
     leave_block("Call to bls12_381_final_exponentiation_last_chunk");
  
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_miller_loop()

bls12_381_Fq12 libff::bls12_381_miller_loop	(	const bls12_381_G1_precomp &	prec_P,
		const bls12_381_G2_precomp &	prec_Q
	)

Definition at line 507 of file bls12_381_pairing.cpp.

 {
     return bls12_381_ate_miller_loop(prec_P, prec_Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_mixed_addition_step_for_miller_loop()

void libff::bls12_381_mixed_addition_step_for_miller_loop	(	const bls12_381_G2	base,
		bls12_381_G2 &	current,
		bls12_381_ate_ell_coeffs &	c
	)

Definition at line 274 of file bls12_381_pairing.cpp.

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_pairing()

bls12_381_Fq12 libff::bls12_381_pairing	(	const bls12_381_G1 &	P,
		const bls12_381_G2 &	Q
	)

Definition at line 522 of file bls12_381_pairing.cpp.

 {
     return bls12_381_ate_pairing(P, Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_precompute_G1()

bls12_381_G1_precomp libff::bls12_381_precompute_G1 ( const bls12_381_G1 & P )

Definition at line 497 of file bls12_381_pairing.cpp.

 {
     return bls12_381_ate_precompute_G1(P);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_precompute_G2()

bls12_381_G2_precomp libff::bls12_381_precompute_G2 ( const bls12_381_G2 & Q )

Definition at line 502 of file bls12_381_pairing.cpp.

 {
     return bls12_381_ate_precompute_G2(Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bls12_381_reduced_pairing()

bls12_381_GT libff::bls12_381_reduced_pairing	(	const bls12_381_G1 &	P,
		const bls12_381_G2 &	Q
	)

Definition at line 527 of file bls12_381_pairing.cpp.

 {
     return bls12_381_ate_reduced_pairing(P, Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ 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 192 of file bn128_pairing.cpp.

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

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 166 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 179 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 200 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 caller graph for this function:

◆ bn128_final_exponentiation()

bn128_GT libff::bn128_final_exponentiation ( const bn128_Fq12 & elt )

Definition at line 212 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 )

◆ bw6_761_ate_double_miller_loop()

bw6_761_Fq6 libff::bw6_761_ate_double_miller_loop	(	const bw6_761_ate_G1_precomp &	prec_P1,
		const bw6_761_ate_G2_precomp &	prec_Q1,
		const bw6_761_ate_G1_precomp &	prec_P2,
		const bw6_761_ate_G2_precomp &	prec_Q2
	)

Definition at line 508 of file bw6_761_pairing.cpp.

 {
     enter_block("Call to bw6_761_ate_double_miller_loop");
  
     const bw6_761_ate_G2_precomp_iteration &prec_Q1_1 = prec_Q1.precomp_1;
     const bw6_761_ate_G2_precomp_iteration &prec_Q2_1 = prec_Q1.precomp_2;
     const bw6_761_ate_G2_precomp_iteration &prec_Q1_2 = prec_Q2.precomp_1;
     const bw6_761_ate_G2_precomp_iteration &prec_Q2_2 = prec_Q2.precomp_2;
  
     // f_{u+1,Q}(P)
     bw6_761_Fq6 f_1 = bw6_761_Fq6::one();
  
     bool found_nonzero_1 = false;
     size_t idx_1 = 0;
  
     bw6_761_ate_ell_coeffs c_1_1;
     bw6_761_ate_ell_coeffs c_1_2;
  
     const bigint<bw6_761_Fq::num_limbs> &loop_count_1 = bw6_761_ate_loop_count1;
     // Get the Non-Adjacent Form of the 1st loop count
     std::vector<long> NAF_1 = find_wnaf(1, loop_count_1);
     for (long i = NAF_1.size() - 1; i >= 0; --i) {
         if (!found_nonzero_1) {
             // This skips the MSB itself
             found_nonzero_1 |= (NAF_1[i] != 0);
             continue;
         }
  
         // The code below gets executed for all bits (EXCEPT the MSB itself) of
         // bw6_761_param_p (skipping leading zeros) in MSB to LSB
         // order
         c_1_1 = prec_Q1_1.coeffs[idx_1];
         c_1_2 = prec_Q1_2.coeffs[idx_1];
         ++idx_1;
  
         f_1 = f_1.squared();
         f_1 = f_1.mul_by_045(
             c_1_1.ell_0, prec_P1.PY * c_1_1.ell_VW, prec_P1.PX * c_1_1.ell_VV);
         f_1 = f_1.mul_by_045(
             c_1_2.ell_0, prec_P2.PY * c_1_2.ell_VW, prec_P2.PX * c_1_2.ell_VV);
  
         if (NAF_1[i] != 0) {
             c_1_1 = prec_Q1_1.coeffs[idx_1];
             c_1_2 = prec_Q1_2.coeffs[idx_1];
             ++idx_1;
  
             f_1 = f_1.mul_by_045(
                 c_1_1.ell_0,
                 prec_P1.PY * c_1_1.ell_VW,
                 prec_P1.PX * c_1_1.ell_VV);
             f_1 = f_1.mul_by_045(
                 c_1_2.ell_0,
                 prec_P2.PY * c_1_2.ell_VW,
                 prec_P2.PX * c_1_2.ell_VV);
         }
     }
  
     // f_{u^3-u^2-u,Q}(P)
     bw6_761_Fq6 f_2 = bw6_761_Fq6::one();
  
     bool found_nonzero_2 = false;
     size_t idx_2 = 0;
  
     bw6_761_ate_ell_coeffs c_2_1;
     bw6_761_ate_ell_coeffs c_2_2;
  
     const bigint<bw6_761_Fq::num_limbs> &loop_count_2 = bw6_761_ate_loop_count2;
     // Get the Non-Adjacent Form of the 1st loop count
     std::vector<long> NAF_2 = find_wnaf(1, loop_count_2);
     for (long i = NAF_2.size() - 1; i >= 0; --i) {
         if (!found_nonzero_2) {
             // This skips the MSB itself
             found_nonzero_2 |= (NAF_2[i] != 0);
             continue;
         }
  
         // The code below gets executed for all bits (EXCEPT the MSB itself) of
         // bw6_761_param_p (skipping leading zeros) in MSB to LSB
         // order
         c_2_1 = prec_Q2_1.coeffs[idx_2];
         c_2_2 = prec_Q2_2.coeffs[idx_2];
         ++idx_2;
  
         f_2 = f_2.squared();
  
         f_2 = f_2.mul_by_045(
             c_2_1.ell_0, prec_P1.PY * c_2_1.ell_VW, prec_P1.PX * c_2_1.ell_VV);
         f_2 = f_2.mul_by_045(
             c_2_2.ell_0, prec_P2.PY * c_2_2.ell_VW, prec_P2.PX * c_2_2.ell_VV);
  
         if (NAF_2[i] != 0) {
             c_2_1 = prec_Q2_1.coeffs[idx_2];
             c_2_2 = prec_Q2_2.coeffs[idx_2];
             ++idx_2;
  
             f_2 = f_2.mul_by_045(
                 c_2_1.ell_0,
                 prec_P1.PY * c_2_1.ell_VW,
                 prec_P1.PX * c_2_1.ell_VV);
             f_2 = f_2.mul_by_045(
                 c_2_2.ell_0,
                 prec_P2.PY * c_2_2.ell_VW,
                 prec_P2.PX * c_2_2.ell_VV);
         }
     }
  
     leave_block("Call to bw6_761_ate_double_miller_loop");
  
     f_2 = f_2.Frobenius_map(1);
  
     return f_1 * f_2;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_ate_miller_loop()

bw6_761_Fq6 libff::bw6_761_ate_miller_loop	(	const bw6_761_ate_G1_precomp &	prec_P,
		const bw6_761_ate_G2_precomp &	prec_Q
	)

Definition at line 423 of file bw6_761_pairing.cpp.

 {
     enter_block("Call to bw6_761_ate_miller_loop");
  
     const bw6_761_ate_G2_precomp_iteration &prec_Q_1 = prec_Q.precomp_1;
     const bw6_761_ate_G2_precomp_iteration &prec_Q_2 = prec_Q.precomp_2;
  
     // f_{u+1,Q}(P)
     bw6_761_Fq6 f_1 = bw6_761_Fq6::one();
  
     bool found_nonzero_1 = false;
     size_t idx_1 = 0;
  
     const bigint<bw6_761_Fq::num_limbs> &loop_count_1 = bw6_761_ate_loop_count1;
     bw6_761_ate_ell_coeffs c_1;
  
     // Get the Non-Adjacent Form of the loop count
     // loop_count_1 = u+1
     // This allows to cover steps 2 to 11 Algorithm 5:
     // https://eprint.iacr.org/2020/351.pdf
     std::vector<long> NAF_1 = find_wnaf(1, loop_count_1);
     for (long i = NAF_1.size() - 1; i >= 0; --i) {
         if (!found_nonzero_1) {
             // This skips the MSB itself
             found_nonzero_1 |= (NAF_1[i] != 0);
             continue;
         }
  
         // The code below gets executed for all bits (EXCEPT the MSB itself) of
         // bw6_761_param_p (skipping leading zeros) in MSB to LSB
         // order
         c_1 = prec_Q_1.coeffs[idx_1];
         ++idx_1;
         f_1 = f_1.squared();
         f_1 = f_1.mul_by_045(
             c_1.ell_0, prec_P.PY * c_1.ell_VW, prec_P.PX * c_1.ell_VV);
  
         if (NAF_1[i] != 0) {
             c_1 = prec_Q_1.coeffs[idx_1];
             ++idx_1;
             f_1 = f_1.mul_by_045(
                 c_1.ell_0, prec_P.PY * c_1.ell_VW, prec_P.PX * c_1.ell_VV);
         }
     }
  
     // f_{u^3-u^2-u,Q}(P)
     bw6_761_Fq6 f_2 = bw6_761_Fq6::one();
  
     bool found_nonzero_2 = false;
     size_t idx_2 = 0;
  
     const bigint<bw6_761_Fq::num_limbs> &loop_count_2 = bw6_761_ate_loop_count2;
     bw6_761_ate_ell_coeffs c_2;
  
     std::vector<long> NAF_2 = find_wnaf(1, loop_count_2);
     for (long i = NAF_2.size() - 1; i >= 0; --i) {
         if (!found_nonzero_2) {
             // This skips the MSB itself
             found_nonzero_2 |= (NAF_2[i] != 0);
             continue;
         }
  
         // The code below gets executed for all bits (EXCEPT the MSB itself) of
         // bw6_761_param_p (skipping leading zeros) in MSB to LSB
         // order
         c_2 = prec_Q_2.coeffs[idx_2++];
         f_2 = f_2.squared();
         f_2 = f_2.mul_by_045(
             c_2.ell_0, prec_P.PY * c_2.ell_VW, prec_P.PX * c_2.ell_VV);
  
         if (NAF_2[i] != 0) {
             c_2 = prec_Q_2.coeffs[idx_2++];
             f_2 = f_2.mul_by_045(
                 c_2.ell_0, prec_P.PY * c_2.ell_VW, prec_P.PX * c_2.ell_VV);
         }
     }
  
     leave_block("Call to bw6_761_ate_miller_loop");
  
     f_2 = f_2.Frobenius_map(1);
  
     return f_1 * f_2;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_ate_pairing()

bw6_761_Fq6 libff::bw6_761_ate_pairing	(	const bw6_761_G1 &	P,
		const bw6_761_G2 &	Q
	)

Definition at line 625 of file bw6_761_pairing.cpp.

 {
     enter_block("Call to bw6_761_ate_pairing");
     bw6_761_ate_G1_precomp prec_P = bw6_761_ate_precompute_G1(P);
     bw6_761_ate_G2_precomp prec_Q = bw6_761_ate_precompute_G2(Q);
     bw6_761_Fq6 result = bw6_761_ate_miller_loop(prec_P, prec_Q);
     leave_block("Call to bw6_761_ate_pairing");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_ate_precompute_G1()

bw6_761_ate_G1_precomp libff::bw6_761_ate_precompute_G1 ( const bw6_761_G1 & P )

Definition at line 354 of file bw6_761_pairing.cpp.

 {
     enter_block("Call to bw6_761_ate_precompute_G1");
  
     bw6_761_G1 Pcopy = P;
     Pcopy.to_affine_coordinates();
  
     bw6_761_ate_G1_precomp result;
     result.PX = Pcopy.X;
     result.PY = Pcopy.Y;
  
     leave_block("Call to bw6_761_ate_precompute_G1");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_ate_precompute_G2()

bw6_761_ate_G2_precomp libff::bw6_761_ate_precompute_G2 ( const bw6_761_G2 & Q )

Definition at line 414 of file bw6_761_pairing.cpp.

 {
     return {
         bw6_761_ate_precompute_G2_internal(Q, bw6_761_ate_loop_count1),
         bw6_761_ate_precompute_G2_internal(Q, bw6_761_ate_loop_count2),
     };
 }

Here is the caller graph for this function:

◆ bw6_761_ate_reduced_pairing()

bw6_761_GT libff::bw6_761_ate_reduced_pairing	(	const bw6_761_G1 &	P,
		const bw6_761_G2 &	Q
	)

Definition at line 635 of file bw6_761_pairing.cpp.

 {
     enter_block("Call to bw6_761_ate_reduced_pairing");
     const bw6_761_Fq6 f = bw6_761_ate_pairing(P, Q);
     const bw6_761_GT result = bw6_761_final_exponentiation(f);
     leave_block("Call to bw6_761_ate_reduced_pairing");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_double_miller_loop()

bw6_761_Fq6 libff::bw6_761_double_miller_loop	(	const bw6_761_ate_G1_precomp &	prec_P1,
		const bw6_761_ate_G2_precomp &	prec_Q1,
		const bw6_761_ate_G1_precomp &	prec_P2,
		const bw6_761_ate_G2_precomp &	prec_Q2
	)

Definition at line 662 of file bw6_761_pairing.cpp.

 {
     return bw6_761_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:

◆ bw6_761_exp_by_z()

bw6_761_Fq6 libff::bw6_761_exp_by_z ( const bw6_761_Fq6 & elt )

Definition at line 150 of file bw6_761_pairing.cpp.

 {
     enter_block("Call to bw6_761_exp_by_z");
  
     bw6_761_Fq6 result = elt.cyclotomic_exp(bw6_761_final_exponent_z);
     if (bw6_761_final_exponent_is_z_neg) {
         result = result.unitary_inverse();
     }
  
     leave_block("Call to bw6_761_exp_by_z");
  
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_final_exponentiation()

bw6_761_GT libff::bw6_761_final_exponentiation ( const bw6_761_Fq6 & elt )

Definition at line 258 of file bw6_761_pairing.cpp.

 {
     enter_block("Call to bw6_761_final_exponentiation");
  
     bw6_761_Fq6 elt_to_first_chunk =
         bw6_761_final_exponentiation_first_chunk(elt);
     bw6_761_GT result =
         bw6_761_final_exponentiation_last_chunk(elt_to_first_chunk);
  
     leave_block("Call to bw6_761_final_exponentiation");
  
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_final_exponentiation_first_chunk()

bw6_761_Fq6 libff::bw6_761_final_exponentiation_first_chunk ( const bw6_761_Fq6 & elt )

Definition at line 131 of file bw6_761_pairing.cpp.

 {
     // Compute elt^{(q^3-1)*(q+1)}
     enter_block("Call to bw6_761_final_exponentiation_first_chunk");
  
     // A = elt^(q^3)
     const bw6_761_Fq6 A = elt.Frobenius_map(3);
     // B = elt^(q^3-1)
     const bw6_761_Fq6 elt_inv = elt.inverse();
     const bw6_761_Fq6 B = A * elt_inv;
     // D = elt^((q^3-1) * q)
     const bw6_761_Fq6 D = B.Frobenius_map(1);
     // result = elt^{(q^3-1)*(q+1)}
     const bw6_761_Fq6 result = D * B;
  
     leave_block("Call to bw6_761_final_exponentiation_first_chunk");
     return result;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_final_exponentiation_last_chunk()

bw6_761_Fq6 libff::bw6_761_final_exponentiation_last_chunk ( const bw6_761_Fq6 & elt )

Definition at line 172 of file bw6_761_pairing.cpp.

 {
     enter_block("Call to bw6_761_final_exponentiation_last_chunk");
  
     // Step 1
     const bw6_761_Fq6 f0 = elt;
     const bw6_761_Fq6 f0p = f0.Frobenius_map(1);
  
     // Step 2-3: For loop
     const bw6_761_Fq6 f1 = bw6_761_exp_by_z(f0);
     const bw6_761_Fq6 f1p = f1.Frobenius_map(1);
     const bw6_761_Fq6 f2 = bw6_761_exp_by_z(f1);
     const bw6_761_Fq6 f2p = f2.Frobenius_map(1);
     const bw6_761_Fq6 f3 = bw6_761_exp_by_z(f2);
     const bw6_761_Fq6 f3p = f3.Frobenius_map(1);
     const bw6_761_Fq6 f4 = bw6_761_exp_by_z(f3);
     const bw6_761_Fq6 f4p = f4.Frobenius_map(1);
     const bw6_761_Fq6 f5 = bw6_761_exp_by_z(f4);
     const bw6_761_Fq6 f5p = f5.Frobenius_map(1);
     const bw6_761_Fq6 f6 = bw6_761_exp_by_z(f5);
     const bw6_761_Fq6 f6p = f6.Frobenius_map(1);
     const bw6_761_Fq6 f7 = bw6_761_exp_by_z(f6);
     const bw6_761_Fq6 f7p = f7.Frobenius_map(1);
  
     // Step 4
     const bw6_761_Fq6 f8p = bw6_761_exp_by_z(f7p);
     const bw6_761_Fq6 f9p = bw6_761_exp_by_z(f8p);
  
     // Step 5
     const bw6_761_Fq6 result1 = f3p * f6p * f5p.Frobenius_map(3);
  
     // Step 6
     const bw6_761_Fq6 result2 = result1.squared();
     const bw6_761_Fq6 f4_2p = f4 * f2p;
     const bw6_761_Fq6 result3 =
         result2 * f5 * f0p * (f0 * f1 * f3 * f4_2p * f8p).Frobenius_map(3);
  
     // Step 7
     const bw6_761_Fq6 result4 = result3.squared();
     const bw6_761_Fq6 result5 = result4 * f9p * f7.Frobenius_map(3);
  
     // Step 8
     const bw6_761_Fq6 result6 = result5.squared();
     const bw6_761_Fq6 f2_4p = f2 * f4p;
     const bw6_761_Fq6 f4_2p_5p = f4_2p * f5p;
     const bw6_761_Fq6 result7 =
         result6 * f4_2p_5p * f6 * f7p * (f2_4p * f3 * f3p).Frobenius_map(3);
  
     // Step 9
     const bw6_761_Fq6 result8 = result7.squared();
     const bw6_761_Fq6 result9 =
         result8 * f0 * f7 * f1p * (f0p * f9p).Frobenius_map(3);
  
     // Step 10
     const bw6_761_Fq6 result10 = result9.squared();
     const bw6_761_Fq6 f6p_8p = f6p * f8p;
     const bw6_761_Fq6 f5_7p = f5 * f7p;
     const bw6_761_Fq6 result11 =
         result10 * f5_7p * f2p * (f6p_8p).Frobenius_map(3);
  
     // Step 11
     const bw6_761_Fq6 result12 = result11.squared();
     const bw6_761_Fq6 f3_6 = f3 * f6;
     const bw6_761_Fq6 f1_7 = f1 * f7;
     const bw6_761_Fq6 result13 =
         result12 * f3_6 * f9p * (f1_7 * f2).Frobenius_map(3);
  
     // Step 12
     const bw6_761_Fq6 result14 = result13.squared();
     const bw6_761_Fq6 result15 = result14 * f0 * f0p * f3p * f5p *
                                  (f4_2p * f5_7p * f6p_8p).Frobenius_map(3);
  
     // Step 13
     const bw6_761_Fq6 result16 = result15.squared();
     const bw6_761_Fq6 result17 = result16 * f1p * (f3_6).Frobenius_map(3);
  
     // Step 14
     const bw6_761_Fq6 result18 = result17.squared();
     const bw6_761_Fq6 result19 = result18 * f1_7 * f5_7p * f0p *
                                  (f2_4p * f4_2p_5p * f9p).Frobenius_map(3);
  
     leave_block("Call to bw6_761_final_exponentiation_last_chunk");
  
     return result19;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_miller_loop()

bw6_761_Fq6 libff::bw6_761_miller_loop	(	const bw6_761_G1_precomp &	prec_P,
		const bw6_761_G2_precomp &	prec_Q
	)

Definition at line 656 of file bw6_761_pairing.cpp.

 {
     return bw6_761_ate_miller_loop(prec_P, prec_Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_pairing()

bw6_761_Fq6 libff::bw6_761_pairing	(	const bw6_761_G1 &	P,
		const bw6_761_G2 &	Q
	)

Definition at line 671 of file bw6_761_pairing.cpp.

 {
     return bw6_761_ate_pairing(P, Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_precompute_G1()

bw6_761_G1_precomp libff::bw6_761_precompute_G1 ( const bw6_761_G1 & P )

Definition at line 646 of file bw6_761_pairing.cpp.

 {
     return bw6_761_ate_precompute_G1(P);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_precompute_G2()

bw6_761_G2_precomp libff::bw6_761_precompute_G2 ( const bw6_761_G2 & Q )

Definition at line 651 of file bw6_761_pairing.cpp.

 {
     return bw6_761_ate_precompute_G2(Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bw6_761_reduced_pairing()

bw6_761_GT libff::bw6_761_reduced_pairing	(	const bw6_761_G1 &	P,
		const bw6_761_G2 &	Q
	)

Definition at line 676 of file bw6_761_pairing.cpp.

 {
     return bw6_761_ate_reduced_pairing(P, Q);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bytes_to_hex_reversed()

std::string libff::bytes_to_hex_reversed	(	const void *	bytes,
		size_t	num_bytes,
		bool	prefix
	)

"prefix" here refers to "0x"

Definition at line 87 of file serialization.cpp.

 {
     if (num_bytes == 0) {
         return "";
     }
  
     std::string out;
     if (prefix) {
         out.reserve(num_bytes * 2 + 2);
         out.push_back('0');
         out.push_back('x');
     } else {
         out.reserve(num_bytes * 2);
     }
  
     const uint8_t *const src_bytes_end = (const uint8_t *)bytes;
     const uint8_t *src_bytes = src_bytes_end + num_bytes;
     do {
         --src_bytes;
         const uint8_t byte = *src_bytes;
         out.push_back(nibble_hex(byte >> 4));
         out.push_back(nibble_hex(byte & 0x0f));
     } while (src_bytes > src_bytes_end);
  
     return out;
 }

◆ char_to_nibble()

uint8_t libff::char_to_nibble ( const char c )

Definition at line 19 of file serialization.cpp.

 {
     const char cc = (char)std::tolower(c);
     if (cc < '0') {
         throw std::invalid_argument("invalid hex character");
     }
     if (cc <= '9') {
         return cc - '0';
     }
     if (cc < 'a') {
         throw std::invalid_argument("invalid hex character");
     }
     if (cc <= 'f') {
         return cc - 'a' + 10;
     }
     throw std::invalid_argument("invalid hex character");
 }

◆ clear_profiling_counters()

void libff::clear_profiling_counters ( )

Definition at line 110 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

Here is the caller graph for this function:

◆ 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 111 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 82 of file utils.cpp.

82 { 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 246 of file alt_bn128_pairing.cpp.

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

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 489 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 400 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 405 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() [1/2]

void libff::doubling_step_for_miller_loop	(	bw6_761_G2 &	current,
		bw6_761_ate_ell_coeffs &	c
	)

Definition at line 274 of file bw6_761_pairing.cpp.

 {
     const bw6_761_Fq X = current.X, Y = current.Y, Z = current.Z;
  
     // A = X1 * Y1
     const bw6_761_Fq A = X * Y;
     // B = Y1^2
     const bw6_761_Fq B = Y.squared();
     // B4 = 4 * Y1^2
     const bw6_761_Fq B4 = B + B + B + B;
     // C = Z1^2
     const bw6_761_Fq C = Z.squared();
     // D = 3 * C
     const bw6_761_Fq D = C + C + C;
     // E = bw6_761_twist_coeff_b * D
     const bw6_761_Fq E = bw6_761_twist_coeff_b * D;
     // F = 3 * E
     const bw6_761_Fq F = E + E + E;
     // G = B+F
     const bw6_761_Fq G = B + F;
     // H = (Y1+Z1)^2-(B+C)
     const bw6_761_Fq H = (Y + Z).squared() - (B + C);
     // I = E-B
     const bw6_761_Fq I = E - B;
     // J = X1^2
     const bw6_761_Fq J = X.squared();
     // E2_squared = (2E)^2
     const bw6_761_Fq E2_squared = (E + E).squared();
  
     // X3 = 2A * (B-F)
     current.X = (A + A) * (B - F);
     // Y3 = G^2 - 3*E2^2
     current.Y = G.squared() - (E2_squared + E2_squared + E2_squared);
     // Z3 = 4 * B * H
     current.Z = B4 * H;
  
     // ell_0 = I
     c.ell_0 = I;
     // ell_VW = -xi * H (later: * yP)
     c.ell_VW = -bw6_761_twist * H;
     // ell_VV = 3*J (later: * xP)
     c.ell_VV = J + J + J;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ doubling_step_for_miller_loop() [2/2]

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

Definition at line 267 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:

◆ 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 702 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 662 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 757 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 609 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 623 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 767 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 792 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 219 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 200 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 179 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 786 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 801 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 776 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 781 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 806 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 409 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 451 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 367 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 234 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 461 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 271 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 30 of file utils.hpp.

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

◆ field_get_component_0()

template<typename FieldT >

const FieldT::my_Fp& libff::field_get_component_0 ( const FieldT & v )

Rerturns a reference to the 0-th component of the element (or the element itself if FieldT is not an extension field).

◆ field_get_digit()

template<mp_size_t n>

size_t libff::field_get_digit	(	const bigint< n > &	v,
		const size_t	digit_size,
		const size_t	digit_index
	)

Decompose v into fixed-size digits of digit_size bits each.

◆ field_get_signed_digit()

template<mp_size_t n>

ssize_t libff::field_get_signed_digit	(	const bigint< n > &	v,
		const size_t	digit_size,
		const size_t	digit_index
	)

Decompose v into fixed-size signed digits of digit_size bits each.

◆ field_get_signed_digits()

template<typename FieldT >

void libff::field_get_signed_digits	(	std::vector< ssize_t > &	digits,
		const FieldT &	v,
		const size_t	digit_size,
		const size_t	num_digits
	)

Decompose the input into a (pre-allocated) vector of fixed-size signed digits, of size digit_size bits.

◆ field_read()

template<encoding_t Enc = encoding_binary, form_t Form = form_plain, typename FieldT >

void libff::field_read	(	FieldT &	v,
		std::istream &	in_s
	)

◆ field_write()

template<encoding_t Enc = encoding_binary, form_t Form = form_plain, typename FieldT >

void libff::field_write	(	const FieldT &	v,
		std::ostream &	out_s
	)

◆ 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() [1/2]

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.

◆ fixed_window_wnaf_exp() [2/2]

template<typename T >

T libff::fixed_window_wnaf_exp	(	const size_t	window_size,
		const T &	base,
		const std::vector< long > &	naf
	)

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

◆ FORMAT()

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

Definition at line 91 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);
 }

◆ fp_from_fp()

template<mp_size_t wn, const bigint< wn > & wmodulus, mp_size_t nn, const bigint< nn > & nmodulus>

void libff::fp_from_fp	(	Fp_model< wn, wmodulus > &	wfp,
		const Fp_model< nn, nmodulus > &	nfp
	)

Safe conversion from one finite field type to another. Internally asserts that the transformation is injective (i.e. multiple input values cannot result in the same output value).

◆ from_twos_complement()

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

Definition at line 53 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 530 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 301 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
 }

Here is the call graph for this function:

◆ g1_curve_point_at_x()

template<typename GroupT >

GroupT libff::g1_curve_point_at_x ( const typename GroupT::base_field & x )

◆ g2_curve_point_at_x()

template<typename GroupT >

GroupT libff::g2_curve_point_at_x ( const typename GroupT::twist_field & x )

◆ 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 42 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.

◆ group_read()

template<encoding_t Enc, form_t Form, compression_t Comp, typename GroupT >

void libff::group_read	(	GroupT &	v,
		std::istream &	in_s
	)

◆ group_write()

template<encoding_t Enc, form_t Form, compression_t Comp, typename GroupT >

void libff::group_write	(	const GroupT &	v,
		std::ostream &	out_s
	)

◆ has_root_of_unity() [1/2]

template<typename FieldT >

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

◆ has_root_of_unity() [2/2]

template<typename FieldT >

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

◆ hex_to_bytes_reversed()

void libff::hex_to_bytes_reversed	(	const std::string &	hex,
		void *	dest,
		size_t	bytes
	)

Definition at line 72 of file serialization.cpp.

 {
     if (bytes == 0) {
         return;
     }
     const char *cur = find_hex_string_of_length(hex, bytes);
     uint8_t *const dest_bytes_end = (uint8_t *)dest;
     uint8_t *dest_bytes = dest_bytes_end + bytes;
     do {
         --dest_bytes;
         *dest_bytes = chars_to_byte(cur);
         cur += 2;
     } while (dest_bytes > dest_bytes_end);
 }

◆ init_alt_bn128_params()

void libff::init_alt_bn128_params ( )

Definition at line 32 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("2188824287183927522224640574525727508854836"
                                    "4400416034343698204186575808495617");
     assert(alt_bn128_Fr::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         alt_bn128_Fr::Rsquared =
             bigint_r("944936681149208446651664254269745548490766851729442924617"
                      "792859073125903783");
         alt_bn128_Fr::Rcubed =
             bigint_r("586654854594384522748989487204024472040386810557878410528"
                      "1690076696998248512");
         alt_bn128_Fr::inv = 0xc2e1f593efffffff;
     }
     if (sizeof(mp_limb_t) == 4) {
         alt_bn128_Fr::Rsquared =
             bigint_r("944936681149208446651664254269745548490766851729442924617"
                      "792859073125903783");
         alt_bn128_Fr::Rcubed =
             bigint_r("586654854594384522748989487204024472040386810557878410528"
                      "1690076696998248512");
         alt_bn128_Fr::inv = 0xefffffff;
     }
     alt_bn128_Fr::num_bits = 254;
     alt_bn128_Fr::euler = bigint_r("1094412143591963761112320287262863754427418"
                                    "2200208017171849102093287904247808");
     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("191032190679217139442913928276920700361456519573292863153"
                      "05642004821462161904");
     alt_bn128_Fr::nqr = alt_bn128_Fr("5");
     alt_bn128_Fr::nqr_to_t =
         alt_bn128_Fr("191032190679217139442913928276920700361456519573292863153"
                      "05642004821462161904");
     alt_bn128_Fr::static_init();
  
     /* parameters for base field Fq */
  
     alt_bn128_modulus_q = bigint_q("2188824287183927522224640574525727508869631"
                                    "1157297823662689037894645226208583");
     assert(alt_bn128_Fq::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         alt_bn128_Fq::Rsquared =
             bigint_q("309661650298370392384356793683737445173554096841907652877"
                      "1170197431451843209");
         alt_bn128_Fq::Rcubed =
             bigint_q("149217865411596481859481527385630809590936198385102451777"
                      "10943249661917737183");
         alt_bn128_Fq::inv = 0x87d20782e4866389;
     }
     if (sizeof(mp_limb_t) == 4) {
         alt_bn128_Fq::Rsquared =
             bigint_q("309661650298370392384356793683737445173554096841907652877"
                      "1170197431451843209");
         alt_bn128_Fq::Rcubed =
             bigint_q("149217865411596481859481527385630809590936198385102451777"
                      "10943249661917737183");
         alt_bn128_Fq::inv = 0xe4866389;
     }
     alt_bn128_Fq::num_bits = 254;
     alt_bn128_Fq::euler = bigint_q("1094412143591963761112320287262863754434815"
                                    "5578648911831344518947322613104291");
     alt_bn128_Fq::s = 1;
     alt_bn128_Fq::t = bigint_q("10944121435919637611123202872628637544348155578"
                                "648911831344518947322613104291");
     alt_bn128_Fq::t_minus_1_over_2 =
         bigint_q("5472060717959818805561601436314318772174077789324455915672259"
                  "473661306552145");
     alt_bn128_Fq::multiplicative_generator = alt_bn128_Fq("3");
     alt_bn128_Fq::root_of_unity =
         alt_bn128_Fq("218882428718392752222464057452572750886963111572978236626"
                      "89037894645226208582");
     alt_bn128_Fq::nqr = alt_bn128_Fq("3");
     alt_bn128_Fq::nqr_to_t =
         alt_bn128_Fq("218882428718392752222464057452572750886963111572978236626"
                      "89037894645226208582");
     alt_bn128_Fq::static_init();
  
     /* parameters for twist field Fq2 */
     alt_bn128_Fq2::euler = bigint<2 * alt_bn128_q_limbs>(
         "2395475880083114212209940226083393703996261582655504112182239011270350"
         "4684318911872392052590971893598559411615740655013091812781706979347432"
         "3196511433944");
     alt_bn128_Fq2::s = 4;
     alt_bn128_Fq2::t = bigint<2 * alt_bn128_q_limbs>(
         "2994344850103892765262425282604242129995326978319380140227798764087938"
         "0855398639840490065738714866998199264519675818766364765977133724184290"
         "399563929243");
     alt_bn128_Fq2::t_minus_1_over_2 = bigint<2 * alt_bn128_q_limbs>(
         "1497172425051946382631212641302121064997663489159690070113899382043969"
         "0427699319920245032869357433499099632259837909383182382988566862092145"
         "199781964621");
     alt_bn128_Fq2::non_residue =
         alt_bn128_Fq("218882428718392752222464057452572750886963111572978236626"
                      "89037894645226208582");
     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("503350371626262426731249255837998268717520073493487759859"
                      "9011485707452665730"),
         alt_bn128_Fq("314498342015008975724433667930697407966947188435857772134"
                      "235984660852259084"));
     alt_bn128_Fq2::Frobenius_coeffs_c1[0] = alt_bn128_Fq("1");
     alt_bn128_Fq2::Frobenius_coeffs_c1[1] =
         alt_bn128_Fq("218882428718392752222464057452572750886963111572978236626"
                      "89037894645226208582");
     alt_bn128_Fq2::static_init();
  
     /* 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("215754636382808430103983242694308260992690442743472168272"
                      "12613867836435027261"),
         alt_bn128_Fq("103076015958737097001522842738161122640692301306164367556"
                      "25194854815875713954"));
     alt_bn128_Fq6::Frobenius_coeffs_c1[2] = alt_bn128_Fq2(
         alt_bn128_Fq("218882428718392752200424452601091531672777074144720616417"
                      "14758635765020556616"),
         alt_bn128_Fq("0"));
     alt_bn128_Fq6::Frobenius_coeffs_c1[3] = alt_bn128_Fq2(
         alt_bn128_Fq("377200088191985377643369518671385823900907359381719577177"
                      "3381919316419345261"),
         alt_bn128_Fq("223659549596724518828170124820318179512106890260586122785"
                      "5261137820944008926"));
     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("184290212234778536576607920343698658391145044464312347263"
                      "92080002137598044644"),
         alt_bn128_Fq("934404577999832033381242022323798102950601212407552567920"
                      "8581902008406485703"));
     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("258191134446700933526731111546880309955166560507619674086"
                      "7805258568234346338"),
         alt_bn128_Fq("199377569717756479879959321699293419943146406529649494483"
                      "13374472400716661030"));
     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("532447920244990354272678339550621448192825776240064327978"
                      "0343368557297135718"),
         alt_bn128_Fq("162089003807376930849194951273343879813937264198568887999"
                      "17914180988844123039"));
     alt_bn128_Fq6::Frobenius_coeffs_c2[4] = alt_bn128_Fq2(
         alt_bn128_Fq("218882428718392752200424452601091531672777074144720616417"
                      "14758635765020556616"),
         alt_bn128_Fq("0"));
     alt_bn128_Fq6::Frobenius_coeffs_c2[5] = alt_bn128_Fq2(
         alt_bn128_Fq("139818523249223623442523112342822575072163877898209836420"
                      "40889267519694726527"),
         alt_bn128_Fq("762982839116520937157738419325082020168425524177380907714"
                      "6787135900891633097"));
  
     /* 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("837611886576382149658397386762636409258990606586829877690"
                      "9617916018768340080"),
         alt_bn128_Fq("164698233230778082238891372411765367990092866461081699356"
                      "59301613961712198316"));
     alt_bn128_Fq12::Frobenius_coeffs_c1[2] = alt_bn128_Fq2(
         alt_bn128_Fq("218882428718392752200424452601091531672777074144720616417"
                      "14758635765020556617"),
         alt_bn128_Fq("0"));
     alt_bn128_Fq12::Frobenius_coeffs_c1[3] = alt_bn128_Fq2(
         alt_bn128_Fq("116974234963581543048257829225847253129123834411595050387"
                      "94027105778954184319"),
         alt_bn128_Fq("303847389135065887422783454877609941456349188919719272345"
                      "083954437860409601"));
     alt_bn128_Fq12::Frobenius_coeffs_c1[4] = alt_bn128_Fq2(
         alt_bn128_Fq("218882428718392752200424452601091531672777074144720616417"
                      "14758635765020556616"),
         alt_bn128_Fq("0"));
     alt_bn128_Fq12::Frobenius_coeffs_c1[5] = alt_bn128_Fq2(
         alt_bn128_Fq("332130463059433280824180905495836122032247737529120626188"
                      "4409189760185844239"),
         alt_bn128_Fq("572226693789653288578005195895834823114337370010937299937"
                      "4820235121374419868"));
     alt_bn128_Fq12::Frobenius_coeffs_c1[6] = alt_bn128_Fq2(
         alt_bn128_Fq("218882428718392752222464057452572750886963111572978236626"
                      "89037894645226208582"),
         alt_bn128_Fq("0"));
     alt_bn128_Fq12::Frobenius_coeffs_c1[7] = alt_bn128_Fq2(
         alt_bn128_Fq("135121240060754537256624318776309109961064050914295248857"
                      "79419978626457868503"),
         alt_bn128_Fq("541841954876146699835726850408073828968702451118965372702"
                      "9736280683514010267"));
     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("101908193754811209174206228226725497757839277161383186238"
                      "95010788866272024264"),
         alt_bn128_Fq("215843954827042093348236222903796651472399619683781043903"
                      "43953940207365798982"));
     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("185669382412449424140045966902989138683738337820066174008"
                      "04628704885040364344"),
         alt_bn128_Fq("161659759339427423364663537862989268575529374571884506633"
                      "14217659523851788715"));
  
     /* 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("215754636382808430103983242694308260992690442743472168272"
                      "12613867836435027261"),
         alt_bn128_Fq("103076015958737097001522842738161122640692301306164367556"
                      "25194854815875713954"));
     alt_bn128_twist_mul_by_q_Y = alt_bn128_Fq2(
         alt_bn128_Fq("282156518219453684454815956169350265935961718524412036707"
                      "8079554186484126554"),
         alt_bn128_Fq("350584376791155637868703030998424884554024350989925964101"
                      "3678093033130930403"));
  
     /* choice of group G1 */
  
     // Identities
     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());
  
     // Curve coeffs
     alt_bn128_G1::coeff_a = alt_bn128_Fq::zero();
     alt_bn128_G1::coeff_b = alt_bn128_coeff_b;
  
     // Cofactor
     alt_bn128_G1::h = bigint<alt_bn128_G1::h_limbs>("1");
  
     // WNAF
     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 */
  
     // Identities
     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("10857046999023057135944570762232829481370756359578518"
                          "086990519993285655852781"),
             alt_bn128_Fq("11559732032986387107991004021392285783925812861821192"
                          "530917403151452391805634")),
         alt_bn128_Fq2(
             alt_bn128_Fq("84956539231234314176049732474892724384181905872636001"
                          "48770280649306958101930"),
             alt_bn128_Fq("40823678758634336813322034031454355683168513275934012"
                          "08105741076214120093531")),
         alt_bn128_Fq2::one());
  
     // Curve coeffs
     alt_bn128_G2::coeff_a = alt_bn128_Fq2::zero();
     alt_bn128_G2::coeff_b = alt_bn128_twist_coeff_b;
  
     // Cofactor
     // [Sage excerpt]
     // u = 4965661367192848881
     // h2 = (36 * u^4) + (36 * u^3) + (30 * u^2) + 6*u + 1; h2
     // #
     // 21888242871839275222246405745257275088844257914179612981679871602714643921549
     alt_bn128_G2::h =
         bigint<alt_bn128_G2::h_limbs>("2188824287183927522224640574525727508884"
                                       "4257914179612981679871602714643921549");
  
     // WNAF
     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>(
         "5524842336132240963126171267831731470973821037629576541888827343141969"
         "1083990754121397450276154062981700960854865468034362770115382944674781"
         "0907373256841551006201639677726139946029199968412598804882391702273019"
         "0836532720475663165843655597764930274954582383739028759376599435048732"
         "2055416155052592630230333174746351564471187665317712957830319109590090"
         "9191624817826566688241804408081892785725967931714097716709526092261278"
         "0719525601711114440720492291235650574837501614600243533462841672824527"
         "5621766233552881351913980829117053907212538123081572907154486160275093"
         "6964829313608137325426383735122175229541155376346436093930287402089517"
         "4269731789175697133847480818272554725769374714961957527271882614356332"
         "7123871013173609629979816885292554054934233077527987700678435480142224"
         "972257378356168517961881648003769500551542616236243107224563832474448"
         "0");
     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_bls12_377_params()

void libff::init_bls12_377_params ( )

Definition at line 50 of file bls12_377_init.cpp.

 {
     typedef bigint<bls12_377_r_limbs> bigint_r;
     typedef bigint<bls12_377_q_limbs> bigint_q;
  
     // Montgomery assumes this
     assert(sizeof(mp_limb_t) == 8 || sizeof(mp_limb_t) == 4);
  
     // Parameters for scalar field Fr
     // r = 0x12ab655e9a2ca55660b44d1e5c37b00159aa76fed00000010a11800000000001
     bls12_377_modulus_r = bigint_r("8444461749428370424248824938781546531375899"
                                    "335154063827935233455917409239041");
     assert(bls12_377_Fr::modulus_is_valid());
     // 64-bit architecture
     if (sizeof(mp_limb_t) == 8) {
         bls12_377_Fr::Rsquared =
             bigint_r("508595941311779472113692600146818027278633330499214071737"
                      "745792929336755579");
         bls12_377_Fr::Rcubed =
             bigint_r("271718748542331355632020787121653842635320109739890963908"
                      "6937135091399607628");
         bls12_377_Fr::inv = 0xa117fffffffffff;
     }
     // 32-bit architecture
     if (sizeof(mp_limb_t) == 4) {
         bls12_377_Fr::Rsquared =
             bigint_r("508595941311779472113692600146818027278633330499214071737"
                      "745792929336755579");
         bls12_377_Fr::Rcubed =
             bigint_r("271718748542331355632020787121653842635320109739890963908"
                      "6937135091399607628");
         bls12_377_Fr::inv = 0xffffffff;
     }
     bls12_377_Fr::num_bits = 253;
     bls12_377_Fr::euler = bigint_r("4222230874714185212124412469390773265687949"
                                    "667577031913967616727958704619520");
     bls12_377_Fr::s = 47;
     bls12_377_Fr::t = bigint_r(
         "60001509534603559531609739528203892656505753216962260608619555");
     bls12_377_Fr::t_minus_1_over_2 = bigint_r(
         "30000754767301779765804869764101946328252876608481130304309777");
     bls12_377_Fr::multiplicative_generator = bls12_377_Fr("22");
     bls12_377_Fr::root_of_unity =
         bls12_377_Fr("806515965671681287737496751840327346652143269366181061997"
                      "9959746626482506078");
     bls12_377_Fr::nqr = bls12_377_Fr("11");
     bls12_377_Fr::nqr_to_t =
         bls12_377_Fr("692488678884788206012306650822351907723216075069845241107"
                      "1850219367055984476");
     bls12_377_Fr::static_init();
  
     // Parameters for base field Fq
     // q =
     // 0x1ae3a4617c510eac63b05c06ca1493b1a22d9f300f5138f1ef3622fba094800170b5d44300000008508c00000000001
     // sage:
     // mod(0x1ae3a4617c510eac63b05c06ca1493b1a22d9f300f5138f1ef3622fba094800170b5d44300000008508c00000000001,
     // 6) # = 1
     bls12_377_modulus_q =
         bigint_q("2586644260129690940106527336948935335363935127549146605398842"
                  "62666720468348340822774968888139573360124440321458177");
     assert(bls12_377_Fq::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         bls12_377_Fq::Rsquared = bigint_q(
             "661274283768726978163325701168662324052305289846649183196063154202"
             "33909940404532140033099444330447428417853902114");
         bls12_377_Fq::Rcubed = bigint_q(
             "157734475176213061358192738313701451942220138363611391489992831740"
             "412033225490229541667992423878570205050777755168");
         bls12_377_Fq::inv = 0x8508bfffffffffff;
     }
     if (sizeof(mp_limb_t) == 4) {
         bls12_377_Fq::Rsquared = bigint_q(
             "661274283768726978163325701168662324052305289846649183196063154202"
             "33909940404532140033099444330447428417853902114");
         bls12_377_Fq::Rcubed = bigint_q(
             "157734475176213061358192738313701451942220138363611391489992831740"
             "412033225490229541667992423878570205050777755168");
         bls12_377_Fq::inv = 0xffffffff;
     }
  
     bls12_377_Fq::num_bits = 377;
     bls12_377_Fq::euler =
         bigint_q("1293322130064845470053263668474467667681967563774573302699421"
                  "31333360234174170411387484444069786680062220160729088");
     bls12_377_Fq::s = 46;
     bls12_377_Fq::t =
         bigint_q("3675842578061421676390135839012792950148785745837396071634149"
                  "488243117337281387659330802195819009059");
     bls12_377_Fq::t_minus_1_over_2 =
         bigint_q("1837921289030710838195067919506396475074392872918698035817074"
                  "744121558668640693829665401097909504529");
     bls12_377_Fq::multiplicative_generator = bls12_377_Fq("15");
     bls12_377_Fq::root_of_unity = bls12_377_Fq(
         "3286357854725450502960126193986832566977050893937512246290474576635225"
         "6812585773382134936404344547323199885654433");
     // We need to find a qnr (small preferably) in order to compute square roots
     // in the field
     bls12_377_Fq::nqr = bls12_377_Fq("5");
     bls12_377_Fq::nqr_to_t = bls12_377_Fq(
         "3377495600822765621977587665628813354707861049382861377725882934574055"
         "6592044969439504850374928261397247202212840");
     bls12_377_Fq::static_init();
  
     // Parameters for twist field Fq2
     bls12_377_Fq2::euler = bigint<2 * bls12_377_q_limbs>(
         "3345364264230938125808962594624906928800576001088647925307095745329795"
         "7116339370141113413635838485065209570299254148838549585056123015878375"
         "0227249980418287852270900634666582330594333230337725133219903165601670"
         "27213559780081664");
     bls12_377_Fq2::s = 47;
     bls12_377_Fq2::t = bigint<2 * bls12_377_q_limbs>(
         "4754048552841450893153254632217264839938161459668674418291936583116517"
         "6127142572882339399080590404004751647874022280630227875599477749628896"
         "1383541476974255391881599499962735436887347234371823579436839914935817"
         "251");
     bls12_377_Fq2::t_minus_1_over_2 = bigint<2 * bls12_377_q_limbs>(
         "2377024276420725446576627316108632419969080729834337209145968291558258"
         "8063571286441169699540295202002375823937011140315113937799738874814448"
         "0691770738487127695940799749981367718443673617185911789718419957467908"
         "625");
     // https://github.com/scipr-lab/zexe/blob/6bfe574f7adea14b97ff554bbb594988635b1908/algebra/src/bls12_377/fields/fq2.rs#L11
     // Additive inverse of 5 in GF(q)
     // sage: GF(q)(-5)
     // Fp2 = Fp[X] / (X^2 - (-5)))
     bls12_377_Fq2::non_residue = bls12_377_Fq(
         "2586644260129690940106527336948935335363935127549146605398842626667204"
         "68348340822774968888139573360124440321458172");
     bls12_377_Fq2::nqr = bls12_377_Fq2(bls12_377_Fq("0"), bls12_377_Fq("1"));
     bls12_377_Fq2::nqr_to_t = bls12_377_Fq2(
         bls12_377_Fq("0"),
         bls12_377_Fq(
             "257286236321774568987262729980034669694531728092793737444525294935"
             "421142460394028155736019924956637466133519652786"));
     bls12_377_Fq2::Frobenius_coeffs_c1[0] = bls12_377_Fq("1");
     bls12_377_Fq2::Frobenius_coeffs_c1[1] = bls12_377_Fq(
         "2586644260129690940106527336948935335363935127549146605398842626667204"
         "68348340822774968888139573360124440321458176");
     bls12_377_Fq2::static_init();
  
     // Parameters for Fq6 = (Fq2)^3
     bls12_377_Fq6::non_residue =
         bls12_377_Fq2(bls12_377_Fq("0"), bls12_377_Fq("1"));
     bls12_377_Fq6::Frobenius_coeffs_c1[0] =
         bls12_377_Fq2(bls12_377_Fq("1"), bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c1[1] = bls12_377_Fq2(
         bls12_377_Fq("809496482649127194085583631406374772648452947207104994781"
                      "37287262712535938301461879813459410946"),
         bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c1[2] = bls12_377_Fq2(
         bls12_377_Fq("809496482649127194085583631406374772648452947207104994781"
                      "37287262712535938301461879813459410945"),
         bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c1[3] = bls12_377_Fq2(
         bls12_377_Fq(
             "258664426012969094010652733694893533536393512754914660539884262666"
             "720468348340822774968888139573360124440321458176"),
         bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c1[4] = bls12_377_Fq2(
         bls12_377_Fq(
             "258664426012969093929703085429980814127835149614277183275038967946"
             "009968870203535512256352201271898244626862047231"),
         bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c1[5] = bls12_377_Fq2(
         bls12_377_Fq(
             "258664426012969093929703085429980814127835149614277183275038967946"
             "009968870203535512256352201271898244626862047232"),
         bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c2[0] =
         bls12_377_Fq2(bls12_377_Fq("1"), bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c2[1] = bls12_377_Fq2(
         bls12_377_Fq("809496482649127194085583631406374772648452947207104994781"
                      "37287262712535938301461879813459410945"),
         bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c2[2] = bls12_377_Fq2(
         bls12_377_Fq(
             "258664426012969093929703085429980814127835149614277183275038967946"
             "009968870203535512256352201271898244626862047231"),
         bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c2[3] =
         bls12_377_Fq2(bls12_377_Fq("1"), bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c2[4] = bls12_377_Fq2(
         bls12_377_Fq("809496482649127194085583631406374772648452947207104994781"
                      "37287262712535938301461879813459410945"),
         bls12_377_Fq("0"));
     bls12_377_Fq6::Frobenius_coeffs_c2[5] = bls12_377_Fq2(
         bls12_377_Fq(
             "258664426012969093929703085429980814127835149614277183275038967946"
             "009968870203535512256352201271898244626862047231"),
         bls12_377_Fq("0"));
  
     // Parameters for Fq12 = ((Fq2)^3)^2
     bls12_377_Fq12::non_residue =
         bls12_377_Fq2(bls12_377_Fq("0"), bls12_377_Fq("1"));
     bls12_377_Fq12::Frobenius_coeffs_c1[0] =
         bls12_377_Fq2(bls12_377_Fq("1"), bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[1] = bls12_377_Fq2(
         bls12_377_Fq(
             "929493452202778647586249605064731826779530489092832489809601043817"
             "95901929519566951595905490535835115111760994353"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[2] = bls12_377_Fq2(
         bls12_377_Fq("809496482649127194085583631406374772648452947207104994781"
                      "37287262712535938301461879813459410946"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[3] = bls12_377_Fq2(
         bls12_377_Fq(
             "216465761340224619389371505802605247630151569547285782856803747159"
             "100223055385581585702401816380679166954762214499"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[4] = bls12_377_Fq2(
         bls12_377_Fq("809496482649127194085583631406374772648452947207104994781"
                      "37287262712535938301461879813459410945"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[5] = bls12_377_Fq2(
         bls12_377_Fq(
             "123516416119946754630746545296132064952198520638002533875843642777"
             "304321125866014634106496325844844051843001220146"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[6] = bls12_377_Fq2(
         bls12_377_Fq(
             "258664426012969094010652733694893533536393512754914660539884262666"
             "720468348340822774968888139573360124440321458176"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[7] = bls12_377_Fq2(
         bls12_377_Fq(
             "165715080792691229252027773188420350858440463845631411558924158284"
             "924566418821255823372982649037525009328560463824"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[8] = bls12_377_Fq2(
         bls12_377_Fq(
             "258664426012969093929703085429980814127835149614277183275038967946"
             "009968870203535512256352201271898244626862047231"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[9] = bls12_377_Fq2(
         bls12_377_Fq(
             "421986646727444746212812278922882859062419432076288776830805155076"
             "20245292955241189266486323192680957485559243678"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[10] = bls12_377_Fq2(
         bls12_377_Fq(
             "258664426012969093929703085429980814127835149614277183275038967946"
             "009968870203535512256352201271898244626862047232"),
         bls12_377_Fq("0"));
     bls12_377_Fq12::Frobenius_coeffs_c1[11] = bls12_377_Fq2(
         bls12_377_Fq(
             "135148009893022339379906188398761468584194992116912126664040619889"
             "416147222474808140862391813728516072597320238031"),
         bls12_377_Fq("0"));
  
     // Choice of short Weierstrass curve and its twist
     // E(Fq): y^2 = x^3 + 1
     bls12_377_coeff_b = bls12_377_Fq("1");
     // We use a type-D twist here, E'(Fq2): y^2 = x^3 + 1/u
     bls12_377_twist = bls12_377_Fq2(bls12_377_Fq("0"), bls12_377_Fq("1"));
     bls12_377_twist_coeff_b = bls12_377_coeff_b * bls12_377_twist.inverse();
  
     bls12_377_twist_mul_by_b_c0 =
         bls12_377_coeff_b * bls12_377_Fq2::non_residue;
     bls12_377_twist_mul_by_b_c1 =
         bls12_377_coeff_b * bls12_377_Fq2::non_residue;
     bls12_377_twist_mul_by_q_X = bls12_377_Fq2(
         bls12_377_Fq("809496482649127194085583631406374772648452947207104994781"
                      "37287262712535938301461879813459410946"),
         bls12_377_Fq("0"));
     bls12_377_twist_mul_by_q_Y = bls12_377_Fq2(
         bls12_377_Fq(
             "216465761340224619389371505802605247630151569547285782856803747159"
             "100223055385581585702401816380679166954762214499"),
         bls12_377_Fq("0"));
  
     // Choice of group G1
     // Identities
     bls12_377_G1::G1_zero = bls12_377_G1(
         bls12_377_Fq::zero(), bls12_377_Fq::one(), bls12_377_Fq::zero());
     bls12_377_G1::G1_one = bls12_377_G1(
         bls12_377_Fq(
             "819379993731509642399382555734659482399886715026479765942196956448"
             "55304257327692006745978603320413799295628339695"),
         bls12_377_Fq(
             "241266749859715473739788878240585681733927191168601896383759122102"
             "112907357779751001206799952863815012735208165030"),
         bls12_377_Fq::one());
  
     // Curve coeffs
     bls12_377_G1::coeff_a = bls12_377_Fq::zero();
     bls12_377_G1::coeff_b = bls12_377_coeff_b;
  
     // Trace of Frobenius
     bls12_377_trace_of_frobenius = bigint_r("9586122913090633730");
  
     // Cofactor
     bls12_377_G1::h =
         bigint<bls12_377_G1::h_limbs>("30631250834960419227450344600217059328");
  
     // G1 fast subgroup check:  0 == [c0]P + [c1]sigma(P)
     bls12_377_g1_endomorphism_beta =
         bls12_377_Fq("809496482649127194085583631406374772648452947207104994781"
                      "37287262712535938301461879813459410945");
     bls12_377_g1_safe_subgroup_check_c1 =
         bigint_r("91893752504881257701523279626832445441");
  
     // G1 proof of subgroup: values used to generate x' s.t. [r]x' = x.
     bls12_377_g1_proof_of_safe_subgroup_w =
         bigint_r("5285428838741532253824584287042945485047145357130994810877");
     bls12_377_g1_proof_of_safe_subgroup_non_member_x = bls12_377_Fq(
         "5579135224678387240478846790990709250936401022990388020368969649878761"
         "5734938123558571181995209025075818229621722");
     bls12_377_g1_proof_of_safe_subgroup_non_member_y = bls12_377_Fq(
         "1743638558335201382296667234848353486892365850134605544446097301206037"
         "41818916846216286948728983932214174344518655");
  
     // WNAF
     //
     // Note to self (AntoineR): Careful with wNAF as it can lead to SCAs:
     // https://eprint.iacr.org/2019/861.pdf Note to self (AntoineR): The GLV
     // patent (https://patents.google.com/patent/US7110538B2/en) expires in
     // 09/2020. As such, efficient techniques for scalar mult. described in
     // https://cryptosith.org/papers/exppair-20130904.pdf can become of interest
     // then.
     //
     // Below we use the same `wnaf_window_table` as used for other curves
     // TODO: Adjust the `wnaf_window_table` and `fixed_base_exp_window_table`
     bls12_377_G1::wnaf_window_table.resize(0);
     bls12_377_G1::wnaf_window_table.push_back(11);
     bls12_377_G1::wnaf_window_table.push_back(24);
     bls12_377_G1::wnaf_window_table.push_back(60);
     bls12_377_G1::wnaf_window_table.push_back(127);
  
     // Below we use the same `fixed_base_exp_window_table` as used for other
     // curves
     bls12_377_G1::fixed_base_exp_window_table.resize(0);
     // window 1 is unbeaten in [-inf, 4.99]
     bls12_377_G1::fixed_base_exp_window_table.push_back(1);
     // window 2 is unbeaten in [4.99, 10.99]
     bls12_377_G1::fixed_base_exp_window_table.push_back(5);
     // window 3 is unbeaten in [10.99, 32.29]
     bls12_377_G1::fixed_base_exp_window_table.push_back(11);
     // window 4 is unbeaten in [32.29, 55.23]
     bls12_377_G1::fixed_base_exp_window_table.push_back(32);
     // window 5 is unbeaten in [55.23, 162.03]
     bls12_377_G1::fixed_base_exp_window_table.push_back(55);
     // window 6 is unbeaten in [162.03, 360.15]
     bls12_377_G1::fixed_base_exp_window_table.push_back(162);
     // window 7 is unbeaten in [360.15, 815.44]
     bls12_377_G1::fixed_base_exp_window_table.push_back(360);
     // window 8 is unbeaten in [815.44, 2373.07]
     bls12_377_G1::fixed_base_exp_window_table.push_back(815);
     // window 9 is unbeaten in [2373.07, 6977.75]
     bls12_377_G1::fixed_base_exp_window_table.push_back(2373);
     // window 10 is unbeaten in [6977.75, 7122.23]
     bls12_377_G1::fixed_base_exp_window_table.push_back(6978);
     // window 11 is unbeaten in [7122.23, 57818.46]
     bls12_377_G1::fixed_base_exp_window_table.push_back(7122);
     // window 12 is never the best
     bls12_377_G1::fixed_base_exp_window_table.push_back(0);
     // window 13 is unbeaten in [57818.46, 169679.14]
     bls12_377_G1::fixed_base_exp_window_table.push_back(57818);
     // window 14 is never the best
     bls12_377_G1::fixed_base_exp_window_table.push_back(0);
     // window 15 is unbeaten in [169679.14, 439758.91]
     bls12_377_G1::fixed_base_exp_window_table.push_back(169679);
     // window 16 is unbeaten in [439758.91, 936073.41]
     bls12_377_G1::fixed_base_exp_window_table.push_back(439759);
     // window 17 is unbeaten in [936073.41, 4666554.74]
     bls12_377_G1::fixed_base_exp_window_table.push_back(936073);
     // window 18 is never the best
     bls12_377_G1::fixed_base_exp_window_table.push_back(0);
     // window 19 is unbeaten in [4666554.74, 7580404.42]
     bls12_377_G1::fixed_base_exp_window_table.push_back(4666555);
     // window 20 is unbeaten in [7580404.42, 34552892.20]
     bls12_377_G1::fixed_base_exp_window_table.push_back(7580404);
     // window 21 is never the best
     bls12_377_G1::fixed_base_exp_window_table.push_back(0);
     // window 22 is unbeaten in [34552892.20, inf]
     bls12_377_G1::fixed_base_exp_window_table.push_back(34552892);
  
     // Choice of group G2
     // Identities
     bls12_377_G2::G2_zero = bls12_377_G2(
         bls12_377_Fq2::zero(), bls12_377_Fq2::one(), bls12_377_Fq2::zero());
     bls12_377_G2::G2_one = bls12_377_G2(
         bls12_377_Fq2(
             bls12_377_Fq(
                 "11158394577469511644391122625782382343446874024988304283774515"
                 "1039122196680777376765707574547389190084887628324746"),
             bls12_377_Fq(
                 "12906698065670308551815730115433521588608211252437868655587316"
                 "1080604845924984124025594590925548060469686767592854")),
         bls12_377_Fq2(
             bls12_377_Fq(
                 "16886329972466897718302994134759646260897838050396510334100391"
                 "8678547611204475537878680436662916294540335494194722"),
             bls12_377_Fq(
                 "23389249728747576225133535189361842960367292146986439276751455"
                 "2093535653615809913098097380147379993375817193725968")),
         bls12_377_Fq2::one());
  
     // Curve twist coeffs
     bls12_377_G2::coeff_a = bls12_377_Fq2::zero();
     bls12_377_G2::coeff_b = bls12_377_twist_coeff_b;
  
     // Cofactor
     bls12_377_G2::h = bigint<bls12_377_G2::h_limbs>(
         "7923214915284317143930293550643874566881017850177945424769256759165301"
         "4366169332282092779667740924864672894786184047614126306918357646745593"
         "76407658497");
  
     // Untwist-Frobenius-Twist coefficients
     bls12_377_Fq12 untwist_frobenius_twist_w =
         bls12_377_Fq12(bls12_377_Fq6::zero(), bls12_377_Fq6::one());
     bls12_377_g2_untwist_frobenius_twist_v =
         untwist_frobenius_twist_w * untwist_frobenius_twist_w;
     bls12_377_g2_untwist_frobenius_twist_w_3 =
         untwist_frobenius_twist_w * bls12_377_g2_untwist_frobenius_twist_v;
     bls12_377_g2_untwist_frobenius_twist_v_inverse =
         bls12_377_g2_untwist_frobenius_twist_v.inverse();
     bls12_377_g2_untwist_frobenius_twist_w_3_inverse =
         bls12_377_g2_untwist_frobenius_twist_w_3.inverse();
  
     // Fast cofactor multiplication coefficients
     bls12_377_g2_mul_by_cofactor_h2_0 =
         bigint_r("293634935485640680722085584138834120318524213360527933441");
     bls12_377_g2_mul_by_cofactor_h2_1 =
         bigint_r("30631250834960419227450344600217059328");
  
     // G2 wNAF window table
     bls12_377_G2::wnaf_window_table.resize(0);
     bls12_377_G2::wnaf_window_table.push_back(5);
     bls12_377_G2::wnaf_window_table.push_back(15);
     bls12_377_G2::wnaf_window_table.push_back(39);
     bls12_377_G2::wnaf_window_table.push_back(109);
  
     // G2 fixed-base exponentiation table
     bls12_377_G2::fixed_base_exp_window_table.resize(0);
     // window 1 is unbeaten in [-inf, 5.10]
     bls12_377_G2::fixed_base_exp_window_table.push_back(1);
     // window 2 is unbeaten in [5.10, 10.43]
     bls12_377_G2::fixed_base_exp_window_table.push_back(5);
     // window 3 is unbeaten in [10.43, 25.28]
     bls12_377_G2::fixed_base_exp_window_table.push_back(10);
     // window 4 is unbeaten in [25.28, 59.00]
     bls12_377_G2::fixed_base_exp_window_table.push_back(25);
     // window 5 is unbeaten in [59.00, 154.03]
     bls12_377_G2::fixed_base_exp_window_table.push_back(59);
     // window 6 is unbeaten in [154.03, 334.25]
     bls12_377_G2::fixed_base_exp_window_table.push_back(154);
     // window 7 is unbeaten in [334.25, 742.58]
     bls12_377_G2::fixed_base_exp_window_table.push_back(334);
     // window 8 is unbeaten in [742.58, 2034.40]
     bls12_377_G2::fixed_base_exp_window_table.push_back(743);
     // window 9 is unbeaten in [2034.40, 4987.56]
     bls12_377_G2::fixed_base_exp_window_table.push_back(2034);
     // window 10 is unbeaten in [4987.56, 8888.27]
     bls12_377_G2::fixed_base_exp_window_table.push_back(4988);
     // window 11 is unbeaten in [8888.27, 26271.13]
     bls12_377_G2::fixed_base_exp_window_table.push_back(8888);
     // window 12 is unbeaten in [26271.13, 39768.20]
     bls12_377_G2::fixed_base_exp_window_table.push_back(26271);
     // window 13 is unbeaten in [39768.20, 106275.75]
     bls12_377_G2::fixed_base_exp_window_table.push_back(39768);
     // window 14 is unbeaten in [106275.75, 141703.40]
     bls12_377_G2::fixed_base_exp_window_table.push_back(106276);
     // window 15 is unbeaten in [141703.40, 462422.97]
     bls12_377_G2::fixed_base_exp_window_table.push_back(141703);
     // window 16 is unbeaten in [462422.97, 926871.84]
     bls12_377_G2::fixed_base_exp_window_table.push_back(462423);
     // window 17 is unbeaten in [926871.84, 4873049.17]
     bls12_377_G2::fixed_base_exp_window_table.push_back(926872);
     // window 18 is never the best
     bls12_377_G2::fixed_base_exp_window_table.push_back(0);
     // window 19 is unbeaten in [4873049.17, 5706707.88]
     bls12_377_G2::fixed_base_exp_window_table.push_back(4873049);
     // window 20 is unbeaten in [5706707.88, 31673814.95]
     bls12_377_G2::fixed_base_exp_window_table.push_back(5706708);
     // window 21 is never the best
     bls12_377_G2::fixed_base_exp_window_table.push_back(0);
     // window 22 is unbeaten in [31673814.95, inf]
     bls12_377_G2::fixed_base_exp_window_table.push_back(31673815);
  
     // Pairing parameters
     // sage: u = 9586122913090633729
     // sage: ceil(log(u, 2)) # = 64
     // sage: bin(u) # =
     //   '0b1000010100001000110000000000000000000000000000000000000000000001'
     // The Hamming weight of u is: HW(u) = 7, where
     //   u = 2**63 + 2**58 + 2**56 + 2**51 + 2**47 + 2**46 + 1
     // Based on the power-2 decomposition of u, we should have 63 doubling
     // steps and 7 addition steps in the Miller Loop.
     bls12_377_ate_loop_count = bigint_q("9586122913090633729");
     bls12_377_ate_is_loop_count_neg = false;
     // k (embedding degree) = 12
     // bls12_377_final_exponent = (q^12 - 1) / r
     bls12_377_final_exponent = bigint<12 * bls12_377_q_limbs>(
         "1062352101801986048825403166370756842879803290512381119957121396507912"
         "9114663661236359849629341526275899063345613340067081670062620727617884"
         "1374877547391501474912045595142051864923855902722089344674614449446527"
         "1100516937116825006879082077612477209563023710218982773301998983506333"
         "4551453893534663070786533932633573962932272563471643288531959637300817"
         "0702655374295064848809909810690412694053835028896773570820128072985299"
         "3111812442856905982234628974507740157013415744497327152098177404714691"
         "8354408632568723153146248333028827919406785654402107153546667815607201"
         "4885908324782254034441364093498774812681548179045413406141732619497724"
         "0306092432436686172324518261985938925498500823600746581427336149713413"
         "8868945580557938161335670207544906643574043606819537336472235809927599"
         "6281232753142880061708040445602386764639316393397119131110809745825932"
         "2813870415432059977568309560404130900019702541996812571801831180595931"
         "5220036948621879242495199408833915486421612374480018459896018440926235"
         "2618246549569323848592604793727760229797367342216290972978901546921944"
         "4152846277021881179562447110897237757369083391323126054783555085125681"
         "7740247389770320334698430697237343583761719223414894063451411431859122"
         "7384883115800054127650702518101599918971109363249432325268702807248769"
         "46523218213525646968094720");
     bls12_377_final_exponent_z = bigint_q("9586122913090633729");
     bls12_377_final_exponent_is_z_neg = false;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ init_bls12_381_params()

void libff::init_bls12_381_params ( )

Definition at line 26 of file bls12_381_init.cpp.

 {
     typedef bigint<bls12_381_r_limbs> bigint_r;
     typedef bigint<bls12_381_q_limbs> bigint_q;
  
     // Montgomery assumes this
     assert(sizeof(mp_limb_t) == 8 || sizeof(mp_limb_t) == 4);
  
     /* parameters for scalar field Fr */
  
     bls12_381_modulus_r = bigint_r("5243587517512619047944774050818596583769055"
                                    "2500527637822603658699938581184513");
     assert(bls12_381_Fr::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         bls12_381_Fr::Rsquared =
             bigint_r("329490647479426544212979752063071073927857568219980068178"
                      "8903916070560242797");
         bls12_381_Fr::Rcubed =
             bigint_r("498292539885403193545507422492760844601274463553159150895"
                      "27227471280320770991");
         bls12_381_Fr::inv = 0xfffffffeffffffff; // (-1/modulus) mod W
     }
     if (sizeof(mp_limb_t) == 4) {
         bls12_381_Fr::Rsquared =
             bigint_r("329490647479426544212979752063071073927857568219980068178"
                      "8903916070560242797");
         bls12_381_Fr::Rcubed =
             bigint_r("498292539885403193545507422492760844601274463553159150895"
                      "27227471280320770991");
         bls12_381_Fr::inv = 0xffffffff;
     }
     bls12_381_Fr::num_bits = 255;
     bls12_381_Fr::euler = bigint_r("2621793758756309523972387025409298291884527"
                                    "6250263818911301829349969290592256");
     bls12_381_Fr::s = 32;
     bls12_381_Fr::t = bigint_r(
         "12208678567578594777604504606729831043093128246378069236549469339647");
     bls12_381_Fr::t_minus_1_over_2 = bigint_r(
         "6104339283789297388802252303364915521546564123189034618274734669823");
     bls12_381_Fr::multiplicative_generator = bls12_381_Fr("7");
     bls12_381_Fr::root_of_unity =
         bls12_381_Fr("102382273577394958236510305758492320625588601802844775411"
                      "89508159991286009131");
     bls12_381_Fr::nqr = bls12_381_Fr("5");
     bls12_381_Fr::nqr_to_t =
         bls12_381_Fr("937917089079007706106976984802249742464848817460758522850"
                      "752807661925904159");
     bls12_381_Fr::static_init();
  
     /* parameters for base field Fq */
     bls12_381_modulus_q =
         bigint_q("4002409555221667393417789825735904156556882819939007885332058"
                  "136124031650490837864442687629129015664037894272559787");
     assert(bls12_381_Fq::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         bls12_381_Fq::Rsquared = bigint_q(
             "270826391065473017479378762632817651183645519716631767700615429398"
             "2164122222515399004018013397331347120527951271750"); // k=6
         bls12_381_Fq::Rcubed = bigint_q(
             "163906754277462589423671657554808490593875383721159409588363701458"
             "2201460755008380976950835174037649440777609978336");
  
         bls12_381_Fq::inv = 0x89f3fffcfffcfffd;
     }
     if (sizeof(mp_limb_t) == 4) {
         bls12_381_Fq::Rsquared = bigint_q(
             "270826391065473017479378762632817651183645519716631767700615429398"
             "2164122222515399004018013397331347120527951271750");
         bls12_381_Fq::Rcubed = bigint_q(
             "163906754277462589423671657554808490593875383721159409588363701458"
             "2201460755008380976950835174037649440777609978336");
         bls12_381_Fq::inv = 0xfffcfffd;
     }
     bls12_381_Fq::num_bits = 381;
     bls12_381_Fq::euler =
         bigint_q("2001204777610833696708894912867952078278441409969503942666029"
                  "068062015825245418932221343814564507832018947136279893");
     bls12_381_Fq::s = 1;
     bls12_381_Fq::t =
         bigint_q("2001204777610833696708894912867952078278441409969503942666029"
                  "068062015825245418932221343814564507832018947136279893");
     bls12_381_Fq::t_minus_1_over_2 =
         bigint_q("1000602388805416848354447456433976039139220704984751971333014"
                  "534031007912622709466110671907282253916009473568139946");
     bls12_381_Fq::multiplicative_generator = bls12_381_Fq("2");
     bls12_381_Fq::root_of_unity = bls12_381_Fq(
         "4002409555221667393417789825735904156556882819939007885332058136124031"
         "650490837864442687629129015664037894272559786");
     bls12_381_Fq::nqr = bls12_381_Fq("2");
     bls12_381_Fq::nqr_to_t = bls12_381_Fq(
         "4002409555221667393417789825735904156556882819939007885332058136124031"
         "650490837864442687629129015664037894272559786");
     bls12_381_Fq::static_init();
  
     /* parameters for twist field Fq2 */
     bls12_381_Fq2::euler = bigint<2 * bls12_381_q_limbs>(
         "8009641123864852705971874322159486308847560049665276329931192268492988"
         "3742456785717003280396510967149874771927700853652655519422698534529681"
         "0010121051821790554650651713590637900820398474816583070927051183888744"
         "9985712996744742684");
     bls12_381_Fq2::s = 3;
     bls12_381_Fq2::t = bigint<2 * bls12_381_q_limbs>(
         "2002410280966213176492968580539871577211890012416319082482798067123247"
         "0935614196429250820099127741787468692981925213413163879855674633632420"
         "2502530262955447638662662928397659475205099618704145767731762795972186"
         "2496428249186185671");
     bls12_381_Fq2::t_minus_1_over_2 = bigint<2 * bls12_381_q_limbs>(
         "1001205140483106588246484290269935788605945006208159541241399033561623"
         "5467807098214625410049563870893734346490962606706581939927837316816210"
         "1251265131477723819331331464198829737602549809352072883865881397986093"
         "1248214124593092835");
     bls12_381_Fq2::non_residue = bls12_381_Fq(
         "4002409555221667393417789825735904156556882819939007885332058136124031"
         "650490837864442687629129015664037894272559786");
     bls12_381_Fq2::nqr =
         bls12_381_Fq2(bls12_381_Fq("1"), bls12_381_Fq("1")); // u+1
     bls12_381_Fq2::nqr_to_t = bls12_381_Fq2(
         bls12_381_Fq(
             "102873214623510634997532447921579527738483993692975789615564311803"
             "2610843298655225875571310552543014690878354869257"),
         bls12_381_Fq(
             "297367740898656104344246534652010887917204288300924998917641501809"
             "1420807192182638567116318576472649347015917690530"));
     bls12_381_Fq2::Frobenius_coeffs_c1[0] = bls12_381_Fq("1");
     bls12_381_Fq2::Frobenius_coeffs_c1[1] = bls12_381_Fq(
         "4002409555221667393417789825735904156556882819939007885332058136124031"
         "650490837864442687629129015664037894272559786");
     bls12_381_Fq2::static_init();
  
     /* parameters for Fq6 */
  
     bls12_381_Fq6::euler = bigint<6 * bls12_381_q_limbs>(
         "2055413310034685917547178203792332860309200402936847589812920000288065"
         "0925292078031236336437155417867098264344518387365893430771451315477306"
         "7723923870911995741881272581302001907244790574962263945847542833396860"
         "73743682966778056496"
         "2327945395707855461784923849488018385374868097169740055671857527378364"
         "8469851242261268044817816320342666827076722752447529192782544353128746"
         "1471193084577848300836833318729082346882823602164341569076593462295099"
         "0371613607731757827"
         "4075669149520898024347473697702653612215721050521068924301068068177428"
         "7151859717713146107915044671570816889418683602912643322766216203471482"
         "2884004062053629214182533388992931530312083763262100940571236423950189"
         "3128509197213249204");
     bls12_381_Fq6::s = 3;
     bls12_381_Fq6::t = bigint<6 * bls12_381_q_limbs>(
         "5138533275086714793867945509480832150773001007342118974532300000720162"
         "7313230195078090841092888544667745660861295968414733576928628288693266"
         "9309809677279989354703181453255004768111976437405659864618857083492151"
         "8435920741694514124"
         "0581986348926963865446230962372004596343717024292435013917964381844591"
         "2117462810565317011204454080085666706769180688111882298195636088282186"
         "5367798271144462075209208329682270586720705900541085392269148365573774"
         "7592903401932939456"
         "8518917287380224506086868424425663403053930262630267231075267017044357"
         "1787964929428286526978761167892704222354670900728160830691554050867870"
         "5721001015513407303545633347248232882578020940815525235142809105987547"
         "3282127299303312301");
     bls12_381_Fq6::t_minus_1_over_2 = bigint<6 * bls12_381_q_limbs>(
         "2569266637543357396933972754740416075386500503671059487266150000360081"
         "3656615097539045420546444272333872830430647984207366788464314144346633"
         "4654904838639994677351590726627502384055988218702829932309428541746075"
         "9217960370847257062"
         "0290993174463481932723115481186002298171858512146217506958982190922295"
         "6058731405282658505602227040042833353384590344055941149097818044141093"
         "2683899135572231037604604164841135293360352950270542696134574182786887"
         "3796451700966469728"
         "4259458643690112253043434212212831701526965131315133615537633508522178"
         "5893982464714143263489380583946352111177335450364080415345777025433935"
         "2860500507756703651772816673624116441289010470407762617571404552993773"
         "6641063649651656150");
     bls12_381_Fq6::non_residue =
         bls12_381_Fq2(bls12_381_Fq("1"), bls12_381_Fq("1"));
     bls12_381_Fq6::nqr = bls12_381_Fq6(
         bls12_381_Fq2::one(), bls12_381_Fq2::one(), bls12_381_Fq2::zero());
     bls12_381_Fq temp_Fq6 = bls12_381_Fq(
         "2973677408986561043442465346520108879172042883009249989176415018091420"
         "807192182638567116318576472649347015917690530");
     bls12_381_Fq6::nqr_to_t = bls12_381_Fq6(
         bls12_381_Fq2(temp_Fq6, temp_Fq6),
         bls12_381_Fq2::zero(),
         bls12_381_Fq2::zero());
     bls12_381_Fq6::Frobenius_coeffs_c1[0] =
         bls12_381_Fq2(bls12_381_Fq("1"), bls12_381_Fq("0"));
     bls12_381_Fq6::Frobenius_coeffs_c1[1] = bls12_381_Fq2(
         bls12_381_Fq("0"),
         bls12_381_Fq(
             "400240955522166739262431043500668864393550311830558643827117139584"
             "2971157480381377015405980053539358417135540939436"));
     bls12_381_Fq6::Frobenius_coeffs_c1[2] = bls12_381_Fq2(
         bls12_381_Fq("793479390729215512621379701633421447060886740281060493010"
                      "456487427281649075476305620758731620350"),
         bls12_381_Fq("0"));
     bls12_381_Fq6::Frobenius_coeffs_c1[3] =
         bls12_381_Fq2(bls12_381_Fq("0"), bls12_381_Fq("1"));
     bls12_381_Fq6::Frobenius_coeffs_c1[4] = bls12_381_Fq2(
         bls12_381_Fq(
             "400240955522166739262431043500668864393550311830558643827117139584"
             "2971157480381377015405980053539358417135540939436"),
         bls12_381_Fq("0"));
     bls12_381_Fq6::Frobenius_coeffs_c1[5] = bls12_381_Fq2(
         bls12_381_Fq("0"),
         bls12_381_Fq("793479390729215512621379701633421447060886740281060493010"
                      "456487427281649075476305620758731620350"));
     bls12_381_Fq6::Frobenius_coeffs_c2[0] =
         bls12_381_Fq2(bls12_381_Fq("1"), bls12_381_Fq("0"));
     bls12_381_Fq6::Frobenius_coeffs_c2[1] = bls12_381_Fq2(
         bls12_381_Fq(
             "400240955522166739262431043500668864393550311830558643827117139584"
             "2971157480381377015405980053539358417135540939437"),
         bls12_381_Fq("0"));
     bls12_381_Fq6::Frobenius_coeffs_c2[2] = bls12_381_Fq2(
         bls12_381_Fq(
             "400240955522166739262431043500668864393550311830558643827117139584"
             "2971157480381377015405980053539358417135540939436"),
         bls12_381_Fq("0"));
     bls12_381_Fq6::Frobenius_coeffs_c2[3] = bls12_381_Fq2(
         bls12_381_Fq(
             "400240955522166739341778982573590415655688281993900788533205813612"
             "4031650490837864442687629129015664037894272559786"),
         bls12_381_Fq("0"));
     bls12_381_Fq6::Frobenius_coeffs_c2[4] = bls12_381_Fq2(
         bls12_381_Fq("793479390729215512621379701633421447060886740281060493010"
                      "456487427281649075476305620758731620350"),
         bls12_381_Fq("0"));
     bls12_381_Fq6::Frobenius_coeffs_c2[5] = bls12_381_Fq2(
         bls12_381_Fq("793479390729215512621379701633421447060886740281060493010"
                      "456487427281649075476305620758731620351"),
         bls12_381_Fq("0"));
  
     /* parameters for Fq12 */
  
     bls12_381_Fq12::euler = bigint<12 * bls12_381_q_limbs>(
         "8449447750135487786386536757818793037762212639342076082205056847631733"
         "7611486762037414270042798116043101246277209976512094361633120467161014"
         "0655544453405655390597288113542772613560509732197200272091941904878386"
         "92659063939320510475"
         "6684686564553744540192748080653129821509884735609423581664936489210967"
         "0440467529068420483514604958227574975684523172972030890413264728910407"
         "5914291222737139398079433126860286068573844453009747181852522430304241"
         "3280382576694575299"
         "4243167774120254336745536274773695755236419654903551716949533916736161"
         "3569172920059467104043034274069321829696761906239463005630083855610676"
         "3024021975665415739763789028633084871968346012196283360672552982454440"
         "6779592032379877481"
         "1619354467715920346231349235866829244117661464414438262378914602649540"
         "0686951521638441608423046735329190594695892803338108752058997137128797"
         "3778883772765769448885014782339635406211030364946185240866112535299846"
         "0333970628572435583"
         "1757875201144654542881444863180645429521461839597984159381168059700378"
         "1998317840382782546961827784098634063653000816109224177006797686172283"
         "6524688010589950951561114449900951002753319232147895757766930045754791"
         "8189673190852298371"
         "5647603567520167155789018111526068121587518840305926270907547770597694"
         "1239754628313695901797410453781873141027101200728931074856266540267317"
         "2430117685618695762741237977291546454709306808974723155022101617076402"
         "8215685592439765640");
     bls12_381_Fq12::s = 4;
     bls12_381_Fq12::t = bigint<12 * bls12_381_q_limbs>(
         "1056180968766935973298317094727349129720276579917759510275632105953966"
         "7201435845254676783755349764505387655784651247064011795204140058395126"
         "7581943056675706923824661014192846576695063716524650034011492738109798"
         "36582382992415063809"
         "4585585820569218067524093510081641227688735591951177947708117061151370"
         "8805058441133552560439325619778446871960565396621503861301658091113800"
         "9489286402842142424759929140857535758571730556626218397731565303788030"
         "1660047822086821912"
         "4280395971765031792093192034346711969404552456862943964618691739592020"
         "1696146615007433388005379284258665228712095238279932875703760481951334"
         "5378002746958176967470473628579135608996043251524535420084069122806805"
         "0847449004047484685"
         "1452419308464490043278918654483353655514707683051804782797364325331192"
         "5085868940204805201052880841916148824336986600417263594007374642141099"
         "6722360471595721181110626847792454425776378795618273155108264066912480"
         "7541746328571554447"
         "8969734400143081817860180607897580678690182729949748019922646007462547"
         "2749789730047847818370228473012329257956625102013653022125849710771535"
         "4565586001323743868945139306237618875344164904018486969720866255719348"
         "9773709148856537296"
         "4455950445940020894473627263940758515198439855038240783863443471324711"
         "7654969328539211987724676306722734142628387650091116384357033317533414"
         "6553764710702336970342654747161443306838663351121840394377762702134550"
         "3526960699054970705");
     bls12_381_Fq12::t_minus_1_over_2 = bigint<12 * bls12_381_q_limbs>(
         "5280904843834679866491585473636745648601382899588797551378160529769833"
         "6007179226273383918776748822526938278923256235320058976020700291975633"
         "7909715283378534619123305070964232883475318582623250170057463690548991"
         "8291191496207531904"
         "7292792910284609033762046755040820613844367795975588973854058530575685"
         "4402529220566776280219662809889223435980282698310751930650829045556900"
         "4744643201421071212379964570428767879285865278313109198865782651894015"
         "0830023911043410956"
         "2140197985882515896046596017173355984702276228431471982309345869796010"
         "0848073307503716694002689642129332614356047619139966437851880240975667"
         "2689001373479088483735236814289567804498021625762267710042034561403402"
         "5423724502023742342"
         "5726209654232245021639459327241676827757353841525902391398682162665596"
         "2542934470102402600526440420958074412168493300208631797003687321070549"
         "8361180235797860590555313423896227212888189397809136577554132033456240"
         "3770873164285777223"
         "9484867200071540908930090303948790339345091364974874009961323003731273"
         "6374894865023923909185114236506164628978312551006826511062924855385767"
         "7282793000661871934472569653118809437672082452009243484860433127859674"
         "4886854574428268648"
         "2227975222970010447236813631970379257599219927519120391931721735662355"
         "8827484664269605993862338153361367071314193825045558192178516658766707"
         "3276882355351168485171327373580721653419331675560920197188881351067275"
         "1763480349527485352");
     bls12_381_Fq12::non_residue =
         bls12_381_Fq2(bls12_381_Fq("1"), bls12_381_Fq("1"));
     bls12_381_Fq12::nqr =
         bls12_381_Fq12(bls12_381_Fq6::zero(), bls12_381_Fq6::one());
     bls12_381_Fq temp_Fq12 = bls12_381_Fq(
         "3357996710086603428986649435961018971596863377125478091385687488711898"
         "724126407611022502097010210262797519903698974");
     bls12_381_Fq12::nqr_to_t = bls12_381_Fq12(
         bls12_381_Fq6::zero(),
         bls12_381_Fq6(
             bls12_381_Fq2::zero(),
             bls12_381_Fq2(temp_Fq12, temp_Fq12),
             bls12_381_Fq2::zero()));
     bls12_381_Fq12::Frobenius_coeffs_c1[0] =
         bls12_381_Fq2(bls12_381_Fq("1"), bls12_381_Fq("0"));
     bls12_381_Fq12::Frobenius_coeffs_c1[1] = bls12_381_Fq2(
         bls12_381_Fq(
             "385075437003716901195214707605136405715880742097068243867605052261"
             "3628423219637725072182697113062777891589506424760"),
         bls12_381_Fq(
             "151655185184498381465642749684540099398075398968325446656007613510"
             "403227271200139370504932015952886146304766135027"));
     bls12_381_Fq12::Frobenius_coeffs_c1[2] = bls12_381_Fq2(
         bls12_381_Fq("793479390729215512621379701633421447060886740281060493010"
                      "456487427281649075476305620758731620351"),
         bls12_381_Fq("0"));
     bls12_381_Fq12::Frobenius_coeffs_c1[3] = bls12_381_Fq2(
         bls12_381_Fq(
             "297367740898656104344246534652010887917204288300924998917641501809"
             "1420807192182638567116318576472649347015917690530"),
         bls12_381_Fq(
             "102873214623510634997532447921579527738483993692975789615564311803"
             "2610843298655225875571310552543014690878354869257"));
     bls12_381_Fq12::Frobenius_coeffs_c1[4] = bls12_381_Fq2(
         bls12_381_Fq("793479390729215512621379701633421447060886740281060493010"
                      "456487427281649075476305620758731620350"),
         bls12_381_Fq("0"));
     bls12_381_Fq12::Frobenius_coeffs_c1[5] = bls12_381_Fq2(
         bls12_381_Fq(
             "312533259417105942490810809620464897857011828197757543583242263160"
             "1824034463382777937621250592425535493320683825557"),
         bls12_381_Fq(
             "877076961050607968509681729531255177986764537961432449499635504522"
             "207616027455086505066378536590128544573588734230"));
     bls12_381_Fq12::Frobenius_coeffs_c1[6] = bls12_381_Fq2(
         bls12_381_Fq(
             "400240955522166739341778982573590415655688281993900788533205813612"
             "4031650490837864442687629129015664037894272559786"),
         bls12_381_Fq("0"));
     bls12_381_Fq12::Frobenius_coeffs_c1[7] = bls12_381_Fq2(
         bls12_381_Fq(
             "151655185184498381465642749684540099398075398968325446656007613510"
             "403227271200139370504932015952886146304766135027"),
         bls12_381_Fq(
             "385075437003716901195214707605136405715880742097068243867605052261"
             "3628423219637725072182697113062777891589506424760"));
     bls12_381_Fq12::Frobenius_coeffs_c1[8] = bls12_381_Fq2(
         bls12_381_Fq(
             "400240955522166739262431043500668864393550311830558643827117139584"
             "2971157480381377015405980053539358417135540939436"),
         bls12_381_Fq("0"));
     bls12_381_Fq12::Frobenius_coeffs_c1[9] = bls12_381_Fq2(
         bls12_381_Fq(
             "102873214623510634997532447921579527738483993692975789615564311803"
             "2610843298655225875571310552543014690878354869257"),
         bls12_381_Fq(
             "297367740898656104344246534652010887917204288300924998917641501809"
             "1420807192182638567116318576472649347015917690530"));
     bls12_381_Fq12::Frobenius_coeffs_c1[10] = bls12_381_Fq2(
         bls12_381_Fq(
             "400240955522166739262431043500668864393550311830558643827117139584"
             "2971157480381377015405980053539358417135540939437"),
         bls12_381_Fq("0"));
     bls12_381_Fq12::Frobenius_coeffs_c1[11] = bls12_381_Fq2(
         bls12_381_Fq(
             "877076961050607968509681729531255177986764537961432449499635504522"
             "207616027455086505066378536590128544573588734230"),
         bls12_381_Fq(
             "312533259417105942490810809620464897857011828197757543583242263160"
             "1824034463382777937621250592425535493320683825557"));
  
     // Choice of short Weierstrass curve and its twist
     // E(Fq): y^2 = x^3 + 4
  
     bls12_381_coeff_b = bls12_381_Fq("4");
     bls12_381_twist = bls12_381_Fq2(bls12_381_Fq("1"), bls12_381_Fq("1"));
     bls12_381_twist_coeff_b = bls12_381_coeff_b * bls12_381_twist;
     bls12_381_twist_mul_by_b_c0 =
         bls12_381_coeff_b * bls12_381_Fq2::non_residue;
     bls12_381_twist_mul_by_b_c1 =
         bls12_381_coeff_b * bls12_381_Fq2::non_residue;
     bls12_381_twist_mul_by_q_X = bls12_381_Fq2(
         bls12_381_Fq("0"),
         bls12_381_Fq(
             "400240955522166739262431043500668864393550311830558643827117139584"
             "2971157480381377015405980053539358417135540939437"));
     bls12_381_twist_mul_by_q_Y = bls12_381_Fq2(
         bls12_381_Fq(
             "297367740898656104344246534652010887917204288300924998917641501809"
             "1420807192182638567116318576472649347015917690530"),
         bls12_381_Fq(
             "102873214623510634997532447921579527738483993692975789615564311803"
             "2610843298655225875571310552543014690878354869257"));
  
     /* choice of group G1 */
     bls12_381_G1::G1_zero = bls12_381_G1(
         bls12_381_Fq::zero(), bls12_381_Fq::one(), bls12_381_Fq::zero());
     bls12_381_G1::G1_one = bls12_381_G1(
         bls12_381_Fq(
             "368541675371338701678108831518307775796162079578254640989457837868"
             "8607592378376318836054947676345821548104185464507"),
         bls12_381_Fq(
             "133950654494447647302047137994192122158493387593834962042654373641"
             "6511423956333506472724655353366534992391756441569"),
         bls12_381_Fq::one());
  
     // Curve coeffs
     bls12_381_G1::coeff_a = bls12_381_Fq::zero();
     bls12_381_G1::coeff_b = bls12_381_coeff_b;
  
     // Cofactor
     bls12_381_G1::h =
         bigint<bls12_381_G1::h_limbs>("76329603384216526031706109802092473003");
  
     // TODO: wNAF window table
     bls12_381_G1::wnaf_window_table.resize(0);
     bls12_381_G1::wnaf_window_table.push_back(11);
     bls12_381_G1::wnaf_window_table.push_back(24);
     bls12_381_G1::wnaf_window_table.push_back(60);
     bls12_381_G1::wnaf_window_table.push_back(127);
  
     // TODO: fixed-base exponentiation table
     bls12_381_G1::fixed_base_exp_window_table.resize(0);
     // window 1 is unbeaten in [-inf, 4.99]
     bls12_381_G1::fixed_base_exp_window_table.push_back(1);
     // window 2 is unbeaten in [4.99, 10.99]
     bls12_381_G1::fixed_base_exp_window_table.push_back(5);
     // window 3 is unbeaten in [10.99, 32.29]
     bls12_381_G1::fixed_base_exp_window_table.push_back(11);
     // window 4 is unbeaten in [32.29, 55.23]
     bls12_381_G1::fixed_base_exp_window_table.push_back(32);
     // window 5 is unbeaten in [55.23, 162.03]
     bls12_381_G1::fixed_base_exp_window_table.push_back(55);
     // window 6 is unbeaten in [162.03, 360.15]
     bls12_381_G1::fixed_base_exp_window_table.push_back(162);
     // window 7 is unbeaten in [360.15, 815.44]
     bls12_381_G1::fixed_base_exp_window_table.push_back(360);
     // window 8 is unbeaten in [815.44, 2373.07]
     bls12_381_G1::fixed_base_exp_window_table.push_back(815);
     // window 9 is unbeaten in [2373.07, 6977.75]
     bls12_381_G1::fixed_base_exp_window_table.push_back(2373);
     // window 10 is unbeaten in [6977.75, 7122.23]
     bls12_381_G1::fixed_base_exp_window_table.push_back(6978);
     // window 11 is unbeaten in [7122.23, 57818.46]
     bls12_381_G1::fixed_base_exp_window_table.push_back(7122);
     // window 12 is never the best
     bls12_381_G1::fixed_base_exp_window_table.push_back(0);
     // window 13 is unbeaten in [57818.46, 169679.14]
     bls12_381_G1::fixed_base_exp_window_table.push_back(57818);
     // window 14 is never the best
     bls12_381_G1::fixed_base_exp_window_table.push_back(0);
     // window 15 is unbeaten in [169679.14, 439758.91]
     bls12_381_G1::fixed_base_exp_window_table.push_back(169679);
     // window 16 is unbeaten in [439758.91, 936073.41]
     bls12_381_G1::fixed_base_exp_window_table.push_back(439759);
     // window 17 is unbeaten in [936073.41, 4666554.74]
     bls12_381_G1::fixed_base_exp_window_table.push_back(936073);
     // window 18 is never the best
     bls12_381_G1::fixed_base_exp_window_table.push_back(0);
     // window 19 is unbeaten in [4666554.74, 7580404.42]
     bls12_381_G1::fixed_base_exp_window_table.push_back(4666555);
     // window 20 is unbeaten in [7580404.42, 34552892.20]
     bls12_381_G1::fixed_base_exp_window_table.push_back(7580404);
     // window 21 is never the best
     bls12_381_G1::fixed_base_exp_window_table.push_back(0);
     // window 22 is unbeaten in [34552892.20, inf]
     bls12_381_G1::fixed_base_exp_window_table.push_back(34552892);
  
     /* choice of group G2 */
     bls12_381_G2::G2_zero = bls12_381_G2(
         bls12_381_Fq2::zero(), bls12_381_Fq2::one(), bls12_381_Fq2::zero());
  
     // simple G2 generator
     bls12_381_G2::G2_one = bls12_381_G2(
         bls12_381_Fq2(
             bls12_381_Fq(
                 "35270106958746661818713911601106014489002995279277524021990864"
                 "4239793785735715026873347600343865175952761926303160"),
             bls12_381_Fq(
                 "30591443442442137099712598147537816369864703254766475586593732"
                 "06291635324768958432433509563104347017837885763365758")),
         bls12_381_Fq2(
             bls12_381_Fq(
                 "19851506022872919355680545211771716383008689782156557308593786"
                 "65066344726373823718423869104263333984641494340347905"),
             bls12_381_Fq(
                 "92755366549233245574720196577603788075774019345359297002502797"
                 "8793976877002675564980949289727957565575433344219582")),
         bls12_381_Fq2::one());
  
     // Curve twist coeffs
     bls12_381_G2::coeff_a = bls12_381_Fq2::zero();
     bls12_381_G2::coeff_b = bls12_381_twist_coeff_b;
  
     // Cofactor
     bls12_381_G2::h = bigint<bls12_381_G2::h_limbs>(
         "3055023339312683442009997531931215042144660192541881426676640329822676"
         "0418297188402650742735925997784783227283904161666128580382337837209635"
         "5777062779109");
  
     // TODO: wNAF window table
     bls12_381_G2::wnaf_window_table.resize(0);
     bls12_381_G2::wnaf_window_table.push_back(5);
     bls12_381_G2::wnaf_window_table.push_back(15);
     bls12_381_G2::wnaf_window_table.push_back(39);
     bls12_381_G2::wnaf_window_table.push_back(109);
  
     // TODO: fixed-base exponentiation table
     bls12_381_G2::fixed_base_exp_window_table.resize(0);
     // window 1 is unbeaten in [-inf, 5.10]
     bls12_381_G2::fixed_base_exp_window_table.push_back(1);
     // window 2 is unbeaten in [5.10, 10.43]
     bls12_381_G2::fixed_base_exp_window_table.push_back(5);
     // window 3 is unbeaten in [10.43, 25.28]
     bls12_381_G2::fixed_base_exp_window_table.push_back(10);
     // window 4 is unbeaten in [25.28, 59.00]
     bls12_381_G2::fixed_base_exp_window_table.push_back(25);
     // window 5 is unbeaten in [59.00, 154.03]
     bls12_381_G2::fixed_base_exp_window_table.push_back(59);
     // window 6 is unbeaten in [154.03, 334.25]
     bls12_381_G2::fixed_base_exp_window_table.push_back(154);
     // window 7 is unbeaten in [334.25, 742.58]
     bls12_381_G2::fixed_base_exp_window_table.push_back(334);
     // window 8 is unbeaten in [742.58, 2034.40]
     bls12_381_G2::fixed_base_exp_window_table.push_back(743);
     // window 9 is unbeaten in [2034.40, 4987.56]
     bls12_381_G2::fixed_base_exp_window_table.push_back(2034);
     // window 10 is unbeaten in [4987.56, 8888.27]
     bls12_381_G2::fixed_base_exp_window_table.push_back(4988);
     // window 11 is unbeaten in [8888.27, 26271.13]
     bls12_381_G2::fixed_base_exp_window_table.push_back(8888);
     // window 12 is unbeaten in [26271.13, 39768.20]
     bls12_381_G2::fixed_base_exp_window_table.push_back(26271);
     // window 13 is unbeaten in [39768.20, 106275.75]
     bls12_381_G2::fixed_base_exp_window_table.push_back(39768);
     // window 14 is unbeaten in [106275.75, 141703.40]
     bls12_381_G2::fixed_base_exp_window_table.push_back(106276);
     // window 15 is unbeaten in [141703.40, 462422.97]
     bls12_381_G2::fixed_base_exp_window_table.push_back(141703);
     // window 16 is unbeaten in [462422.97, 926871.84]
     bls12_381_G2::fixed_base_exp_window_table.push_back(462423);
     // window 17 is unbeaten in [926871.84, 4873049.17]
     bls12_381_G2::fixed_base_exp_window_table.push_back(926872);
     // window 18 is never the best
     bls12_381_G2::fixed_base_exp_window_table.push_back(0);
     // window 19 is unbeaten in [4873049.17, 5706707.88]
     bls12_381_G2::fixed_base_exp_window_table.push_back(4873049);
     // window 20 is unbeaten in [5706707.88, 31673814.95]
     bls12_381_G2::fixed_base_exp_window_table.push_back(5706708);
     // window 21 is never the best
     bls12_381_G2::fixed_base_exp_window_table.push_back(0);
     // window 22 is unbeaten in [31673814.95, inf]
     bls12_381_G2::fixed_base_exp_window_table.push_back(31673815);
  
     /* pairing parameters */
  
     bls12_381_ate_loop_count =
         bigint<bls12_381_q_limbs>("15132376222941642752");
     bls12_381_ate_is_loop_count_neg = true;
     bls12_381_final_exponent = bigint<12 * bls12_381_q_limbs>(
         "3222773615169341404628915645865101399083799695148284942183666880252886"
         "6104110468279499868049758000889997324981410444769277898820837677957381"
         "9485263026159588510513834876303014016798809919343532899164848730280942"
         "6099566709175656181158672873996232868132703579017315101881499343633603"
         "8161450133408682544227192007936328995451056537537844370437299488140679"
         "7882676971082200626541916413184642520269678897559532260949334760604962"
         "0863488981189822488426343796375986654688177690758785554937522144927901"
         "2278585020295757520017608420442275148595733646547232481098283363849090"
         "4279282696134323072515220044451592646885410572234451732790590013479358"
         "3438412200741748482217220170835978720176385141031741227848439255783704"
         "3084352295960009567628572373704943834654475316891297497679152853527631"
         "7256904336520179281145394686565050419250614107803233314658825463117900"
         "2507011991815292059423631593257659918194339143039088604607205814082013"
         "7316404777379482541101192230582006561112154456180841405530221205747139"
         "5719432072209245600258134364584636810093520285711072578721435517884103"
         "5264838327332898024261573015427444767400084947803633543051169788056206"
         "7146707140071135883955337534072489973546048014459978201490658654381329"
         "2157922220645089192130209334926661588737007768565838519456601560804957"
         "985667880395221049249803753582637708560");
     bls12_381_final_exponent_z =
         bigint<bls12_381_q_limbs>("15132376222941642752");
     bls12_381_final_exponent_is_z_neg = true;
 }

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 29 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("21888242871839275222246405745257275088548364400"
                                "416034343698204186575808495617");
     assert(bn128_Fr::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         bn128_Fr::Rsquared = bigint_r("9449366811492084466516642542697455484907"
                                       "66851729442924617792859073125903783");
         bn128_Fr::Rcubed = bigint_r("586654854594384522748989487204024472040386"
                                     "8105578784105281690076696998248512");
         bn128_Fr::inv = 0xc2e1f593efffffff;
     }
     if (sizeof(mp_limb_t) == 4) {
         bn128_Fr::Rsquared = bigint_r("9449366811492084466516642542697455484907"
                                       "66851729442924617792859073125903783");
         bn128_Fr::Rcubed = bigint_r("586654854594384522748989487204024472040386"
                                     "8105578784105281690076696998248512");
         bn128_Fr::inv = 0xefffffff;
     }
     bn128_Fr::num_bits = 254;
     bn128_Fr::euler = bigint_r("10944121435919637611123202872628637544274182200"
                                "208017171849102093287904247808");
     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("1910321906792171394429139282769207003614565195732928631530564"
                  "2004821462161904");
     bn128_Fr::nqr = bn128_Fr("5");
     bn128_Fr::nqr_to_t = bn128_Fr("19103219067921713944291392827692070036145651"
                                   "957329286315305642004821462161904");
     bn128_Fr::static_init();
  
     /* parameters for base field Fq */
     bn128_modulus_q = bigint_q("21888242871839275222246405745257275088696311157"
                                "297823662689037894645226208583");
     assert(bn128_Fq::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         bn128_Fq::Rsquared = bigint_q("3096616502983703923843567936837374451735"
                                       "540968419076528771170197431451843209");
         bn128_Fq::Rcubed = bigint_q("149217865411596481859481527385630809590936"
                                     "19838510245177710943249661917737183");
         bn128_Fq::inv = 0x87d20782e4866389;
     }
     if (sizeof(mp_limb_t) == 4) {
         bn128_Fq::Rsquared = bigint_q("3096616502983703923843567936837374451735"
                                       "540968419076528771170197431451843209");
         bn128_Fq::Rcubed = bigint_q("149217865411596481859481527385630809590936"
                                     "19838510245177710943249661917737183");
         bn128_Fq::inv = 0xe4866389;
     }
     bn128_Fq::num_bits = 254;
     bn128_Fq::euler = bigint_q("10944121435919637611123202872628637544348155578"
                                "648911831344518947322613104291");
     bn128_Fq::s = 1;
     bn128_Fq::t = bigint_q("109441214359196376111232028726286375443481555786489"
                            "11831344518947322613104291");
     bn128_Fq::t_minus_1_over_2 =
         bigint_q("5472060717959818805561601436314318772174077789324455915672259"
                  "473661306552145");
     bn128_Fq::multiplicative_generator = bn128_Fq("3");
     bn128_Fq::root_of_unity =
         bn128_Fq("2188824287183927522224640574525727508869631115729782366268903"
                  "7894645226208582");
     bn128_Fq::nqr = bn128_Fq("3");
     bn128_Fq::nqr_to_t = bn128_Fq("21888242871839275222246405745257275088696311"
                                   "157297823662689037894645226208582");
     bn128_Fq::static_init();
  
     /* 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("21888242871839275222246405745257275088696311157"
                                "297823662689037894645226208582");
     bn128_Fq_t_minus_1_over_2 =
         mie::Vuint("54720607179598188055616014363143187721740777893244559156722"
                    "59473661306552145");
  
     bn128_twist_coeff_b = bn::Fp2(
         bn::Fp("194858747517593547710242392610217205057906184693017210655646312"
                "96452457478373"),
         bn::Fp("266929791119991161246907387137283842545076965332900288569378510"
                "910307636690"));
     bn128_Fq2_s = 4;
     bn128_Fq2_nqr_to_t = bn::Fp2(
         bn::Fp("503350371626262426731249255837998268717520073493487759859901148"
                "5707452665730"),
         bn::Fp("314498342015008975724433667930697407966947188435857772134235984"
                "660852259084"));
     bn128_Fq2_t_minus_1_over_2 =
         mie::Vuint("14971724250519463826312126413021210649976634891596900701138"
                    "99382043969042769931992024503286935743349909963225983790938"
                    "3182382988566862092145199781964621");
  
     /* choice of group G1 */
     // Identities
     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);
  
     // Cofactor
     bn128_G1::h = bigint<bn128_G1::h_limbs>("1");
  
     // WNAF
     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 */
     // Identities
     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("152678028847935503835587060391656210502900897759612088243037657"
                "53922461897946"),
         bn::Fp("903449356601974233940237867046189777450996766956261078811321598"
                "8055021632533"));
     bn128_G2::G2_one.Y = bn::Fp2(
         bn::Fp("644888581738283025171396578091639672120333224302184904896215738"
                "366765861164"),
         bn::Fp("205328750812034486954487442552245436619595163613273857798784767"
                "09582931298750"));
     bn128_G2::G2_one.Z = bn::Fp2(bn::Fp(1), bn::Fp(0));
  
     // Cofactor
     bn128_G2::h =
         bigint<bn128_G2::h_limbs>("21888242871839275222246405745257275088844257"
                                   "914179612981679871602714643921549");
  
     // WNAF
     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_bw6_761_params()

void libff::init_bw6_761_params ( )

Definition at line 27 of file bw6_761_init.cpp.

 {
     typedef bigint<bw6_761_r_limbs> bigint_r;
     typedef bigint<bw6_761_q_limbs> bigint_q;
  
     // Montgomery assumes this
     assert(sizeof(mp_limb_t) == 8 || sizeof(mp_limb_t) == 4);
  
     // Parameters for scalar field Fr
     // r =
     // 0x1ae3a4617c510eac63b05c06ca1493b1a22d9f300f5138f1ef3622fba094800170b5d44300000008508c00000000001
     bw6_761_modulus_r =
         bigint_r("2586644260129690940106527336948935335363935127549146605398842"
                  "62666720468348340822774968888139573360124440321458177");
     assert(bw6_761_Fr::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         bw6_761_Fr::Rsquared = bigint_r(
             "661274283768726978163325701168662324052305289846649183196063154202"
             "33909940404532140033099444330447428417853902114");
         bw6_761_Fr::Rcubed = bigint_r(
             "157734475176213061358192738313701451942220138363611391489992831740"
             "412033225490229541667992423878570205050777755168");
         bw6_761_Fr::inv = 0x8508bfffffffffff;
     }
     if (sizeof(mp_limb_t) == 4) {
         bw6_761_Fr::Rsquared = bigint_r(
             "661274283768726978163325701168662324052305289846649183196063154202"
             "33909940404532140033099444330447428417853902114");
         bw6_761_Fr::Rcubed = bigint_r(
             "157734475176213061358192738313701451942220138363611391489992831740"
             "412033225490229541667992423878570205050777755168");
         bw6_761_Fr::inv = 0xffffffff;
     }
     bw6_761_Fr::num_bits = 377;
     bw6_761_Fr::euler =
         bigint_r("1293322130064845470053263668474467667681967563774573302699421"
                  "31333360234174170411387484444069786680062220160729088");
     bw6_761_Fr::s = 46;
     bw6_761_Fr::t =
         bigint_r("3675842578061421676390135839012792950148785745837396071634149"
                  "488243117337281387659330802195819009059");
     bw6_761_Fr::t_minus_1_over_2 =
         bigint_r("1837921289030710838195067919506396475074392872918698035817074"
                  "744121558668640693829665401097909504529");
     bw6_761_Fr::multiplicative_generator = bw6_761_Fr("15");
     bw6_761_Fr::root_of_unity =
         bw6_761_Fr("32863578547254505029601261939868325669770508939375122462904"
                    "745766352256812585773382134936404344547323199885654433");
     bw6_761_Fr::nqr = bw6_761_Fr("5");
     bw6_761_Fr::nqr_to_t =
         bw6_761_Fr("33774956008227656219775876656288133547078610493828613777258"
                    "829345740556592044969439504850374928261397247202212840");
     bw6_761_Fr::static_init();
  
     // Parameters for base field Fq
     // q =
     // 0x122e824fb83ce0ad187c94004faff3eb926186a81d14688528275ef8087be41707ba638e584e91903cebaff25b423048689c8ed12f9fd9071dcd3dc73ebff2e98a116c25667a8f8160cf8aeeaf0a437e6913e6870000082f49d00000000008b
     bw6_761_modulus_q =
         bigint_q("6891450384315732539396789682275657542479668912536150109513790"
                  "1602096234222434917360876831832894116876408645677537866134511"
                  "6175912055424775934951169912530159895160509937850885037254363"
                  "1423596795951899700429969112842764913119068299");
     assert(bw6_761_Fq::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         bw6_761_Fq::Rsquared = bigint_q(
             "410173710550729835244256131339319232418037181415529408988358678008"
             "337131002543531210418765667118526087296627284304957029592342298086"
             "677137781899438438783090920915449892454598380340650741080836049574"
             "9428678951279422657716620863065");
         bw6_761_Fq::Rcubed = bigint_q(
             "297415514632118086526834853439131925910825545338380841392089322640"
             "624198677430665521626961318971291885148318712859327336480040754936"
             "765047304839676586453060891603903912680899124818868997690823101153"
             "644786484398736894438670450156");
  
         bw6_761_Fq::inv = 0xa5593568fa798dd;
     }
     if (sizeof(mp_limb_t) == 4) {
         bw6_761_Fq::Rsquared = bigint_q(
             "410173710550729835244256131339319232418037181415529408988358678008"
             "337131002543531210418765667118526087296627284304957029592342298086"
             "677137781899438438783090920915449892454598380340650741080836049574"
             "9428678951279422657716620863065");
         bw6_761_Fq::Rcubed = bigint_q(
             "297415514632118086526834853439131925910825545338380841392089322640"
             "624198677430665521626961318971291885148318712859327336480040754936"
             "765047304839676586453060891603903912680899124818868997690823101153"
             "644786484398736894438670450156");
         bw6_761_Fq::inv = 0x8fa798dd;
     }
     bw6_761_Fq::num_bits = 761;
     bw6_761_Fq::euler =
         bigint_q("3445725192157866269698394841137828771239834456268075054756895"
                  "0801048117111217458680438415916447058438204322838768933067255"
                  "8087956027712387967475584956265079947580254968925442518627181"
                  "5711798397975949850214984556421382456559534149");
     bw6_761_Fq::s = 1;
     bw6_761_Fq::t =
         bigint_q("3445725192157866269698394841137828771239834456268075054756895"
                  "0801048117111217458680438415916447058438204322838768933067255"
                  "8087956027712387967475584956265079947580254968925442518627181"
                  "5711798397975949850214984556421382456559534149");
     bw6_761_Fq::t_minus_1_over_2 =
         bigint_q("1722862596078933134849197420568914385619917228134037527378447"
                  "5400524058555608729340219207958223529219102161419384466533627"
                  "9043978013856193983737792478132539973790127484462721259313590"
                  "7855899198987974925107492278210691228279767074");
     bw6_761_Fq::multiplicative_generator = bw6_761_Fq("2");
     bw6_761_Fq::root_of_unity =
         bw6_761_Fq("68914503843157325393967896822756575424796689125361501095137"
                    "90160209623422243491736087683183289411687640864567753786613"
                    "45116175912055424775934951169912530159895160509937850885037"
                    "2543631423596795951899700429969112842764913119068298");
     bw6_761_Fq::nqr = bw6_761_Fq("2");
     bw6_761_Fq::nqr_to_t =
         bw6_761_Fq("68914503843157325393967896822756575424796689125361501095137"
                    "90160209623422243491736087683183289411687640864567753786613"
                    "45116175912055424775934951169912530159895160509937850885037"
                    "2543631423596795951899700429969112842764913119068298");
     bw6_761_Fq::static_init();
  
     // Parameters for Fq3
     bw6_761_Fq3::euler = bigint<3 * bw6_761_q_limbs>(
         "1636446854262954003249141699409548889559206196373633220512096143268984"
         "5397014880568641901171928604942518055908462554673180677727867910667998"
         "4663099143697116161447047621868304705520956489172590015220902479424161"
         "5633521368602921395669003930971333893630420619714613478078837246039873"
         "3124493326270446151854198371345979937646860351442184846671768256523932"
         "2945704382553665794724881767934477627356011124130848888786345848916593"
         "9567481576923242781572039862743001907835119097653682898829629358506603"
         "8893699793468601168791027807574316427084928535262789988925129164000203"
         "2048904566729137025370148302740362549750397891505412715221417910833483"
         "274288268810463328915955262815220574933205354950574767449");
     bw6_761_Fq3::s = 1;
     bw6_761_Fq3::t = bigint<3 * bw6_761_q_limbs>(
         "1636446854262954003249141699409548889559206196373633220512096143268984"
         "5397014880568641901171928604942518055908462554673180677727867910667998"
         "4663099143697116161447047621868304705520956489172590015220902479424161"
         "5633521368602921395669003930971333893630420619714613478078837246039873"
         "3124493326270446151854198371345979937646860351442184846671768256523932"
         "2945704382553665794724881767934477627356011124130848888786345848916593"
         "9567481576923242781572039862743001907835119097653682898829629358506603"
         "8893699793468601168791027807574316427084928535262789988925129164000203"
         "2048904566729137025370148302740362549750397891505412715221417910833483"
         "274288268810463328915955262815220574933205354950574767449");
     bw6_761_Fq3::t_minus_1_over_2 = bigint<3 * bw6_761_q_limbs>(
         "8182234271314770016245708497047744447796030981868166102560480716344922"
         "6985074402843209505859643024712590279542312773365903388639339553339992"
         "3315495718485580807235238109341523527604782445862950076104512397120807"
         "8167606843014606978345019654856669468152103098573067390394186230199366"
         "5622466631352230759270991856729899688234301757210924233358841282619661"
         "4728521912768328973624408839672388136780055620654244443931729244582969"
         "7837407884616213907860199313715009539175595488268414494148146792533019"
         "4468498967343005843955139037871582135424642676313949944625645820001016"
         "0244522833645685126850741513701812748751989457527063576107089554167416"
         "37144134405231664457977631407610287466602677475287383724");
     bw6_761_Fq3::nqr =
         bw6_761_Fq3(bw6_761_Fq("0"), bw6_761_Fq("1"), bw6_761_Fq("0"));
     bw6_761_Fq3::nqr_to_t = bw6_761_Fq3(
         bw6_761_Fq("68914503843157325393967896822756575424796689125361501095137"
                    "90160209623422243491736087683183289411687640864567753786613"
                    "45116175912055424775934951169912530159895160509937850885037"
                    "2543631423596795951899700429969112842764913119068298"),
         bw6_761_Fq("0"),
         bw6_761_Fq("0"));
     bw6_761_Fq3::non_residue =
         bw6_761_Fq("68914503843157325393967896822756575424796689125361501095137"
                    "90160209623422243491736087683183289411687640864567753786613"
                    "45116175912055424775934951169912530159895160509937850885037"
                    "2543631423596795951899700429969112842764913119068295");
     bw6_761_Fq3::nqr =
         bw6_761_Fq3(bw6_761_Fq("0"), bw6_761_Fq("1"), bw6_761_Fq("0"));
     bw6_761_Fq3::nqr_to_t = bw6_761_Fq3(
         bw6_761_Fq("68914503843157325393967896822756575424796689125361501095137"
                    "90160209623422243491736087683183289411687640864567753786613"
                    "45116175912055424775934951169912530159895160509937850885037"
                    "2543631423596795951899700429969112842764913119068298"),
         bw6_761_Fq("0"),
         bw6_761_Fq("0"));
     bw6_761_Fq3::Frobenius_coeffs_c1[0] = bw6_761_Fq("1");
     bw6_761_Fq3::Frobenius_coeffs_c1[1] =
         bw6_761_Fq("49224645602255232421181789425750803910820025302323243810630"
                    "48548642823052024664478336818169867474395270858391911405337"
                    "70724773573982666493944449046954210939153048282672820358254"
                    "9674992333383150446779312029624171857054392282775648");
     bw6_761_Fq3::Frobenius_coeffs_c1[2] =
         bw6_761_Fq("19689858240902092972786107397005771513976663823038257284507"
                    "41611566800370218827257750865013421937292370006175842381275"
                    "74391402338072758281990502122958319220742112227265030526782"
                    "2868639090213645505120388400344940985710520836292650");
     bw6_761_Fq3::Frobenius_coeffs_c2[0] = bw6_761_Fq("1");
     bw6_761_Fq3::Frobenius_coeffs_c2[1] =
         bw6_761_Fq("19689858240902092972786107397005771513976663823038257284507"
                    "41611566800370218827257750865013421937292370006175842381275"
                    "74391402338072758281990502122958319220742112227265030526782"
                    "2868639090213645505120388400344940985710520836292650");
     bw6_761_Fq3::Frobenius_coeffs_c2[2] =
         bw6_761_Fq("49224645602255232421181789425750803910820025302323243810630"
                    "48548642823052024664478336818169867474395270858391911405337"
                    "70724773573982666493944449046954210939153048282672820358254"
                    "9674992333383150446779312029624171857054392282775648");
  
     // Parameters for the field Fq^6
     bw6_761_Fq6::non_residue =
         bw6_761_Fq("68914503843157325393967896822756575424796689125361501095137"
                    "90160209623422243491736087683183289411687640864567753786613"
                    "45116175912055424775934951169912530159895160509937850885037"
                    "2543631423596795951899700429969112842764913119068295");
     bw6_761_Fq6::Frobenius_coeffs_c1[0] = bw6_761_Fq("1");
     bw6_761_Fq6::Frobenius_coeffs_c1[1] =
         bw6_761_Fq("49224645602255232421181789425750803910820025302323243810630"
                    "48548642823052024664478336818169867474395270858391911405337"
                    "70724773573982666493944449046954210939153048282672820358254"
                    "9674992333383150446779312029624171857054392282775649");
     bw6_761_Fq6::Frobenius_coeffs_c1[2] =
         bw6_761_Fq("49224645602255232421181789425750803910820025302323243810630"
                    "48548642823052024664478336818169867474395270858391911405337"
                    "70724773573982666493944449046954210939153048282672820358254"
                    "9674992333383150446779312029624171857054392282775648");
     bw6_761_Fq6::Frobenius_coeffs_c1[3] =
         bw6_761_Fq("68914503843157325393967896822756575424796689125361501095137"
                    "90160209623422243491736087683183289411687640864567753786613"
                    "45116175912055424775934951169912530159895160509937850885037"
                    "2543631423596795951899700429969112842764913119068298");
     bw6_761_Fq6::Frobenius_coeffs_c1[4] =
         bw6_761_Fq("19689858240902092972786107397005771513976663823038257284507"
                    "41611566800370218827257750865013421937292370006175842381275"
                    "74391402338072758281990502122958319220742112227265030526782"
                    "2868639090213645505120388400344940985710520836292650");
     bw6_761_Fq6::Frobenius_coeffs_c1[5] =
         bw6_761_Fq("19689858240902092972786107397005771513976663823038257284507"
                    "41611566800370218827257750865013421937292370006175842381275"
                    "74391402338072758281990502122958319220742112227265030526782"
                    "2868639090213645505120388400344940985710520836292651");
  
     bw6_761_Fq6::my_Fp2::non_residue = bw6_761_Fq3::non_residue;
  
     // Choice of short Weierstrass curve and its twist
     // E: y^2 = x^3 - 1
     // bw6_761_coeff_b = -1
     bw6_761_coeff_b =
         bw6_761_Fq("68914503843157325393967896822756575424796689125361501095137"
                    "90160209623422243491736087683183289411687640864567753786613"
                    "45116175912055424775934951169912530159895160509937850885037"
                    "2543631423596795951899700429969112842764913119068298");
     // E': y^2 = x^3 - 1 * (-4) = y^2 = x^3 + 4
     // bw6_761_twist = -4
     bw6_761_twist =
         bw6_761_Fq("68914503843157325393967896822756575424796689125361501095137"
                    "90160209623422243491736087683183289411687640864567753786613"
                    "45116175912055424775934951169912530159895160509937850885037"
                    "2543631423596795951899700429969112842764913119068295");
     // We use a M-twist here, hence:
     // bw6_761_twist_coeff_b = bw6_761_coeff_b * bw6_761_twist;
     bw6_761_twist_coeff_b = bw6_761_Fq("4");
  
     // Choice of group G1
     // Identities
     bw6_761_G1::G1_zero =
         bw6_761_G1(bw6_761_Fq::zero(), bw6_761_Fq::one(), bw6_761_Fq::zero());
     bw6_761_G1::G1_one = bw6_761_G1(
         bw6_761_Fq("62387722575946793680321456936228128387790058097608247331387"
                    "87810501188623461307351759238099287535516224314149266511977"
                    "13214082863595094002179048950761175436631780181109081136794"
                    "5064510304504157188661901055903167026722666149426237"),
         bw6_761_Fq("21017351265208974239115045622158349511481275559133679971627"
                    "89335052900271653517958562461315794228241561913734371411178"
                    "22693652768320387955309393418595047097184897208532179795812"
                    "4416462268292467002957525517188485984766314758624099"),
         bw6_761_Fq::one());
  
     // Curve coeffs
     bw6_761_G1::coeff_a = bw6_761_Fq::zero();
     bw6_761_G1::coeff_b = bw6_761_coeff_b;
  
     // Cofactor
     bw6_761_G1::h = bigint<bw6_761_G1::h_limbs>(
         "2664243587933581668398767770148807386775111827005265065594210250231297"
         "7592501693353047140953112195348280268661194876");
  
     // WNAF
     //
     // Below we use the same `wnaf_window_table` as used for alt_bn_128
     // TODO: Adjust the `wnaf_window_table` and `fixed_base_exp_window_table`
     bw6_761_G1::wnaf_window_table.resize(0);
     bw6_761_G1::wnaf_window_table.push_back(11);
     bw6_761_G1::wnaf_window_table.push_back(24);
     bw6_761_G1::wnaf_window_table.push_back(60);
     bw6_761_G1::wnaf_window_table.push_back(127);
  
     // Fixed-base exponentiation table
     bw6_761_G1::fixed_base_exp_window_table.resize(0);
     // window 1 is unbeaten in [-inf, 4.99]
     bw6_761_G1::fixed_base_exp_window_table.push_back(1);
     // window 2 is unbeaten in [4.99, 10.99]
     bw6_761_G1::fixed_base_exp_window_table.push_back(5);
     // window 3 is unbeaten in [10.99, 32.29]
     bw6_761_G1::fixed_base_exp_window_table.push_back(11);
     // window 4 is unbeaten in [32.29, 55.23]
     bw6_761_G1::fixed_base_exp_window_table.push_back(32);
     // window 5 is unbeaten in [55.23, 162.03]
     bw6_761_G1::fixed_base_exp_window_table.push_back(55);
     // window 6 is unbeaten in [162.03, 360.15]
     bw6_761_G1::fixed_base_exp_window_table.push_back(162);
     // window 7 is unbeaten in [360.15, 815.44]
     bw6_761_G1::fixed_base_exp_window_table.push_back(360);
     // window 8 is unbeaten in [815.44, 2373.07]
     bw6_761_G1::fixed_base_exp_window_table.push_back(815);
     // window 9 is unbeaten in [2373.07, 6977.75]
     bw6_761_G1::fixed_base_exp_window_table.push_back(2373);
     // window 10 is unbeaten in [6977.75, 7122.23]
     bw6_761_G1::fixed_base_exp_window_table.push_back(6978);
     // window 11 is unbeaten in [7122.23, 57818.46]
     bw6_761_G1::fixed_base_exp_window_table.push_back(7122);
     // window 12 is never the best
     bw6_761_G1::fixed_base_exp_window_table.push_back(0);
     // window 13 is unbeaten in [57818.46, 169679.14]
     bw6_761_G1::fixed_base_exp_window_table.push_back(57818);
     // window 14 is never the best
     bw6_761_G1::fixed_base_exp_window_table.push_back(0);
     // window 15 is unbeaten in [169679.14, 439758.91]
     bw6_761_G1::fixed_base_exp_window_table.push_back(169679);
     // window 16 is unbeaten in [439758.91, 936073.41]
     bw6_761_G1::fixed_base_exp_window_table.push_back(439759);
     // window 17 is unbeaten in [936073.41, 4666554.74]
     bw6_761_G1::fixed_base_exp_window_table.push_back(936073);
     // window 18 is never the best
     bw6_761_G1::fixed_base_exp_window_table.push_back(0);
     // window 19 is unbeaten in [4666554.74, 7580404.42]
     bw6_761_G1::fixed_base_exp_window_table.push_back(4666555);
     // window 20 is unbeaten in [7580404.42, 34552892.20]
     bw6_761_G1::fixed_base_exp_window_table.push_back(7580404);
     // window 21 is never the best
     bw6_761_G1::fixed_base_exp_window_table.push_back(0);
     // window 22 is unbeaten in [34552892.20, inf]
     bw6_761_G1::fixed_base_exp_window_table.push_back(34552892);
  
     // Choice of group G2
     // Identities
     bw6_761_G2::G2_zero =
         bw6_761_G2(bw6_761_Fq::zero(), bw6_761_Fq::one(), bw6_761_Fq::zero());
     bw6_761_G2::G2_one = bw6_761_G2(
         bw6_761_Fq("64453329105969793360358881527740716268988861397741013649339"
                    "48236926875073754470830732273879639675437155036544153105017"
                    "72959260056063167855429956276229474392791242909663615640117"
                    "1909259073181112518725201388196280039960074422214428"),
         bw6_761_Fq("56292365808953971938692216344454738775758653474108026394695"
                    "34015951552119346305989993003963171041825980447937581532149"
                    "72605680357108252243146746187917218885078195819486220416605"
                    "630144001533548163105316661692978285266378674355041"),
         bw6_761_Fq::one());
  
     // Curve coeffs
     bw6_761_G2::coeff_a = bw6_761_Fq::zero();
     bw6_761_G2::coeff_b = bw6_761_twist_coeff_b;
  
     // Cofactor
     bw6_761_G2::h = bigint<bw6_761_G2::h_limbs>(
         "2664243587933581668398767770148807386775111827005265065594210250231297"
         "7592501693353047140953112195348280268661194869");
  
     // wNAF window table
     bw6_761_G2::wnaf_window_table.resize(0);
     bw6_761_G2::wnaf_window_table.push_back(5);
     bw6_761_G2::wnaf_window_table.push_back(15);
     bw6_761_G2::wnaf_window_table.push_back(39);
     bw6_761_G2::wnaf_window_table.push_back(109);
  
     // Fixed-base exponentiation table
     bw6_761_G2::fixed_base_exp_window_table.resize(0);
     // window 1 is unbeaten in [-inf, 5.10]
     bw6_761_G2::fixed_base_exp_window_table.push_back(1);
     // window 2 is unbeaten in [5.10, 10.43]
     bw6_761_G2::fixed_base_exp_window_table.push_back(5);
     // window 3 is unbeaten in [10.43, 25.28]
     bw6_761_G2::fixed_base_exp_window_table.push_back(10);
     // window 4 is unbeaten in [25.28, 59.00]
     bw6_761_G2::fixed_base_exp_window_table.push_back(25);
     // window 5 is unbeaten in [59.00, 154.03]
     bw6_761_G2::fixed_base_exp_window_table.push_back(59);
     // window 6 is unbeaten in [154.03, 334.25]
     bw6_761_G2::fixed_base_exp_window_table.push_back(154);
     // window 7 is unbeaten in [334.25, 742.58]
     bw6_761_G2::fixed_base_exp_window_table.push_back(334);
     // window 8 is unbeaten in [742.58, 2034.40]
     bw6_761_G2::fixed_base_exp_window_table.push_back(743);
     // window 9 is unbeaten in [2034.40, 4987.56]
     bw6_761_G2::fixed_base_exp_window_table.push_back(2034);
     // window 10 is unbeaten in [4987.56, 8888.27]
     bw6_761_G2::fixed_base_exp_window_table.push_back(4988);
     // window 11 is unbeaten in [8888.27, 26271.13]
     bw6_761_G2::fixed_base_exp_window_table.push_back(8888);
     // window 12 is unbeaten in [26271.13, 39768.20]
     bw6_761_G2::fixed_base_exp_window_table.push_back(26271);
     // window 13 is unbeaten in [39768.20, 106275.75]
     bw6_761_G2::fixed_base_exp_window_table.push_back(39768);
     // window 14 is unbeaten in [106275.75, 141703.40]
     bw6_761_G2::fixed_base_exp_window_table.push_back(106276);
     // window 15 is unbeaten in [141703.40, 462422.97]
     bw6_761_G2::fixed_base_exp_window_table.push_back(141703);
     // window 16 is unbeaten in [462422.97, 926871.84]
     bw6_761_G2::fixed_base_exp_window_table.push_back(462423);
     // window 17 is unbeaten in [926871.84, 4873049.17]
     bw6_761_G2::fixed_base_exp_window_table.push_back(926872);
     // window 18 is never the best
     bw6_761_G2::fixed_base_exp_window_table.push_back(0);
     // window 19 is unbeaten in [4873049.17, 5706707.88]
     bw6_761_G2::fixed_base_exp_window_table.push_back(4873049);
     // window 20 is unbeaten in [5706707.88, 31673814.95]
     bw6_761_G2::fixed_base_exp_window_table.push_back(5706708);
     // window 21 is never the best
     bw6_761_G2::fixed_base_exp_window_table.push_back(0);
     // window 22 is unbeaten in [31673814.95, inf]
     bw6_761_G2::fixed_base_exp_window_table.push_back(31673815);
  
     // Pairing parameters
     // See Algorithm 5 for Miller Loop: https://eprint.iacr.org/2020/351.pdf
     // ate_opt(P,Q) = (f_{u^3-u^2-u,Q}(P)f^{q}_{u+1,Q}(P))^(q^6 - 1)/r
     //
     // u+1
     bw6_761_ate_loop_count1 = bigint_q("9586122913090633730");
     // u^3-u^2-u
     bw6_761_ate_loop_count2 =
         bigint_q("880904806456922042166256752416502360955572640081583800319");
     bw6_761_ate_is_loop_count_neg = false;
     // u
     bw6_761_final_exponent_z = bigint_q("9586122913090633729");
     bw6_761_final_exponent_is_z_neg = false;
 }

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 38 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");
     edwards_Fr::static_init();
  
     /* 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");
     edwards_Fq::static_init();
  
     /* parameters for twist field Fq3 */
  
     edwards_Fq3::euler = bigint<3 * edwards_q_limbs>(
         "1197440827139715029629926131910678366982050433739789489038399345641529"
         "9485805128465854550297120332503183164742441311116131831414476564652505"
         "7914792711854057586688000");
     edwards_Fq3::s = 31;
     edwards_Fq3::t = bigint<3 * edwards_q_limbs>(
         "1115203674081447561858153093523046343570622088145268605126439915636116"
         "5908915110366283497118503164968623933142462103735778323760700006645643"
         "8894190557165125");
     edwards_Fq3::t_minus_1_over_2 = bigint<3 * edwards_q_limbs>(
         "5576018370407237809290765467615231717853110440726343025632199578180582"
         "9544575551831417485592515824843119665712310518678891618803500033228219"
         "447095278582562");
     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::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::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>(
         "3694310717796169464961879734644687013874865157861174841512820742949159"
         "3976636391130175425245705674550269561361208979548749447898941828686017"
         "7657304194168755396159416512697939289624688998560831692274575039424707"
         "21108165443528513330156264699608120624990672333642644221591552000");
     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 41 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("475922286169261325753349249653048451545124878552"
                               "823515553267735739164647307408490559963137");
     assert(mnt4_Fr::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         mnt4_Fr::Rsquared =
             bigint_r("163983144722506446826715124368972380525894397127205577781"
                      "234305496325861831001705438796139");
         mnt4_Fr::Rcubed =
             bigint_r("207236281459091063710247635236340312578688659363066707916"
                      "716212805695955118593239854980171");
         mnt4_Fr::inv = 0xbb4334a3ffffffff;
     }
     if (sizeof(mp_limb_t) == 4) {
         mnt4_Fr::Rsquared =
             bigint_r("163983144722506446826715124368972380525894397127205577781"
                      "234305496325861831001705438796139");
         mnt4_Fr::Rcubed =
             bigint_r("207236281459091063710247635236340312578688659363066707916"
                      "716212805695955118593239854980171");
         mnt4_Fr::inv = 0xffffffff;
     }
     mnt4_Fr::num_bits = 298;
     mnt4_Fr::euler = bigint_r("237961143084630662876674624826524225772562439276"
                               "411757776633867869582323653704245279981568");
     mnt4_Fr::s = 34;
     mnt4_Fr::t = bigint_r("2770232305450256248897344628657729199302411164115319"
                           "9339359284829066871159442729");
     mnt4_Fr::t_minus_1_over_2 =
         bigint_r("1385116152725128124448672314328864599651205582057659966967964"
                  "2414533435579721364");
     mnt4_Fr::multiplicative_generator = mnt4_Fr("10");
     mnt4_Fr::root_of_unity =
         mnt4_Fr("12063881782691317345876882948569009984537700803089161801010977"
                 "2937363554409782252579816313");
     mnt4_Fr::nqr = mnt4_Fr("5");
     mnt4_Fr::nqr_to_t = mnt4_Fr("4062206042430904010564294587302981459372625525"
                                 "08985450684842547562990900634752279902740880");
     mnt4_Fr::static_init();
  
     /* parameters for base field Fq */
     mnt4_modulus_q = bigint_q("475922286169261325753349249653048451545124879242"
                               "694725395555128576210262817955800483758081");
     assert(mnt4_Fq::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         mnt4_Fq::Rsquared =
             bigint_q("273000478523237720910981655601160860640083126627235719712"
                      "980612296263966512828033847775776");
         mnt4_Fq::Rcubed =
             bigint_q("427298980065529822574935274648041073124704261331681436071"
                      "990730954930769758106792920349077");
         mnt4_Fq::inv = 0xb071a1b67165ffff;
     }
     if (sizeof(mp_limb_t) == 4) {
         mnt4_Fq::Rsquared =
             bigint_q("273000478523237720910981655601160860640083126627235719712"
                      "980612296263966512828033847775776");
         mnt4_Fq::Rcubed =
             bigint_q("427298980065529822574935274648041073124704261331681436071"
                      "990730954930769758106792920349077");
         mnt4_Fq::inv = 0x7165ffff;
     }
     mnt4_Fq::num_bits = 298;
     mnt4_Fq::euler = bigint_q("237961143084630662876674624826524225772562439621"
                               "347362697777564288105131408977900241879040");
     mnt4_Fq::s = 17;
     mnt4_Fq::t = bigint_q("3630998887399759870554727551674258816109656366292531"
                           "779446068791017229177993437198515");
     mnt4_Fq::t_minus_1_over_2 =
         bigint_q("1815499443699879935277363775837129408054828183146265889723034"
                  "395508614588996718599257");
     mnt4_Fq::multiplicative_generator = mnt4_Fq("17");
     mnt4_Fq::root_of_unity =
         mnt4_Fq("26470625057180008075806930236965430553012567552126397603405487"
                 "8017580902343339784464690243");
     mnt4_Fq::nqr = mnt4_Fq("17");
     mnt4_Fq::nqr_to_t = mnt4_Fq("2647062505718000807580693023696543055301256755"
                                 "21263976034054878017580902343339784464690243");
     mnt4_Fq::static_init();
  
     /* parameters for twist field Fq2 */
     mnt4_Fq2::euler = bigint<2 * mnt4_q_limbs>(
         "1132510112362881350982493452491542308959143818587889181068472142434191"
         "4242292413349746081746824985483306726003898571037009192086083701428188"
         "6963086681184370139950267830740466401280");
     mnt4_Fq2::s = 18;
     mnt4_Fq2::t = bigint<2 * mnt4_q_limbs>(
         "8640366457846689994678447360927904578850889729216683815524842395280391"
         "1150302225873917249655341991297200973540485924049447571457547770905980"
         "6542104196047745818712370534824115");
     mnt4_Fq2::t_minus_1_over_2 = bigint<2 * mnt4_q_limbs>(
         "4320183228923344997339223680463952289425444864608341907762421197640195"
         "5575151112936958624827670995648600486770242962024723785728773885452990"
         "3271052098023872909356185267412057");
     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("29402818985595053196743631544512156561638230562612542604956687"
                 "802791427330205135130967658"));
     mnt4_Fq2::Frobenius_coeffs_c1[0] = mnt4_Fq("1");
     mnt4_Fq2::Frobenius_coeffs_c1[1] =
         mnt4_Fq("47592228616926132575334924965304845154512487924269472539555512"
                 "8576210262817955800483758080");
     mnt4_Fq2::static_init();
  
     /* 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("76841632454535016156213515524733370693010820609768050046250116"
                 "94147890954040864167002308");
     mnt4_Fq4::Frobenius_coeffs_c1[2] =
         mnt4_Fq("47592228616926132575334924965304845154512487924269472539555512"
                 "8576210262817955800483758080");
     mnt4_Fq4::Frobenius_coeffs_c1[3] =
         mnt4_Fq("46823812292380782413772789810057511447582379718171792039093011"
                 "6882062371863914936316755773");
  
     /* choice of short Weierstrass curve and its twist */
     mnt4_G1::coeff_a = mnt4_Fq("2");
     mnt4_G1::coeff_b = mnt4_Fq("42389453652668417828941601153388824002931810367"
                                "3896002803341544124054745019340795360841685");
     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("47592228616926132575334924965304845154512487924269472539555512"
                 "8576210262817955800483758080");
     mnt4_twist_mul_by_q_Y =
         mnt4_Fq("76841632454535016156213515524733370693010820609768050046250116"
                 "94147890954040864167002308");
  
     /* choice of group G1 */
     // Identities
     mnt4_G1::G1_zero =
         mnt4_G1(mnt4_Fq::zero(), mnt4_Fq::one(), mnt4_Fq::zero());
     mnt4_G1::G1_one = mnt4_G1(
         mnt4_Fq("60760244141852568949126569781626075788424196370144486719385562"
                 "369396875346601926534016838"),
         mnt4_Fq("36373285070258297826390277081514578445974772235707184397110767"
                 "4179038674942891694705904306"),
         mnt4_Fq::one());
  
     // Cofactor
     mnt4_G1::h = bigint<mnt4_G1::h_limbs>("1");
  
     // WNAF
     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 */
     // Identities
     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("4383749262193500998549191000778096818427835091637909918478"
                     "67546339851681564223481322252708"),
             mnt4_Fq("3762095361550048011093551436092327860546447645971239327767"
                     "9280819942849043649216370485641")),
         mnt4_Fq2(
             mnt4_Fq("3743740900852896826835252103493693184297354644137066311854"
                     "3015118291998305624025037512482"),
             mnt4_Fq("4246214795988938826723931903374206805975846958923171976461"
                     "13820787463109735345923009077489")),
         mnt4_Fq2::one());
  
     // Cofactor
     mnt4_G2::h = bigint<mnt4_G2::h_limbs>(
         "4759222861692613257533492496530484515451248799325659352378425214132558"
         "78328503110407553025");
  
     // WNAF
     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>(
         "1077973603571099034307944903095920722789277838030318543579109081219034"
         "3983877286149717711641082558674308976086994539461051191727497797155906"
         "2689561855016270594656570874331111995170645233717143416875749097203441"
         "437192367065467706065411650403684877366879441766585988546560");
     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 43 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("475922286169261325753349249653048451545124879242"
                               "694725395555128576210262817955800483758081");
     assert(mnt6_Fr::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         mnt6_Fr::Rsquared =
             bigint_r("273000478523237720910981655601160860640083126627235719712"
                      "980612296263966512828033847775776");
         mnt6_Fr::Rcubed =
             bigint_r("427298980065529822574935274648041073124704261331681436071"
                      "990730954930769758106792920349077");
         mnt6_Fr::inv = 0xb071a1b67165ffff;
     }
     if (sizeof(mp_limb_t) == 4) {
         mnt6_Fr::Rsquared =
             bigint_r("273000478523237720910981655601160860640083126627235719712"
                      "980612296263966512828033847775776");
         mnt6_Fr::Rcubed =
             bigint_r("427298980065529822574935274648041073124704261331681436071"
                      "990730954930769758106792920349077");
         mnt6_Fr::inv = 0x7165ffff;
     }
     mnt6_Fr::num_bits = 298;
     mnt6_Fr::euler = bigint_r("237961143084630662876674624826524225772562439621"
                               "347362697777564288105131408977900241879040");
     mnt6_Fr::s = 17;
     mnt6_Fr::t = bigint_r("3630998887399759870554727551674258816109656366292531"
                           "779446068791017229177993437198515");
     mnt6_Fr::t_minus_1_over_2 =
         bigint_r("1815499443699879935277363775837129408054828183146265889723034"
                  "395508614588996718599257");
     mnt6_Fr::multiplicative_generator = mnt6_Fr("17");
     mnt6_Fr::root_of_unity =
         mnt6_Fr("26470625057180008075806930236965430553012567552126397603405487"
                 "8017580902343339784464690243");
     mnt6_Fr::nqr = mnt6_Fr("17");
     mnt6_Fr::nqr_to_t = mnt6_Fr("2647062505718000807580693023696543055301256755"
                                 "21263976034054878017580902343339784464690243");
     mnt6_Fr::static_init();
  
     /* parameters for base field Fq */
     mnt6_modulus_q = bigint_q("475922286169261325753349249653048451545124878552"
                               "823515553267735739164647307408490559963137");
     assert(mnt6_Fq::modulus_is_valid());
     if (sizeof(mp_limb_t) == 8) {
         mnt6_Fq::Rsquared =
             bigint_q("163983144722506446826715124368972380525894397127205577781"
                      "234305496325861831001705438796139");
         mnt6_Fq::Rcubed =
             bigint_q("207236281459091063710247635236340312578688659363066707916"
                      "716212805695955118593239854980171");
         mnt6_Fq::inv = 0xbb4334a3ffffffff;
     }
     if (sizeof(mp_limb_t) == 4) {
         mnt6_Fq::Rsquared =
             bigint_q("163983144722506446826715124368972380525894397127205577781"
                      "234305496325861831001705438796139");
         mnt6_Fq::Rcubed =
             bigint_q("207236281459091063710247635236340312578688659363066707916"
                      "716212805695955118593239854980171");
         mnt6_Fq::inv = 0xffffffff;
     }
     mnt6_Fq::num_bits = 298;
     mnt6_Fq::euler = bigint_q("237961143084630662876674624826524225772562439276"
                               "411757776633867869582323653704245279981568");
     mnt6_Fq::s = 34;
     mnt6_Fq::t = bigint_q("2770232305450256248897344628657729199302411164115319"
                           "9339359284829066871159442729");
     mnt6_Fq::t_minus_1_over_2 =
         bigint_q("1385116152725128124448672314328864599651205582057659966967964"
                  "2414533435579721364");
     mnt6_Fq::multiplicative_generator = mnt6_Fq("10");
     mnt6_Fq::root_of_unity =
         mnt6_Fq("12063881782691317345876882948569009984537700803089161801010977"
                 "2937363554409782252579816313");
     mnt6_Fq::nqr = mnt6_Fq("5");
     mnt6_Fq::nqr_to_t = mnt6_Fq("4062206042430904010564294587302981459372625525"
                                 "08985450684842547562990900634752279902740880");
     mnt6_Fq::static_init();
  
     /* parameters for twist field Fq3 */
     mnt6_Fq3::euler = bigint<3 * mnt6_q_limbs>(
         "5389868017855495171539724515479603613946389158900147862919313636912491"
         "5637741423690184935056189295242736833704290747216410090671804540908400"
         "2107789344621296256462630953983234857955575512841902241668515716158341"
         "94321908328559167529729507439069424158411618728014749106176");
     mnt6_Fq3::s = 34;
     mnt6_Fq3::t = bigint<3 * mnt6_q_limbs>(
         "6274632199033507112809136178669989590936327770934612330653836993631547"
         "7403976749268110067416202853483540045218880692515999649967770721889566"
         "8755040206738394052328810740708414066996862544726932237004530285669423"
         "1080113482726640944570478452261237446033817102203");
     mnt6_Fq3::t_minus_1_over_2 = bigint<3 * mnt6_q_limbs>(
         "3137316099516753556404568089334994795468163885467306165326918496815773"
         "8701988374634055033708101426741770022609440346257999824983885360944783"
         "4377520103369197026164405370354207033498431272363466118502265142834711"
         "5540056741363320472285239226130618723016908551101");
     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("15436144967878350507698415627597793765433110336117446963234623"
                 "0549735979552469642799720052"),
         mnt6_Fq("0"),
         mnt6_Fq("0"));
     mnt6_Fq3::Frobenius_coeffs_c1[0] = mnt6_Fq("1");
     mnt6_Fq3::Frobenius_coeffs_c1[1] =
         mnt6_Fq("47173889896752102913304085131844916599730410872955897377007731"
                 "9830005517129946578866686956");
     mnt6_Fq3::Frobenius_coeffs_c1[2] =
         mnt6_Fq("41833872017402966203083983345992855478207698232645417831904159"
                 "09159130177461911693276180");
     mnt6_Fq3::Frobenius_coeffs_c2[0] = mnt6_Fq("1");
     mnt6_Fq3::Frobenius_coeffs_c2[1] =
         mnt6_Fq("41833872017402966203083983345992855478207698232645417831904159"
                 "09159130177461911693276180");
     mnt6_Fq3::Frobenius_coeffs_c2[2] =
         mnt6_Fq("47173889896752102913304085131844916599730410872955897377007731"
                 "9830005517129946578866686956");
  
     /* 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("47173889896752102913304085131844916599730410872955897377007731"
                 "9830005517129946578866686957");
     mnt6_Fq6::Frobenius_coeffs_c1[2] =
         mnt6_Fq("47173889896752102913304085131844916599730410872955897377007731"
                 "9830005517129946578866686956");
     mnt6_Fq6::Frobenius_coeffs_c1[3] =
         mnt6_Fq("47592228616926132575334924965304845154512487855282351555326773"
                 "5739164647307408490559963136");
     mnt6_Fq6::Frobenius_coeffs_c1[4] =
         mnt6_Fq("41833872017402966203083983345992855478207698232645417831904159"
                 "09159130177461911693276180");
     mnt6_Fq6::Frobenius_coeffs_c1[5] =
         mnt6_Fq("41833872017402966203083983345992855478207698232645417831904159"
                 "09159130177461911693276181");
     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("10670008051085173567796731963258535225645425120"
                                "1367587890185989362936000262606668469523074");
     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("41833872017402966203083983345992855478207698232645417831904159"
                 "09159130177461911693276180");
     mnt6_twist_mul_by_q_Y =
         mnt6_Fq("47592228616926132575334924965304845154512487855282351555326773"
                 "5739164647307408490559963136");
  
     /* choice of group G1 */
     // Identities
     mnt6_G1::G1_zero =
         mnt6_G1(mnt6_Fq::zero(), mnt6_Fq::one(), mnt6_Fq::zero());
     mnt6_G1::G1_one = mnt6_G1(
         mnt6_Fq("33668575288308222810928984635393710418569820937140417834296883"
                 "8739115829740084426881123453"),
         mnt6_Fq("40259629013978098970933270771656892077762203207376274986234237"
                 "4583908837063963736098549800"),
         mnt6_Fq::one());
  
     // Cofactor
     mnt6_G1::h = bigint<mnt6_G1::h_limbs>("1");
  
     // WNAF
     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 */
     // Identities
     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("4214564357728118462568265615939083222885091154891199075603"
                     "82401870203318738334702321297427"),
             mnt6_Fq("1030729274385485024635270099613449150211675847064399454049"
                     "59058962657261178393635706405114"),
             mnt6_Fq("1430291721437318526270029263247351838097683633011490092048"
                     "49580478324784395590388826052558")),
         mnt6_Fq3(
             mnt6_Fq("4646735966686894631300992275756395125412181334453888693838"
                     "93594087634649237515554342751377"),
             mnt6_Fq("1006429075019773751845750759671180718078211179601527433356"
                     "03284583254620685343989304941678"),
             mnt6_Fq("1230198555029698960269405457158411813002751801572880446630"
                     "51565390506010149881373807142903")),
         mnt6_Fq3::one());
  
     // Cofactor
     mnt6_G2::h = bigint<mnt6_G2::h_limbs>(
         "2265020224725762701964986904983084617918287627326025861622075353519602"
         "7008271269497733337236154908221451925226173504813188901850140437785678"
         "6623430385820659037970876666767495659520");
  
     // WNAF
     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>(
         "2441632013809050969789059541431343876835397748986254393590401071543906"
         "6975957855922532159264213056712140358746422742237328406558352706591021"
         "6422306180605028554512640453974447931868761990152567816487468886255270"
         "7546606307501130780086217376423631134210521168112142693161684363521585"
         "2236649271569251468773714424208521977615548771268520882870120900360322"
         "0442188067120277293518453076904749855025875277538472001305920580983636"
         "41559341826790559426614919168");
     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 69 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 84 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 305 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 )

returns ceil(log2(n)), so 1ul<<log2(n) is the smallest power of 2, that is not less than 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 290 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;
  
     // D = X1 - X2*Z1
     const alt_bn128_Fq2 D = X1 - x2 * Z1;
     // E = Y1 - Y2*Z1
     const alt_bn128_Fq2 E = Y1 - y2 * Z1;
     // F = D^2
     const alt_bn128_Fq2 F = D.squared();
     // G = E^2
     const alt_bn128_Fq2 G = E.squared();
     // H = D*F
     const alt_bn128_Fq2 H = D * F;
     // I = X1 * F
     const alt_bn128_Fq2 I = X1 * F;
     // J = H + Z1*G - (I+I)
     const alt_bn128_Fq2 J = H + Z1 * G - (I + I);
  
     // X3 = D*J
     current.X = D * J;
     // Y3 = E*(I-J)-(H*Y1)
     current.Y = E * (I - J) - (H * Y1);
     // Z3 = Z1*H
     current.Z = Z1 * H;
     // ell_0 = xi * (E * X2 - D * Y2)
     c.ell_0 = alt_bn128_twist * (E * x2 - D * y2);
     // ell_VV = - E (later: * xP)
     c.ell_VV = -E;
     // ell_VW = D (later: * yP)
     c.ell_VW = D;
 }

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 570 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 429 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 434 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() [1/2]

void libff::mixed_addition_step_for_miller_loop	(	const bw6_761_G2	base,
		bw6_761_G2 &	current,
		bw6_761_ate_ell_coeffs &	c
	)

Definition at line 319 of file bw6_761_pairing.cpp.

 {
     const bw6_761_Fq X1 = current.X, Y1 = current.Y, Z1 = current.Z;
     const bw6_761_Fq &X2 = base.X, &Y2 = base.Y;
  
     // D = X1 - X2*Z1
     const bw6_761_Fq D = X1 - X2 * Z1;
     // E = Y1 - Y2*Z1
     const bw6_761_Fq E = Y1 - Y2 * Z1;
     // F = D^2
     const bw6_761_Fq F = D.squared();
     // G = E^2
     const bw6_761_Fq G = E.squared();
     // H = D*F
     const bw6_761_Fq H = D * F;
     // I = X1 * F
     const bw6_761_Fq I = X1 * F;
     // J = H + Z1*G - (I+I)
     const bw6_761_Fq J = H + Z1 * G - (I + I);
  
     // X3 = D*J
     current.X = D * J;
     // Y3 = E*(I-J)-(H*Y1)
     current.Y = E * (I - J) - (H * Y1);
     // Z3 = Z1*H
     current.Z = Z1 * H;
  
     c.ell_0 = E * X2 - D * Y2;
     // VV gets multiplied to xP during line evaluation at P
     c.ell_VV = -E;
     // VW gets multiplied to yP during line evaluation at P
     c.ell_VW = bw6_761_twist * D;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mixed_addition_step_for_miller_loop() [2/2]

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 334 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 call 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 318 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 224 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 241 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 730 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 595 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 539 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 */
         const mnt4_ate_dbl_coeffs &dc = prec_Q.dbl_coeffs[dbl_idx++];
  
         const 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) {
             const mnt4_ate_add_coeffs &ac = prec_Q.add_coeffs[add_idx++];
  
             const 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 463 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 480 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 207 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 191 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 172 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 720 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 323 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 228 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 245 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 605 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 548 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 689 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 468 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 485 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 699 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 724 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 211 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 192 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 173 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 718 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 733 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 708 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 713 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 738 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, multi_exp_base_form BaseForm = multi_exp_base_form_normal>

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 processed in parallel.

◆ multi_exp_filter_one_zero()

template<typename T , typename FieldT , multi_exp_method Method, multi_exp_base_form BaseForm = multi_exp_base_form_normal>

T libff::multi_exp_filter_one_zero	(	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 which includes special pre-processing step to skip zeros, and directly sum base elements with factor 1. Remaining values are processed as usual via multi_exp.

◆ multi_exp_stream()

template<form_t Form, compression_t Comp, typename GroupT , typename FieldT >

GroupT libff::multi_exp_stream	(	std::istream &	base_elements_in,
		const std::vector< FieldT > &	exponents
	)

Read base elements from a stream. More intermediate memory is used (offset by the fact that base elements are streamed and therefore not all memory-resident) to reduce the number of internal passes. Currently processing is single-threaded (although element streaming happens in a separate temporary thread).

◆ multi_exp_stream_with_precompute()

template<form_t Form, compression_t Comp, typename GroupT , typename FieldT >

GroupT libff::multi_exp_stream_with_precompute	(	std::istream &	precomputed_elements_in,
		const std::vector< FieldT > &	exponents,
		const size_t	precompute_c
	)

Perform optimal multiexp using precomputed elements from a stream. The stream is expected to be formatted as follows: For each original base element e_i: e_i, [2^c] e_i, [2^2c] e_i, .... [2^(b-1)c] e_i where c is the digit size (in bits) to be used in the BDLO12_signed algorithm, and b = (FieldT::num_bits + c - 1) / c is the number of digits required to fully represent a scalar value.

Optimal c can be computed with bdlo12_signed_optimal_c().

◆ op_profiling_enter()

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

Definition at line 264 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/42]

template<mp_size_t m>

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

Definition at line 99 of file alt_bn128_g1.hpp.

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

◆ operator*() [2/42]

template<mp_size_t m>

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

Definition at line 103 of file alt_bn128_g2.hpp.

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

◆ operator*() [3/42]

template<mp_size_t m>

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

Definition at line 112 of file bls12_377_g1.hpp.

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

◆ operator*() [4/42]

template<mp_size_t m>

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

Definition at line 104 of file bls12_377_g2.hpp.

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

◆ operator*() [5/42]

template<mp_size_t m>

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

Definition at line 99 of file bls12_381_g1.hpp.

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

◆ operator*() [6/42]

template<mp_size_t m>

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

Definition at line 106 of file bls12_381_g2.hpp.

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

◆ operator*() [7/42]

template<mp_size_t m>

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

Definition at line 106 of file bn128_g1.hpp.

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

◆ operator*() [8/42]

template<mp_size_t m>

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

Definition at line 106 of file bn128_g2.hpp.

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

◆ operator*() [9/42]

template<mp_size_t m>

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

Definition at line 94 of file bw6_761_g1.hpp.

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

◆ operator*() [10/42]

template<mp_size_t m>

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

Definition at line 98 of file bw6_761_g2.hpp.

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

◆ operator*() [11/42]

template<mp_size_t m>

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

Definition at line 92 of file edwards_g1.hpp.

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

◆ operator*() [12/42]

template<mp_size_t m>

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

Definition at line 99 of file edwards_g2.hpp.

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

◆ operator*() [13/42]

template<mp_size_t m>

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

Definition at line 106 of file mnt4_g1.hpp.

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

◆ operator*() [14/42]

template<mp_size_t m>

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

Definition at line 106 of file mnt4_g2.hpp.

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

◆ operator*() [15/42]

template<mp_size_t m>

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

Definition at line 109 of file mnt6_g1.hpp.

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

◆ operator*() [16/42]

template<mp_size_t m>

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

Definition at line 111 of file mnt6_g2.hpp.

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

◆ operator*() [17/42]

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*() [18/42]

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*() [19/42]

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*() [20/42]

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*() [21/42]

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 105 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*() [22/42]

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 109 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*() [23/42]

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

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

Definition at line 118 of file bls12_377_g1.hpp.

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

Here is the call graph for this function:

◆ operator*() [24/42]

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

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

Definition at line 110 of file bls12_377_g2.hpp.

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

Here is the call graph for this function:

◆ operator*() [25/42]

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

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

Definition at line 105 of file bls12_381_g1.hpp.

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

Here is the call graph for this function:

◆ operator*() [26/42]

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

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

Definition at line 112 of file bls12_381_g2.hpp.

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

Here is the call graph for this function:

◆ operator*() [27/42]

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 112 of file bn128_g1.hpp.

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

Here is the call graph for this function:

◆ operator*() [28/42]

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 112 of file bn128_g2.hpp.

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

Here is the call graph for this function:

◆ operator*() [29/42]

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

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

Definition at line 100 of file bw6_761_g1.hpp.

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

Here is the call graph for this function:

◆ operator*() [30/42]

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

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

Definition at line 104 of file bw6_761_g2.hpp.

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

Here is the call graph for this function:

◆ operator*() [31/42]

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 98 of file edwards_g1.hpp.

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

Here is the call graph for this function:

◆ operator*() [32/42]

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 105 of file edwards_g2.hpp.

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

Here is the call graph for this function:

◆ operator*() [33/42]

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 112 of file mnt4_g1.hpp.

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

Here is the call graph for this function:

◆ operator*() [34/42]

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 112 of file mnt4_g2.hpp.

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

Here is the call graph for this function:

◆ operator*() [35/42]

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 115 of file mnt6_g1.hpp.

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

Here is the call graph for this function:

◆ operator*() [36/42]

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 117 of file mnt6_g2.hpp.

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

Here is the call graph for this function:

◆ operator*() [37/42]

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*() [38/42]

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*() [39/42]

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*() [40/42]

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*() [41/42]

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*() [42/42]

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/62]

template<mp_size_t n>

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

◆ operator<<() [2/62]

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

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

◆ operator<<() [3/62]

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

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

◆ operator<<() [4/62]

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

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

◆ operator<<() [5/62]

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

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

◆ operator<<() [6/62]

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

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

◆ operator<<() [7/62]

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

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

◆ operator<<() [8/62]

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

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

◆ operator<<() [9/62]

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

Definition at line 49 of file alt_bn128_pairing.cpp.

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

◆ operator<<() [10/62]

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<<() [11/62]

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

Definition at line 75 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<<() [12/62]

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

Definition at line 436 of file alt_bn128_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [13/62]

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

Definition at line 466 of file alt_bn128_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [14/62]

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

Definition at line 42 of file bls12_377_pairing.cpp.

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

◆ operator<<() [15/62]

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

Definition at line 17 of file bls12_377_pairing.cpp.

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

◆ operator<<() [16/62]

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

Definition at line 68 of file bls12_377_pairing.cpp.

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

◆ operator<<() [17/62]

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

Definition at line 492 of file bls12_377_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [18/62]

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

Definition at line 551 of file bls12_377_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [19/62]

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

Definition at line 49 of file bls12_381_pairing.cpp.

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

◆ operator<<() [20/62]

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

Definition at line 24 of file bls12_381_pairing.cpp.

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

◆ operator<<() [21/62]

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

Definition at line 75 of file bls12_381_pairing.cpp.

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

◆ operator<<() [22/62]

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

Definition at line 421 of file bls12_381_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [23/62]

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

Definition at line 443 of file bls12_381_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [24/62]

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<<() [25/62]

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

Definition at line 75 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<<() [26/62]

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

Definition at line 449 of file bn128_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [27/62]

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

Definition at line 463 of file bn128_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [28/62]

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

Definition at line 42 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<<() [29/62]

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

Definition at line 42 of file bw6_761_pairing.cpp.

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

◆ operator<<() [30/62]

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

Definition at line 17 of file bw6_761_pairing.cpp.

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

◆ operator<<() [31/62]

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

Definition at line 113 of file bw6_761_pairing.cpp.

 {
     out << prec_Q.precomp_1 << OUTPUT_SEPARATOR << prec_Q.precomp_2 << "\n";
     return out;
 }

◆ operator<<() [32/62]

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

Definition at line 68 of file bw6_761_pairing.cpp.

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

◆ operator<<() [33/62]

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

Definition at line 416 of file bw6_761_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [34/62]

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

Definition at line 427 of file bw6_761_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [35/62]

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

Definition at line 162 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<<() [36/62]

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

Definition at line 122 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<<() [37/62]

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

Definition at line 104 of file edwards_pairing.cpp.

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

◆ operator<<() [38/62]

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

Definition at line 26 of file edwards_pairing.cpp.

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

◆ operator<<() [39/62]

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

Definition at line 368 of file edwards_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [40/62]

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

Definition at line 426 of file edwards_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [41/62]

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

Definition at line 44 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<<() [42/62]

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

Definition at line 81 of file edwards_pairing.cpp.

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

◆ operator<<() [43/62]

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

Definition at line 85 of file mnt4_pairing.cpp.

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

◆ operator<<() [44/62]

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

Definition at line 60 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<<() [45/62]

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

Definition at line 32 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<<() [46/62]

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

Definition at line 109 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<<() [47/62]

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

Definition at line 507 of file mnt4_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [48/62]

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

Definition at line 558 of file mnt4_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [49/62]

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

Definition at line 85 of file mnt6_pairing.cpp.

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

◆ operator<<() [50/62]

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

Definition at line 60 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<<() [51/62]

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

Definition at line 32 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<<() [52/62]

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

Definition at line 110 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<<() [53/62]

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

Definition at line 524 of file mnt6_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [54/62]

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

Definition at line 575 of file mnt6_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     g.write_uncompressed(out);
 #else
     g.write_compressed(out);
 #endif
     return out;
 }

Here is the call graph for this function:

◆ operator<<() [55/62]

template<typename T1 , typename T2 >

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

◆ operator<<() [56/62]

template<typename T >

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

◆ operator<<() [57/62]

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<<() [58/62]

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<<() [59/62]

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<<() [60/62]

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<<() [61/62]

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<<() [62/62]

template<typename T >

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

◆ operator>>() [1/62]

template<mp_size_t n>

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

◆ operator>>() [2/62]

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

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

◆ operator>>() [3/62]

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

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

◆ operator>>() [4/62]

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

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

◆ operator>>() [5/62]

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

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

◆ operator>>() [6/62]

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

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

◆ operator>>() [7/62]

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

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

◆ operator>>() [8/62]

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

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

◆ operator>>() [9/62]

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

Definition at line 56 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;
 }

Here is the call graph for this function:

◆ operator>>() [10/62]

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

Definition at line 32 of file alt_bn128_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [11/62]

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

Definition at line 86 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;
 }

Here is the call graph for this function:

◆ operator>>() [12/62]

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

Definition at line 446 of file alt_bn128_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     alt_bn128_G1::read_uncompressed(in, g);
 #else
     alt_bn128_G1::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [13/62]

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

Definition at line 476 of file alt_bn128_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     alt_bn128_G2::read_uncompressed(in, g);
 #else
     alt_bn128_G2::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [14/62]

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

Definition at line 49 of file bls12_377_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [15/62]

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

Definition at line 25 of file bls12_377_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [16/62]

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

Definition at line 79 of file bls12_377_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) {
         bls12_377_ate_ell_coeffs c;
         in >> c;
         consume_OUTPUT_NEWLINE(in);
         prec_Q.coeffs.emplace_back(c);
     }
  
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [17/62]

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

Definition at line 502 of file bls12_377_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     bls12_377_G1::read_uncompressed(in, g);
 #else
     bls12_377_G1::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [18/62]

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

Definition at line 561 of file bls12_377_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     bls12_377_G2::read_uncompressed(in, g);
 #else
     bls12_377_G2::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [19/62]

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

Definition at line 56 of file bls12_381_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [20/62]

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

Definition at line 32 of file bls12_381_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [21/62]

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

Definition at line 87 of file bls12_381_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) {
         bls12_381_ate_ell_coeffs c;
         in >> c;
         consume_OUTPUT_NEWLINE(in);
         prec_Q.coeffs.emplace_back(c);
     }
  
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [22/62]

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

Definition at line 431 of file bls12_381_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     bls12_381_G1::read_uncompressed(in, g);
 #else
     bls12_381_G1::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [23/62]

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

Definition at line 453 of file bls12_381_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     bls12_381_G2::read_uncompressed(in, g);
 #else
     bls12_381_G2::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [24/62]

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

Definition at line 41 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;
 }

Here is the call graph for this function:

◆ operator>>() [25/62]

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

Definition at line 116 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;
 }

Here is the call graph for this function:

◆ operator>>() [26/62]

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

Definition at line 459 of file bn128_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     bn128_G1::read_uncompressed(in, g);
 #else
     bn128_G1::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [27/62]

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

Definition at line 473 of file bn128_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     bn128_G2::read_uncompressed(in, g);
 #else
     bn128_G2::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [28/62]

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

Definition at line 53 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;
 }

Here is the call graph for this function:

◆ operator>>() [29/62]

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

Definition at line 49 of file bw6_761_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [30/62]

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

Definition at line 25 of file bw6_761_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [31/62]

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

Definition at line 120 of file bw6_761_pairing.cpp.

 {
     in >> prec_Q.precomp_1;
     consume_OUTPUT_SEPARATOR(in);
     in >> prec_Q.precomp_2;
     consume_newline(in);
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [32/62]

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

Definition at line 79 of file bw6_761_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) {
         bw6_761_ate_ell_coeffs c;
         in >> c;
         consume_OUTPUT_NEWLINE(in);
         prec_Q.coeffs.emplace_back(c);
     }
  
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [33/62]

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

Definition at line 479 of file bw6_761_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     bw6_761_G1::read_uncompressed(in, g);
 #else
     bw6_761_G1::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [34/62]

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

Definition at line 488 of file bw6_761_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     bw6_761_G2::read_uncompressed(in, g);
 #else
     bw6_761_G2::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [35/62]

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

Definition at line 171 of file edwards_pairing.cpp.

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

◆ operator>>() [36/62]

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

Definition at line 133 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>>() [37/62]

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

Definition at line 112 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;
 }

Here is the call graph for this function:

◆ operator>>() [38/62]

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

Definition at line 34 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;
 }

Here is the call graph for this function:

◆ operator>>() [39/62]

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

Definition at line 378 of file edwards_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     edwards_G1::read_uncompressed(in, g);
 #else
     edwards_G1::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [40/62]

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

Definition at line 436 of file edwards_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     edwards_G2::read_uncompressed(in, g);
 #else
     edwards_G2::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [41/62]

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

Definition at line 55 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>>() [42/62]

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

Definition at line 88 of file edwards_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [43/62]

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

Definition at line 91 of file mnt4_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [44/62]

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;
 }

Here is the call graph for this function:

◆ operator>>() [45/62]

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;
 }

Here is the call graph for this function:

◆ operator>>() [46/62]

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

Definition at line 126 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;
 }

Here is the call graph for this function:

◆ operator>>() [47/62]

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

Definition at line 517 of file mnt4_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     mnt4_G1::read_uncompressed(in, g);
 #else
     mnt4_G1::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [48/62]

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

Definition at line 568 of file mnt4_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     mnt4_G2::read_uncompressed(in, g);
 #else
     mnt4_G2::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [49/62]

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

Definition at line 91 of file mnt6_pairing.cpp.

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

Here is the call graph for this function:

◆ operator>>() [50/62]

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;
 }

Here is the call graph for this function:

◆ operator>>() [51/62]

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;
 }

Here is the call graph for this function:

◆ operator>>() [52/62]

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

Definition at line 127 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;
 }

Here is the call graph for this function:

◆ operator>>() [53/62]

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

Definition at line 534 of file mnt6_g1.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     mnt6_G1::read_uncompressed(in, g);
 #else
     mnt6_G1::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [54/62]

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

Definition at line 585 of file mnt6_g2.cpp.

 {
 #ifdef NO_PT_COMPRESSION
     mnt6_G2::read_uncompressed(in, g);
 #else
     mnt6_G2::read_compressed(in, g);
 #endif
     return in;
 }

Here is the call graph for this function:

◆ operator>>() [55/62]

template<typename T1 , typename T2 >

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

◆ operator>>() [56/62]

template<typename T >

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

◆ operator>>() [57/62]

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>>() [58/62]

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

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

◆ operator>>() [59/62]

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

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

◆ operator>>() [60/62]

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>>() [61/62]

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>>() [62/62]

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 45 of file bn128_gt.hpp.

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

◆ 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 375 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 144 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
 }

Here is the call graph for this function:

◆ print_cumulative_time_entry()

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

Definition at line 118 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 136 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 248 of file profiling.cpp.

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

◆ print_indent()

void libff::print_indent ( )

Definition at line 257 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 354 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
     UNUSED(s);
     printf("* Memory profiling not supported in NO_PROCPS mode\n");
 #endif
 }

Here is the call graph for this function:

◆ print_op_profiling()

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

Definition at line 176 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 227 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:

◆ print_vector()

template<typename FieldT >

void libff::print_vector ( const std::vector< FieldT > & v )

print the elements of a vector

◆ reserialize()

template<typename T >

T libff::reserialize ( const T & obj )

◆ scalar_mul()

template<typename GroupT , mp_size_t m>

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

◆ serialize_bit_vector()

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

Definition at line 103 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 )

◆ 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 65 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:

◆ to_twos_complement()

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

Definition at line 46 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 && ... )

A variadic template to suppress unused argument warnings.

Definition at line 45 of file utils.hpp.

45 {}

Here is the caller graph for this function:

◆ update_wnaf()

template<mp_size_t n>

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

Find the wNAF representation of the given scalar relative to the given window size, reusing the given vector to store it.

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

◆ wnaf_opt_window_size()

template<typename T >

size_t libff::wnaf_opt_window_size ( const size_t scalar_bits )

Compute optimal window size.

Variable Documentation

◆ alt_bn128_ate_is_loop_count_neg

bool libff::alt_bn128_ate_is_loop_count_neg

Definition at line 27 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 26 of file alt_bn128_init.cpp.

◆ alt_bn128_coeff_b

alt_bn128_Fq libff::alt_bn128_coeff_b

Definition at line 18 of file alt_bn128_init.cpp.

◆ alt_bn128_final_exponent

bigint< 12 *alt_bn128_q_limbs > libff::alt_bn128_final_exponent

Definition at line 28 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 30 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 29 of file alt_bn128_init.cpp.

◆ alt_bn128_modulus_q

bigint< alt_bn128_q_limbs > libff::alt_bn128_modulus_q

Definition at line 16 of file alt_bn128_init.cpp.

◆ alt_bn128_modulus_r

bigint< alt_bn128_r_limbs > libff::alt_bn128_modulus_r

Definition at line 15 of file alt_bn128_init.cpp.

◆ alt_bn128_q_bitcount

const mp_size_t libff::alt_bn128_q_bitcount = 254

Definition at line 20 of file alt_bn128_init.hpp.

◆ alt_bn128_q_limbs

const mp_size_t libff::alt_bn128_q_limbs

Initial value:

=

(alt_bn128_q_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 24 of file alt_bn128_init.hpp.

◆ alt_bn128_r_bitcount

const mp_size_t libff::alt_bn128_r_bitcount = 254

Definition at line 19 of file alt_bn128_init.hpp.

◆ alt_bn128_r_limbs

const mp_size_t libff::alt_bn128_r_limbs

Initial value:

=

(alt_bn128_r_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 22 of file alt_bn128_init.hpp.

◆ alt_bn128_twist

alt_bn128_Fq2 libff::alt_bn128_twist

Definition at line 19 of file alt_bn128_init.cpp.

◆ alt_bn128_twist_coeff_b

alt_bn128_Fq2 libff::alt_bn128_twist_coeff_b

Definition at line 20 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 21 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 22 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 23 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 24 of file alt_bn128_init.cpp.

◆ block_names

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

Definition at line 88 of file profiling.cpp.

◆ bls12_377_ate_is_loop_count_neg

bool libff::bls12_377_ate_is_loop_count_neg

Definition at line 44 of file bls12_377_init.cpp.

◆ bls12_377_ate_loop_count

bigint< bls12_377_q_limbs > libff::bls12_377_ate_loop_count

Definition at line 43 of file bls12_377_init.cpp.

◆ bls12_377_coeff_b

bls12_377_Fq libff::bls12_377_coeff_b

Definition at line 16 of file bls12_377_init.cpp.

◆ bls12_377_final_exponent

bigint< 12 *bls12_377_q_limbs > libff::bls12_377_final_exponent

Definition at line 46 of file bls12_377_init.cpp.

◆ bls12_377_final_exponent_is_z_neg

bool libff::bls12_377_final_exponent_is_z_neg

Definition at line 48 of file bls12_377_init.cpp.

◆ bls12_377_final_exponent_z

bigint< bls12_377_q_limbs > libff::bls12_377_final_exponent_z

Definition at line 47 of file bls12_377_init.cpp.

◆ bls12_377_g1_endomorphism_beta

bls12_377_Fq libff::bls12_377_g1_endomorphism_beta

Definition at line 26 of file bls12_377_init.cpp.

◆ bls12_377_g1_proof_of_safe_subgroup_non_member_x

bls12_377_Fq libff::bls12_377_g1_proof_of_safe_subgroup_non_member_x

Definition at line 29 of file bls12_377_init.cpp.

◆ bls12_377_g1_proof_of_safe_subgroup_non_member_y

bls12_377_Fq libff::bls12_377_g1_proof_of_safe_subgroup_non_member_y

Definition at line 30 of file bls12_377_init.cpp.

◆ bls12_377_g1_proof_of_safe_subgroup_w

bigint< bls12_377_r_limbs > libff::bls12_377_g1_proof_of_safe_subgroup_w

Definition at line 28 of file bls12_377_init.cpp.

◆ bls12_377_g1_safe_subgroup_check_c1

bigint< bls12_377_r_limbs > libff::bls12_377_g1_safe_subgroup_check_c1

Definition at line 27 of file bls12_377_init.cpp.

◆ bls12_377_g2_mul_by_cofactor_h2_0

bigint< bls12_377_r_limbs > libff::bls12_377_g2_mul_by_cofactor_h2_0

Definition at line 40 of file bls12_377_init.cpp.

◆ bls12_377_g2_mul_by_cofactor_h2_1

bigint< bls12_377_r_limbs > libff::bls12_377_g2_mul_by_cofactor_h2_1

Definition at line 41 of file bls12_377_init.cpp.

◆ bls12_377_g2_untwist_frobenius_twist_v

bls12_377_Fq12 libff::bls12_377_g2_untwist_frobenius_twist_v

Definition at line 34 of file bls12_377_init.cpp.

◆ bls12_377_g2_untwist_frobenius_twist_v_inverse

bls12_377_Fq12 libff::bls12_377_g2_untwist_frobenius_twist_v_inverse

Definition at line 36 of file bls12_377_init.cpp.

◆ bls12_377_g2_untwist_frobenius_twist_w

bls12_377_Fq12 libff::bls12_377_g2_untwist_frobenius_twist_w

Definition at line 33 of file bls12_377_init.cpp.

◆ bls12_377_g2_untwist_frobenius_twist_w_3

bls12_377_Fq12 libff::bls12_377_g2_untwist_frobenius_twist_w_3

Definition at line 35 of file bls12_377_init.cpp.

◆ bls12_377_g2_untwist_frobenius_twist_w_3_inverse

bls12_377_Fq12 libff::bls12_377_g2_untwist_frobenius_twist_w_3_inverse

Definition at line 37 of file bls12_377_init.cpp.

◆ bls12_377_modulus_r

bigint< bls12_377_r_limbs > libff::bls12_377_modulus_r

Definition at line 11 of file bls12_377_init.cpp.

◆ bls12_377_q_bitcount

const mp_size_t libff::bls12_377_q_bitcount = 377

Definition at line 25 of file bls12_377_init.hpp.

◆ bls12_377_q_limbs

const mp_size_t libff::bls12_377_q_limbs

Initial value:

=

(bls12_377_q_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 29 of file bls12_377_init.hpp.

◆ bls12_377_r_bitcount

const mp_size_t libff::bls12_377_r_bitcount = 253

Definition at line 24 of file bls12_377_init.hpp.

◆ bls12_377_r_limbs

const mp_size_t libff::bls12_377_r_limbs

Initial value:

=

(bls12_377_r_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 27 of file bls12_377_init.hpp.

◆ bls12_377_trace_of_frobenius

bigint< bls12_377_r_limbs > libff::bls12_377_trace_of_frobenius

Definition at line 17 of file bls12_377_init.cpp.

◆ bls12_377_twist

bls12_377_Fq2 libff::bls12_377_twist

Definition at line 18 of file bls12_377_init.cpp.

◆ bls12_377_twist_coeff_b

bls12_377_Fq2 libff::bls12_377_twist_coeff_b

Definition at line 19 of file bls12_377_init.cpp.

◆ bls12_377_twist_mul_by_b_c0

bls12_377_Fq libff::bls12_377_twist_mul_by_b_c0

Definition at line 20 of file bls12_377_init.cpp.

◆ bls12_377_twist_mul_by_b_c1

bls12_377_Fq libff::bls12_377_twist_mul_by_b_c1

Definition at line 21 of file bls12_377_init.cpp.

◆ bls12_377_twist_mul_by_q_X

bls12_377_Fq2 libff::bls12_377_twist_mul_by_q_X

Definition at line 22 of file bls12_377_init.cpp.

◆ bls12_377_twist_mul_by_q_Y

bls12_377_Fq2 libff::bls12_377_twist_mul_by_q_Y

Definition at line 23 of file bls12_377_init.cpp.

◆ bls12_381_ate_is_loop_count_neg

bool libff::bls12_381_ate_is_loop_count_neg

Definition at line 21 of file bls12_381_init.cpp.

◆ bls12_381_ate_loop_count

bigint< bls12_381_q_limbs > libff::bls12_381_ate_loop_count

Definition at line 20 of file bls12_381_init.cpp.

◆ bls12_381_coeff_b

bls12_381_Fq libff::bls12_381_coeff_b

Definition at line 11 of file bls12_381_init.cpp.

◆ bls12_381_final_exponent

bigint< 12 *bls12_381_q_limbs > libff::bls12_381_final_exponent

Definition at line 22 of file bls12_381_init.cpp.

◆ bls12_381_final_exponent_is_z_neg

bool libff::bls12_381_final_exponent_is_z_neg

Definition at line 24 of file bls12_381_init.cpp.

◆ bls12_381_final_exponent_z

bigint< bls12_381_q_limbs > libff::bls12_381_final_exponent_z

Definition at line 23 of file bls12_381_init.cpp.

◆ bls12_381_modulus_q

bigint< bls12_381_q_limbs > libff::bls12_381_modulus_q

Definition at line 9 of file bls12_381_init.cpp.

◆ bls12_381_modulus_r

bigint< bls12_381_r_limbs > libff::bls12_381_modulus_r

Definition at line 8 of file bls12_381_init.cpp.

◆ bls12_381_q_bitcount

const mp_size_t libff::bls12_381_q_bitcount = 381

Definition at line 20 of file bls12_381_init.hpp.

◆ bls12_381_q_limbs

const mp_size_t libff::bls12_381_q_limbs

Initial value:

=

(bls12_381_q_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 24 of file bls12_381_init.hpp.

◆ bls12_381_r_bitcount

const mp_size_t libff::bls12_381_r_bitcount = 255

Definition at line 19 of file bls12_381_init.hpp.

◆ bls12_381_r_limbs

const mp_size_t libff::bls12_381_r_limbs

Initial value:

=

(bls12_381_r_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 22 of file bls12_381_init.hpp.

◆ bls12_381_trace_of_frobenius

bigint< bls12_381_r_limbs > libff::bls12_381_trace_of_frobenius

Definition at line 12 of file bls12_381_init.cpp.

◆ bls12_381_twist

bls12_381_Fq2 libff::bls12_381_twist

Definition at line 13 of file bls12_381_init.cpp.

◆ bls12_381_twist_coeff_b

bls12_381_Fq2 libff::bls12_381_twist_coeff_b

Definition at line 14 of file bls12_381_init.cpp.

◆ bls12_381_twist_mul_by_b_c0

bls12_381_Fq libff::bls12_381_twist_mul_by_b_c0

Definition at line 15 of file bls12_381_init.cpp.

◆ bls12_381_twist_mul_by_b_c1

bls12_381_Fq libff::bls12_381_twist_mul_by_b_c1

Definition at line 16 of file bls12_381_init.cpp.

◆ bls12_381_twist_mul_by_q_X

bls12_381_Fq2 libff::bls12_381_twist_mul_by_q_X

Definition at line 17 of file bls12_381_init.cpp.

◆ bls12_381_twist_mul_by_q_Y

bls12_381_Fq2 libff::bls12_381_twist_mul_by_q_Y

Definition at line 18 of file bls12_381_init.cpp.

◆ bn128_coeff_b

bn::Fp libff::bn128_coeff_b

Definition at line 19 of file bn128_init.cpp.

◆ bn128_Fq2_nqr_to_t

bn::Fp2 libff::bn128_Fq2_nqr_to_t

Definition at line 26 of file bn128_init.cpp.

◆ bn128_Fq2_s

size_t libff::bn128_Fq2_s

Definition at line 25 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 27 of file bn128_init.cpp.

◆ bn128_Fq_nqr_to_t

bn::Fp libff::bn128_Fq_nqr_to_t

Definition at line 21 of file bn128_init.cpp.

◆ bn128_Fq_s

size_t libff::bn128_Fq_s

Definition at line 20 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 22 of file bn128_init.cpp.

◆ bn128_modulus_q

bigint< bn128_q_limbs > libff::bn128_modulus_q

Definition at line 17 of file bn128_init.cpp.

◆ bn128_modulus_r

bigint< bn128_r_limbs > libff::bn128_modulus_r

Definition at line 16 of file bn128_init.cpp.

◆ bn128_q_bitcount

const mp_size_t libff::bn128_q_bitcount = 254

Definition at line 19 of file bn128_init.hpp.

◆ bn128_q_limbs

const mp_size_t libff::bn128_q_limbs

Initial value:

=

(bn128_q_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 23 of file bn128_init.hpp.

◆ bn128_r_bitcount

const mp_size_t libff::bn128_r_bitcount = 254

Definition at line 18 of file bn128_init.hpp.

◆ bn128_r_limbs

const mp_size_t libff::bn128_r_limbs

Initial value:

=

(bn128_r_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 21 of file bn128_init.hpp.

◆ bn128_twist_coeff_b

bn::Fp2 libff::bn128_twist_coeff_b

Definition at line 24 of file bn128_init.cpp.

◆ bw6_761_ate_is_loop_count_neg

bool libff::bw6_761_ate_is_loop_count_neg

Definition at line 23 of file bw6_761_init.cpp.

◆ bw6_761_ate_loop_count1

bigint< bw6_761_q_limbs > libff::bw6_761_ate_loop_count1

Definition at line 21 of file bw6_761_init.cpp.

◆ bw6_761_ate_loop_count2

bigint< bw6_761_q_limbs > libff::bw6_761_ate_loop_count2

Definition at line 22 of file bw6_761_init.cpp.

◆ bw6_761_coeff_b

bw6_761_Fq libff::bw6_761_coeff_b

Definition at line 17 of file bw6_761_init.cpp.

◆ bw6_761_final_exponent_is_z_neg

bool libff::bw6_761_final_exponent_is_z_neg

Definition at line 25 of file bw6_761_init.cpp.

◆ bw6_761_final_exponent_z

bigint< bw6_761_q_limbs > libff::bw6_761_final_exponent_z

Definition at line 24 of file bw6_761_init.cpp.

◆ bw6_761_modulus_q

bigint< bw6_761_q_limbs > libff::bw6_761_modulus_q

Definition at line 15 of file bw6_761_init.cpp.

◆ bw6_761_modulus_r

bigint< bw6_761_r_limbs > libff::bw6_761_modulus_r

Definition at line 14 of file bw6_761_init.cpp.

◆ bw6_761_q_bitcount

const mp_size_t libff::bw6_761_q_bitcount = 761

Definition at line 13 of file bw6_761_init.hpp.

◆ bw6_761_q_limbs

const mp_size_t libff::bw6_761_q_limbs

Initial value:

=

(bw6_761_q_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 17 of file bw6_761_init.hpp.

◆ bw6_761_r_bitcount

const mp_size_t libff::bw6_761_r_bitcount = 377

Definition at line 12 of file bw6_761_init.hpp.

◆ bw6_761_r_limbs

const mp_size_t libff::bw6_761_r_limbs

Initial value:

=

(bw6_761_r_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 15 of file bw6_761_init.hpp.

◆ bw6_761_twist

bw6_761_Fq libff::bw6_761_twist

Definition at line 18 of file bw6_761_init.cpp.

◆ bw6_761_twist_coeff_b

bw6_761_Fq libff::bw6_761_twist_coeff_b

Definition at line 19 of file bw6_761_init.cpp.

◆ cumulative_op_counts

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

Definition at line 83 of file profiling.cpp.

◆ cumulative_times

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

Definition at line 76 of file profiling.cpp.

◆ curve_point_y_at_x

template<typename GroupT >

decltype(((GroupT *)nullptr)->X) libff::curve_point_y_at_x(const decltype(((GroupT *) nullptr) ->X) &x)

Definition at line 24 of file curve_utils.hpp.

◆ DEFAULT_COMPRESSION

constexpr compression_t libff::DEFAULT_COMPRESSION = compression_on

constexpr

Definition at line 60 of file serialization.hpp.

◆ DEFAULT_ENCODING

constexpr encoding_t libff::DEFAULT_ENCODING = encoding_json

constexpr

Definition at line 48 of file serialization.hpp.

◆ DEFAULT_FORM

constexpr form_t libff::DEFAULT_FORM = form_plain

constexpr

Definition at line 54 of file serialization.hpp.

◆ edwards_ate_loop_count

bigint< edwards_q_limbs > libff::edwards_ate_loop_count

Definition at line 32 of file edwards_init.cpp.

◆ edwards_coeff_a

edwards_Fq libff::edwards_coeff_a

Definition at line 18 of file edwards_init.cpp.

◆ edwards_coeff_d

edwards_Fq libff::edwards_coeff_d

Definition at line 19 of file edwards_init.cpp.

◆ edwards_final_exponent

bigint< 6 *edwards_q_limbs > libff::edwards_final_exponent

Definition at line 33 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 34 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 35 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 36 of file edwards_init.cpp.

◆ edwards_modulus_q

bigint< edwards_q_limbs > libff::edwards_modulus_q

Definition at line 16 of file edwards_init.cpp.

◆ edwards_modulus_r

bigint< edwards_r_limbs > libff::edwards_modulus_r

Definition at line 15 of file edwards_init.cpp.

◆ edwards_q_bitcount

const mp_size_t libff::edwards_q_bitcount = 183

Definition at line 19 of file edwards_init.hpp.

◆ edwards_q_limbs

const mp_size_t libff::edwards_q_limbs

Initial value:

=

(edwards_q_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 23 of file edwards_init.hpp.

◆ edwards_r_bitcount

const mp_size_t libff::edwards_r_bitcount = 181

Definition at line 18 of file edwards_init.hpp.

◆ edwards_r_limbs

const mp_size_t libff::edwards_r_limbs

Initial value:

=

(edwards_r_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 21 of file edwards_init.hpp.

◆ edwards_twist

edwards_Fq3 libff::edwards_twist

Definition at line 20 of file edwards_init.cpp.

◆ edwards_twist_coeff_a

edwards_Fq3 libff::edwards_twist_coeff_a

Definition at line 21 of file edwards_init.cpp.

◆ edwards_twist_coeff_d

edwards_Fq3 libff::edwards_twist_coeff_d

Definition at line 22 of file edwards_init.cpp.

◆ edwards_twist_mul_by_a_c0

edwards_Fq libff::edwards_twist_mul_by_a_c0

Definition at line 23 of file edwards_init.cpp.

◆ edwards_twist_mul_by_a_c1

edwards_Fq libff::edwards_twist_mul_by_a_c1

Definition at line 24 of file edwards_init.cpp.

◆ edwards_twist_mul_by_a_c2

edwards_Fq libff::edwards_twist_mul_by_a_c2

Definition at line 25 of file edwards_init.cpp.

◆ edwards_twist_mul_by_d_c0

edwards_Fq libff::edwards_twist_mul_by_d_c0

Definition at line 26 of file edwards_init.cpp.

◆ edwards_twist_mul_by_d_c1

edwards_Fq libff::edwards_twist_mul_by_d_c1

Definition at line 27 of file edwards_init.cpp.

◆ edwards_twist_mul_by_d_c2

edwards_Fq libff::edwards_twist_mul_by_d_c2

Definition at line 28 of file edwards_init.cpp.

◆ edwards_twist_mul_by_q_Y

edwards_Fq libff::edwards_twist_mul_by_q_Y

Definition at line 29 of file edwards_init.cpp.

◆ edwards_twist_mul_by_q_Z

edwards_Fq libff::edwards_twist_mul_by_q_Z

Definition at line 30 of file edwards_init.cpp.

◆ enter_cpu_times

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

Definition at line 79 of file profiling.cpp.

◆ enter_times

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

Definition at line 74 of file profiling.cpp.

◆ indentation

size_t libff::indentation = 0

Definition at line 86 of file profiling.cpp.

◆ inhibit_profiling_counters

bool libff::inhibit_profiling_counters = false

Definition at line 108 of file profiling.cpp.

◆ inhibit_profiling_info

bool libff::inhibit_profiling_info = false

Definition at line 107 of file profiling.cpp.

◆ invocation_counts

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

Definition at line 73 of file profiling.cpp.

◆ last_cpu_time

long long libff::last_cpu_time

Definition at line 63 of file profiling.cpp.

◆ last_cpu_times

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

Definition at line 80 of file profiling.cpp.

◆ last_time

long long libff::last_time

Definition at line 62 of file profiling.cpp.

◆ last_times

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

Definition at line 75 of file profiling.cpp.

◆ mnt46_A_bitcount

const mp_size_t libff::mnt46_A_bitcount = 298

Definition at line 20 of file mnt46_common.hpp.

◆ mnt46_A_limbs

const mp_size_t libff::mnt46_A_limbs

Initial value:

=

(mnt46_A_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 23 of file mnt46_common.hpp.

◆ mnt46_B_bitcount

const mp_size_t libff::mnt46_B_bitcount = 298

Definition at line 21 of file mnt46_common.hpp.

◆ mnt46_B_limbs

const mp_size_t libff::mnt46_B_limbs

Initial value:

=

(mnt46_B_bitcount + GMP_NUMB_BITS - 1) / GMP_NUMB_BITS

Definition at line 25 of file mnt46_common.hpp.

◆ mnt46_modulus_A

bigint< mnt46_A_limbs > libff::mnt46_modulus_A

Definition at line 19 of file mnt46_common.cpp.

◆ mnt46_modulus_B

bigint< mnt46_B_limbs > libff::mnt46_modulus_B

Definition at line 20 of file mnt46_common.cpp.

◆ mnt4_ate_is_loop_count_neg

bool libff::mnt4_ate_is_loop_count_neg

Definition at line 35 of file mnt4_init.cpp.

◆ mnt4_ate_loop_count

bigint< mnt4_q_limbs > libff::mnt4_ate_loop_count

Definition at line 34 of file mnt4_init.cpp.

◆ mnt4_final_exponent

bigint< 4 *mnt4_q_limbs > libff::mnt4_final_exponent

Definition at line 36 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 37 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 38 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 39 of file mnt4_init.cpp.

◆ mnt4_modulus_q

bigint<mnt4_q_limbs> libff::mnt4_modulus_q

◆ mnt4_modulus_r

bigint<mnt4_r_limbs> libff::mnt4_modulus_r

◆ mnt4_q_bitcount

const mp_size_t libff::mnt4_q_bitcount = mnt46_B_bitcount

Definition at line 28 of file mnt4_init.hpp.

◆ mnt4_q_limbs

const mp_size_t libff::mnt4_q_limbs = mnt46_B_limbs

Definition at line 31 of file mnt4_init.hpp.

◆ mnt4_r_bitcount

const mp_size_t libff::mnt4_r_bitcount = mnt46_A_bitcount

Definition at line 27 of file mnt4_init.hpp.

◆ mnt4_r_limbs

const mp_size_t libff::mnt4_r_limbs = mnt46_A_limbs

Definition at line 30 of file mnt4_init.hpp.

◆ mnt4_twist

mnt4_Fq2 libff::mnt4_twist

Definition at line 24 of file mnt4_init.cpp.

◆ mnt4_twist_coeff_a

mnt4_Fq2 libff::mnt4_twist_coeff_a

Definition at line 25 of file mnt4_init.cpp.

◆ mnt4_twist_coeff_b

mnt4_Fq2 libff::mnt4_twist_coeff_b

Definition at line 26 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_a_c0

mnt4_Fq libff::mnt4_twist_mul_by_a_c0

Definition at line 27 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_a_c1

mnt4_Fq libff::mnt4_twist_mul_by_a_c1

Definition at line 28 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_b_c0

mnt4_Fq libff::mnt4_twist_mul_by_b_c0

Definition at line 29 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_b_c1

mnt4_Fq libff::mnt4_twist_mul_by_b_c1

Definition at line 30 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_q_X

mnt4_Fq libff::mnt4_twist_mul_by_q_X

Definition at line 31 of file mnt4_init.cpp.

◆ mnt4_twist_mul_by_q_Y

mnt4_Fq libff::mnt4_twist_mul_by_q_Y

Definition at line 32 of file mnt4_init.cpp.

◆ mnt6_ate_is_loop_count_neg

bool libff::mnt6_ate_is_loop_count_neg

Definition at line 37 of file mnt6_init.cpp.

◆ mnt6_ate_loop_count

bigint< mnt6_q_limbs > libff::mnt6_ate_loop_count

Definition at line 36 of file mnt6_init.cpp.

◆ mnt6_final_exponent

bigint< 6 *mnt6_q_limbs > libff::mnt6_final_exponent

Definition at line 38 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 39 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 40 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 41 of file mnt6_init.cpp.

◆ mnt6_modulus_q

bigint<mnt6_q_limbs> libff::mnt6_modulus_q

◆ mnt6_modulus_r

bigint<mnt6_r_limbs> libff::mnt6_modulus_r

◆ mnt6_q_bitcount

const mp_size_t libff::mnt6_q_bitcount = mnt46_A_bitcount

Definition at line 28 of file mnt6_init.hpp.

◆ mnt6_q_limbs

const mp_size_t libff::mnt6_q_limbs = mnt46_A_limbs

Definition at line 31 of file mnt6_init.hpp.

◆ mnt6_r_bitcount

const mp_size_t libff::mnt6_r_bitcount = mnt46_B_bitcount

Definition at line 27 of file mnt6_init.hpp.

◆ mnt6_r_limbs

const mp_size_t libff::mnt6_r_limbs = mnt46_B_limbs

Definition at line 30 of file mnt6_init.hpp.

◆ mnt6_twist

mnt6_Fq3 libff::mnt6_twist

Definition at line 24 of file mnt6_init.cpp.

◆ mnt6_twist_coeff_a

mnt6_Fq3 libff::mnt6_twist_coeff_a

Definition at line 25 of file mnt6_init.cpp.

◆ mnt6_twist_coeff_b

mnt6_Fq3 libff::mnt6_twist_coeff_b

Definition at line 26 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_a_c0

mnt6_Fq libff::mnt6_twist_mul_by_a_c0

Definition at line 27 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_a_c1

mnt6_Fq libff::mnt6_twist_mul_by_a_c1

Definition at line 28 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_a_c2

mnt6_Fq libff::mnt6_twist_mul_by_a_c2

Definition at line 29 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_b_c0

mnt6_Fq libff::mnt6_twist_mul_by_b_c0

Definition at line 30 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_b_c1

mnt6_Fq libff::mnt6_twist_mul_by_b_c1

Definition at line 31 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_b_c2

mnt6_Fq libff::mnt6_twist_mul_by_b_c2

Definition at line 32 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_q_X

mnt6_Fq libff::mnt6_twist_mul_by_q_X

Definition at line 33 of file mnt6_init.cpp.

◆ mnt6_twist_mul_by_q_Y

mnt6_Fq libff::mnt6_twist_mul_by_q_Y

Definition at line 34 of file mnt6_init.cpp.

◆ op_counts

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

Definition at line 81 of file profiling.cpp.

◆ op_data_points

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

Initial value:

= {
 
}

Definition at line 90 of file profiling.cpp.

◆ start_cpu_time

long long libff::start_cpu_time

Definition at line 63 of file profiling.cpp.

◆ start_time

long long libff::start_time

Definition at line 62 of file profiling.cpp.

Namespaces

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

◆ bls12_377_Fq

◆ bls12_377_Fq12

◆ bls12_377_Fq2

◆ bls12_377_Fq6

◆ bls12_377_Fr

◆ bls12_377_G1_precomp

◆ bls12_377_G2_precomp

◆ bls12_377_GT

◆ bls12_381_Fq

◆ bls12_381_Fq12

◆ bls12_381_Fq2

◆ bls12_381_Fq6

◆ bls12_381_Fr

◆ bls12_381_G1_precomp

◆ bls12_381_G2_precomp

◆ bls12_381_GT

◆ bn128_ate_ell_coeffs

◆ bn128_Fq

◆ bn128_Fq12

◆ bn128_Fr

◆ bw6_761_Fq

◆ bw6_761_Fq3

◆ bw6_761_Fq6

◆ bw6_761_Fr

◆ bw6_761_G1_precomp

◆ bw6_761_G2_precomp

◆ bw6_761_GT

◆ 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