libff::alt_bn128_G2 Class Reference

#include <alt_bn128_g2.hpp>

Collaboration diagram for libff::alt_bn128_G2:

Public Types
typedef alt_bn128_Fq	base_field
typedef alt_bn128_Fq2	twist_field
typedef alt_bn128_Fr	scalar_field

Public Member Functions
	alt_bn128_G2 ()
	alt_bn128_G2 (const alt_bn128_Fq2 &X, const alt_bn128_Fq2 &Y, const alt_bn128_Fq2 &Z)
void	print () const
void	print_coordinates () const
void	to_affine_coordinates ()
void	to_special ()
bool	is_special () const
bool	is_zero () const
bool	operator== (const alt_bn128_G2 &other) const
bool	operator!= (const alt_bn128_G2 &other) const
alt_bn128_G2	operator+ (const alt_bn128_G2 &other) const
alt_bn128_G2	operator- () const
alt_bn128_G2	operator- (const alt_bn128_G2 &other) const
alt_bn128_G2	add (const alt_bn128_G2 &other) const
alt_bn128_G2	mixed_add (const alt_bn128_G2 &other) const
alt_bn128_G2	dbl () const
alt_bn128_G2	mul_by_q () const
bool	is_well_formed () const

Static Public Member Functions
static alt_bn128_Fq2	mul_by_b (const alt_bn128_Fq2 &elt)
static alt_bn128_G2	zero ()
static alt_bn128_G2	one ()
static alt_bn128_G2	random_element ()
static size_t	size_in_bits ()
static bigint< base_field::num_limbs >	base_field_char ()
static bigint< scalar_field::num_limbs >	order ()
static void	batch_to_special_all_non_zeros (std::vector< alt_bn128_G2 > &vec)

Public Attributes
alt_bn128_Fq2	X
alt_bn128_Fq2	Y
alt_bn128_Fq2	Z

Static Public Attributes
static std::vector< size_t >	wnaf_window_table
static std::vector< size_t >	fixed_base_exp_window_table
static alt_bn128_G2	G2_zero = {}
static alt_bn128_G2	G2_one = {}
static bool	initialized = false

Friends
std::ostream &	operator<< (std::ostream &out, const alt_bn128_G2 &g)
std::istream &	operator>> (std::istream &in, alt_bn128_G2 &g)

Detailed Description

Definition at line 21 of file alt_bn128_g2.hpp.

Member Typedef Documentation

base_field

alt_bn128_Fq libff::alt_bn128_G2::base_field

Definition at line 33 of file alt_bn128_g2.hpp.

scalar_field

alt_bn128_Fr libff::alt_bn128_G2::scalar_field

Definition at line 35 of file alt_bn128_g2.hpp.

twist_field

alt_bn128_Fq2 libff::alt_bn128_G2::twist_field

Definition at line 34 of file alt_bn128_g2.hpp.

Constructor & Destructor Documentation

alt_bn128_G2() [1/2]

libff::alt_bn128_G2::alt_bn128_G2

(

)

Definition at line 23 of file alt_bn128_g2.cpp.

{
    if (initialized)
    {
        this->X = G2_zero.X;
        this->Y = G2_zero.Y;
        this->Z = G2_zero.Z;
    }
}

Here is the caller graph for this function:

alt_bn128_G2() [2/2]

libff::alt_bn128_G2::alt_bn128_G2 ( const alt_bn128_Fq2 & X, const alt_bn128_Fq2 & Y, const alt_bn128_Fq2 & Z )

inline

Definition at line 41 of file alt_bn128_g2.hpp.

: X(X), Y(Y), Z(Z) {};

Member Function Documentation

add()

alt_bn128_G2 libff::alt_bn128_G2::add

(

const alt_bn128_G2 &

other

)

const

Definition at line 222 of file alt_bn128_g2.cpp.

{
    // handle special cases having to do with O
    if (this->is_zero())
    {
        return other;
    }
 
    if (other.is_zero())
    {
        return *this;
    }
 
    // no need to handle points of order 2,4
    // (they cannot exist in a prime-order subgroup)
 
    // handle double case
    if (this->operator==(other))
    {
        return this->dbl();
    }
 
#ifdef PROFILE_OP_COUNTS
    this->add_cnt++;
#endif
    // NOTE: does not handle O and pts of order 2,4
    // http://www.hyperelliptic.org/EFD/g1p/auto-shortw-projective.html#addition-add-1998-cmo-2
 
    alt_bn128_Fq2 Z1Z1 = (this->Z).squared();             // Z1Z1 = Z1^2
    alt_bn128_Fq2 Z2Z2 = (other.Z).squared();             // Z2Z2 = Z2^2
    alt_bn128_Fq2 U1 = (this->X) * Z2Z2;                  // U1 = X1 * Z2Z2
    alt_bn128_Fq2 U2 = (other.X) * Z1Z1;                  // U2 = X2 * Z1Z1
    alt_bn128_Fq2 S1 = (this->Y) * (other.Z) * Z2Z2;      // S1 = Y1 * Z2 * Z2Z2
    alt_bn128_Fq2 S2 = (other.Y) * (this->Z) * Z1Z1;      // S2 = Y2 * Z1 * Z1Z1
    alt_bn128_Fq2 H = U2 - U1;                            // H = U2-U1
    alt_bn128_Fq2 S2_minus_S1 = S2-S1;
    alt_bn128_Fq2 I = (H+H).squared();                    // I = (2 * H)^2
    alt_bn128_Fq2 J = H * I;                              // J = H * I
    alt_bn128_Fq2 r = S2_minus_S1 + S2_minus_S1;          // r = 2 * (S2-S1)
    alt_bn128_Fq2 V = U1 * I;                             // V = U1 * I
    alt_bn128_Fq2 X3 = r.squared() - J - (V+V);           // X3 = r^2 - J - 2 * V
    alt_bn128_Fq2 S1_J = S1 * J;
    alt_bn128_Fq2 Y3 = r * (V-X3) - (S1_J+S1_J);          // Y3 = r * (V-X3)-2 S1 J
    alt_bn128_Fq2 Z3 = ((this->Z+other.Z).squared()-Z1Z1-Z2Z2) * H; // Z3 = ((Z1+Z2)^2-Z1Z1-Z2Z2) * H
 
    return alt_bn128_G2(X3, Y3, Z3);
}

Here is the call graph for this function:

base_field_char()

static bigint< base_field::num_limbs > libff::alt_bn128_G2::base_field_char ( )

inlinestatic

Definition at line 73 of file alt_bn128_g2.hpp.

{ return base_field::field_char(); }

Here is the call graph for this function:

batch_to_special_all_non_zeros()

void libff::alt_bn128_G2::batch_to_special_all_non_zeros ( std::vector< alt_bn128_G2 > & vec )

static

Definition at line 484 of file alt_bn128_g2.cpp.

{
    std::vector<alt_bn128_Fq2> Z_vec;
    Z_vec.reserve(vec.size());
 
    for (auto &el: vec)
    {
        Z_vec.emplace_back(el.Z);
    }
    batch_invert<alt_bn128_Fq2>(Z_vec);
 
    const alt_bn128_Fq2 one = alt_bn128_Fq2::one();
 
    for (size_t i = 0; i < vec.size(); ++i)
    {
        alt_bn128_Fq2 Z2 = Z_vec[i].squared();
        alt_bn128_Fq2 Z3 = Z_vec[i] * Z2;
 
        vec[i].X = vec[i].X * Z2;
        vec[i].Y = vec[i].Y * Z3;
        vec[i].Z = one;
    }
}

Here is the call graph for this function:

dbl()

alt_bn128_G2 libff::alt_bn128_G2::dbl

(

)

const

Definition at line 339 of file alt_bn128_g2.cpp.

{
#ifdef PROFILE_OP_COUNTS
    this->dbl_cnt++;
#endif
    // handle point at infinity
    if (this->is_zero())
    {
        return (*this);
    }
 
    // NOTE: does not handle O and pts of order 2,4
    // http://www.hyperelliptic.org/EFD/g1p/auto-shortw-projective.html#doubling-dbl-2007-bl
 
    alt_bn128_Fq2 A = (this->X).squared();         // A = X1^2
    alt_bn128_Fq2 B = (this->Y).squared();        // B = Y1^2
    alt_bn128_Fq2 C = B.squared();                // C = B^2
    alt_bn128_Fq2 D = (this->X + B).squared() - A - C;
    D = D+D;                        // D = 2 * ((X1 + B)^2 - A - C)
    alt_bn128_Fq2 E = A + A + A;                  // E = 3 * A
    alt_bn128_Fq2 F = E.squared();                // F = E^2
    alt_bn128_Fq2 X3 = F - (D+D);                 // X3 = F - 2 D
    alt_bn128_Fq2 eightC = C+C;
    eightC = eightC + eightC;
    eightC = eightC + eightC;
    alt_bn128_Fq2 Y3 = E * (D - X3) - eightC;     // Y3 = E * (D - X3) - 8 * C
    alt_bn128_Fq2 Y1Z1 = (this->Y)*(this->Z);
    alt_bn128_Fq2 Z3 = Y1Z1 + Y1Z1;               // Z3 = 2 * Y1 * Z1
 
    return alt_bn128_G2(X3, Y3, Z3);
}

Here is the call graph for this function:

Here is the caller graph for this function:

is_special()

bool libff::alt_bn128_G2::is_special

(

)

const

Definition at line 98 of file alt_bn128_g2.cpp.

{
    return (this->is_zero() || this->Z == alt_bn128_Fq2::one());
}

Here is the call graph for this function:

is_well_formed()

bool libff::alt_bn128_G2::is_well_formed

(

)

const

Definition at line 378 of file alt_bn128_g2.cpp.

{
    if (this->is_zero())
    {
        return true;
    }
    else
    {
        /*
          y^2 = x^3 + b
 
          We are using Jacobian coordinates, so equation we need to check is actually
 
          (y/z^3)^2 = (x/z^2)^3 + b
          y^2 / z^6 = x^3 / z^6 + b
          y^2 = x^3 + b z^6
        */
        alt_bn128_Fq2 X2 = this->X.squared();
        alt_bn128_Fq2 Y2 = this->Y.squared();
        alt_bn128_Fq2 Z2 = this->Z.squared();
 
        alt_bn128_Fq2 X3 = this->X * X2;
        alt_bn128_Fq2 Z3 = this->Z * Z2;
        alt_bn128_Fq2 Z6 = Z3.squared();
 
        return (Y2 == X3 + alt_bn128_twist_coeff_b * Z6);
    }
}

Here is the call graph for this function:

is_zero()

bool libff::alt_bn128_G2::is_zero

(

)

const

Definition at line 103 of file alt_bn128_g2.cpp.

{
    return (this->Z.is_zero());
}

Here is the call graph for this function:

Here is the caller graph for this function:

mixed_add()

alt_bn128_G2 libff::alt_bn128_G2::mixed_add

(

const alt_bn128_G2 &

other

)

const

Definition at line 270 of file alt_bn128_g2.cpp.

{
#ifdef DEBUG
    assert(other.is_special());
#endif
 
    // handle special cases having to do with O
    if (this->is_zero())
    {
        return other;
    }
 
    if (other.is_zero())
    {
        return *this;
    }
 
    // no need to handle points of order 2,4
    // (they cannot exist in a prime-order subgroup)
 
    // check for doubling case
 
    // using Jacobian coordinates so:
    // (X1:Y1:Z1) = (X2:Y2:Z2)
    // iff
    // X1/Z1^2 == X2/Z2^2 and Y1/Z1^3 == Y2/Z2^3
    // iff
    // X1 * Z2^2 == X2 * Z1^2 and Y1 * Z2^3 == Y2 * Z1^3
 
    // we know that Z2 = 1
 
    const alt_bn128_Fq2 Z1Z1 = (this->Z).squared();
 
    const alt_bn128_Fq2 &U1 = this->X;
    const alt_bn128_Fq2 U2 = other.X * Z1Z1;
 
    const alt_bn128_Fq2 Z1_cubed = (this->Z) * Z1Z1;
 
    const alt_bn128_Fq2 &S1 = (this->Y);                // S1 = Y1 * Z2 * Z2Z2
    const alt_bn128_Fq2 S2 = (other.Y) * Z1_cubed;      // S2 = Y2 * Z1 * Z1Z1
 
    if (U1 == U2 && S1 == S2)
    {
        // dbl case; nothing of above can be reused
        return this->dbl();
    }
 
#ifdef PROFILE_OP_COUNTS
    this->add_cnt++;
#endif
 
    // NOTE: does not handle O and pts of order 2,4
    // http://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-madd-2007-bl
    alt_bn128_Fq2 H = U2-(this->X);                         // H = U2-X1
    alt_bn128_Fq2 HH = H.squared() ;                        // HH = H&2
    alt_bn128_Fq2 I = HH+HH;                                // I = 4*HH
    I = I + I;
    alt_bn128_Fq2 J = H*I;                                  // J = H*I
    alt_bn128_Fq2 r = S2-(this->Y);                         // r = 2*(S2-Y1)
    r = r + r;
    alt_bn128_Fq2 V = (this->X) * I ;                       // V = X1*I
    alt_bn128_Fq2 X3 = r.squared()-J-V-V;                   // X3 = r^2-J-2*V
    alt_bn128_Fq2 Y3 = (this->Y)*J;                         // Y3 = r*(V-X3)-2*Y1*J
    Y3 = r*(V-X3) - Y3 - Y3;
    alt_bn128_Fq2 Z3 = ((this->Z)+H).squared() - Z1Z1 - HH; // Z3 = (Z1+H)^2-Z1Z1-HH
 
    return alt_bn128_G2(X3, Y3, Z3);
}

Here is the call graph for this function:

mul_by_b()

alt_bn128_Fq2 libff::alt_bn128_G2::mul_by_b ( const alt_bn128_Fq2 & elt )

static

Definition at line 33 of file alt_bn128_g2.cpp.

{
    return alt_bn128_Fq2(alt_bn128_twist_mul_by_b_c0 * elt.c0, alt_bn128_twist_mul_by_b_c1 * elt.c1);
}

mul_by_q()

alt_bn128_G2 libff::alt_bn128_G2::mul_by_q

(

)

const

Definition at line 371 of file alt_bn128_g2.cpp.

{
    return alt_bn128_G2(alt_bn128_twist_mul_by_q_X * (this->X).Frobenius_map(1),
                      alt_bn128_twist_mul_by_q_Y * (this->Y).Frobenius_map(1),
                      (this->Z).Frobenius_map(1));
}

Here is the call graph for this function:

Here is the caller graph for this function:

one()

alt_bn128_G2 libff::alt_bn128_G2::one ( )

static

Definition at line 412 of file alt_bn128_g2.cpp.

{
    return G2_one;
}

Here is the caller graph for this function:

operator!=()

bool libff::alt_bn128_G2::operator!=

(

const alt_bn128_G2 &

other

)

const

Definition at line 148 of file alt_bn128_g2.cpp.

{
    return !(operator==(other));
}

Here is the call graph for this function:

operator+()

alt_bn128_G2 libff::alt_bn128_G2::operator+

(

const alt_bn128_G2 &

other

)

const

Definition at line 153 of file alt_bn128_g2.cpp.

{
    // handle special cases having to do with O
    if (this->is_zero())
    {
        return other;
    }
 
    if (other.is_zero())
    {
        return *this;
    }
 
    // no need to handle points of order 2,4
    // (they cannot exist in a prime-order subgroup)
 
    // check for doubling case
 
    // using Jacobian coordinates so:
    // (X1:Y1:Z1) = (X2:Y2:Z2)
    // iff
    // X1/Z1^2 == X2/Z2^2 and Y1/Z1^3 == Y2/Z2^3
    // iff
    // X1 * Z2^2 == X2 * Z1^2 and Y1 * Z2^3 == Y2 * Z1^3
 
    alt_bn128_Fq2 Z1Z1 = (this->Z).squared();
    alt_bn128_Fq2 Z2Z2 = (other.Z).squared();
 
    alt_bn128_Fq2 U1 = this->X * Z2Z2;
    alt_bn128_Fq2 U2 = other.X * Z1Z1;
 
    alt_bn128_Fq2 Z1_cubed = (this->Z) * Z1Z1;
    alt_bn128_Fq2 Z2_cubed = (other.Z) * Z2Z2;
 
    alt_bn128_Fq2 S1 = (this->Y) * Z2_cubed;      // S1 = Y1 * Z2 * Z2Z2
    alt_bn128_Fq2 S2 = (other.Y) * Z1_cubed;      // S2 = Y2 * Z1 * Z1Z1
 
    if (U1 == U2 && S1 == S2)
    {
        // dbl case; nothing of above can be reused
        return this->dbl();
    }
 
    // rest of add case
    alt_bn128_Fq2 H = U2 - U1;                            // H = U2-U1
    alt_bn128_Fq2 S2_minus_S1 = S2-S1;
    alt_bn128_Fq2 I = (H+H).squared();                    // I = (2 * H)^2
    alt_bn128_Fq2 J = H * I;                              // J = H * I
    alt_bn128_Fq2 r = S2_minus_S1 + S2_minus_S1;          // r = 2 * (S2-S1)
    alt_bn128_Fq2 V = U1 * I;                             // V = U1 * I
    alt_bn128_Fq2 X3 = r.squared() - J - (V+V);           // X3 = r^2 - J - 2 * V
    alt_bn128_Fq2 S1_J = S1 * J;
    alt_bn128_Fq2 Y3 = r * (V-X3) - (S1_J+S1_J);          // Y3 = r * (V-X3)-2 S1 J
    alt_bn128_Fq2 Z3 = ((this->Z+other.Z).squared()-Z1Z1-Z2Z2) * H; // Z3 = ((Z1+Z2)^2-Z1Z1-Z2Z2) * H
 
    return alt_bn128_G2(X3, Y3, Z3);
}

Here is the call graph for this function:

operator-() [1/2]

alt_bn128_G2 libff::alt_bn128_G2::operator-

(

)

const

Definition at line 211 of file alt_bn128_g2.cpp.

{
    return alt_bn128_G2(this->X, -(this->Y), this->Z);
}

Here is the call graph for this function:

operator-() [2/2]

alt_bn128_G2 libff::alt_bn128_G2::operator-

(

const alt_bn128_G2 &

other

)

const

Definition at line 217 of file alt_bn128_g2.cpp.

{
    return (*this) + (-other);
}

operator==()

bool libff::alt_bn128_G2::operator==

(

const alt_bn128_G2 &

other

)

const

Definition at line 108 of file alt_bn128_g2.cpp.

{
    if (this->is_zero())
    {
        return other.is_zero();
    }
 
    if (other.is_zero())
    {
        return false;
    }
 
    /* now neither is O */
 
    // using Jacobian coordinates so:
    // (X1:Y1:Z1) = (X2:Y2:Z2)
    // iff
    // X1/Z1^2 == X2/Z2^2 and Y1/Z1^3 == Y2/Z2^3
    // iff
    // X1 * Z2^2 == X2 * Z1^2 and Y1 * Z2^3 == Y2 * Z1^3
 
    alt_bn128_Fq2 Z1_squared = (this->Z).squared();
    alt_bn128_Fq2 Z2_squared = (other.Z).squared();
 
    if ((this->X * Z2_squared) != (other.X * Z1_squared))
    {
        return false;
    }
 
    alt_bn128_Fq2 Z1_cubed = (this->Z) * Z1_squared;
    alt_bn128_Fq2 Z2_cubed = (other.Z) * Z2_squared;
 
    if ((this->Y * Z2_cubed) != (other.Y * Z1_cubed))
    {
        return false;
    }
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

order()

static bigint< scalar_field::num_limbs > libff::alt_bn128_G2::order ( )

inlinestatic

Definition at line 74 of file alt_bn128_g2.hpp.

{ return scalar_field::field_char(); }

Here is the call graph for this function:

Here is the caller graph for this function:

print()

void libff::alt_bn128_G2::print

(

)

const

Definition at line 38 of file alt_bn128_g2.cpp.

{
    if (this->is_zero())
    {
        printf("O\n");
    }
    else
    {
        alt_bn128_G2 copy(*this);
        copy.to_affine_coordinates();
        gmp_printf("(%Nd*z + %Nd , %Nd*z + %Nd)\n",
                   copy.X.c1.as_bigint().data, alt_bn128_Fq::num_limbs,
                   copy.X.c0.as_bigint().data, alt_bn128_Fq::num_limbs,
                   copy.Y.c1.as_bigint().data, alt_bn128_Fq::num_limbs,
                   copy.Y.c0.as_bigint().data, alt_bn128_Fq::num_limbs);
    }
}

Here is the call graph for this function:

print_coordinates()

void libff::alt_bn128_G2::print_coordinates

(

)

const

Definition at line 56 of file alt_bn128_g2.cpp.

{
    if (this->is_zero())
    {
        printf("O\n");
    }
    else
    {
        gmp_printf("(%Nd*z + %Nd : %Nd*z + %Nd : %Nd*z + %Nd)\n",
                   this->X.c1.as_bigint().data, alt_bn128_Fq::num_limbs,
                   this->X.c0.as_bigint().data, alt_bn128_Fq::num_limbs,
                   this->Y.c1.as_bigint().data, alt_bn128_Fq::num_limbs,
                   this->Y.c0.as_bigint().data, alt_bn128_Fq::num_limbs,
                   this->Z.c1.as_bigint().data, alt_bn128_Fq::num_limbs,
                   this->Z.c0.as_bigint().data, alt_bn128_Fq::num_limbs);
    }
}

Here is the call graph for this function:

random_element()

alt_bn128_G2 libff::alt_bn128_G2::random_element ( )

static

Definition at line 417 of file alt_bn128_g2.cpp.

{
    return (alt_bn128_Fr::random_element().as_bigint()) * G2_one;
}

Here is the call graph for this function:

size_in_bits()

static size_t libff::alt_bn128_G2::size_in_bits ( )

inlinestatic

Definition at line 72 of file alt_bn128_g2.hpp.

{ return twist_field::size_in_bits() + 1; }

Here is the call graph for this function:

to_affine_coordinates()

void libff::alt_bn128_G2::to_affine_coordinates

(

)

Definition at line 74 of file alt_bn128_g2.cpp.

{
    if (this->is_zero())
    {
        this->X = alt_bn128_Fq2::zero();
        this->Y = alt_bn128_Fq2::one();
        this->Z = alt_bn128_Fq2::zero();
    }
    else
    {
        alt_bn128_Fq2 Z_inv = Z.inverse();
        alt_bn128_Fq2 Z2_inv = Z_inv.squared();
        alt_bn128_Fq2 Z3_inv = Z2_inv * Z_inv;
        this->X = this->X * Z2_inv;
        this->Y = this->Y * Z3_inv;
        this->Z = alt_bn128_Fq2::one();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

to_special()

void libff::alt_bn128_G2::to_special

(

)

Definition at line 93 of file alt_bn128_g2.cpp.

{
    this->to_affine_coordinates();
}

Here is the call graph for this function:

zero()

alt_bn128_G2 libff::alt_bn128_G2::zero ( )

static

Definition at line 407 of file alt_bn128_g2.cpp.

{
    return G2_zero;
}

Here is the caller graph for this function:

Friends And Related Symbol Documentation

operator<<

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

friend

Definition at line 422 of file alt_bn128_g2.cpp.

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

operator>>

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

friend

Definition at line 437 of file alt_bn128_g2.cpp.

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

Member Data Documentation

fixed_base_exp_window_table

std::vector< size_t > libff::alt_bn128_G2::fixed_base_exp_window_table

static

Definition at line 28 of file alt_bn128_g2.hpp.

G2_one

alt_bn128_G2 libff::alt_bn128_G2::G2_one = {}

static

Definition at line 30 of file alt_bn128_g2.hpp.

G2_zero

alt_bn128_G2 libff::alt_bn128_G2::G2_zero = {}

static

Definition at line 29 of file alt_bn128_g2.hpp.

initialized

bool libff::alt_bn128_G2::initialized = false

static

Definition at line 31 of file alt_bn128_g2.hpp.

wnaf_window_table

std::vector< size_t > libff::alt_bn128_G2::wnaf_window_table

static

Definition at line 27 of file alt_bn128_g2.hpp.

X

alt_bn128_Fq2 libff::alt_bn128_G2::X

Definition at line 37 of file alt_bn128_g2.hpp.

Y

alt_bn128_Fq2 libff::alt_bn128_G2::Y

Definition at line 37 of file alt_bn128_g2.hpp.

Z

alt_bn128_Fq2 libff::alt_bn128_G2::Z

Definition at line 37 of file alt_bn128_g2.hpp.

---

The documentation for this class was generated from the following files:

• libraries/fc/libraries/ff/libff/algebra/curves/alt_bn128/alt_bn128_g2.hpp
• libraries/fc/libraries/ff/libff/algebra/curves/alt_bn128/alt_bn128_g2.cpp