Struct pairing_plus::bls12_381::G2Affine

pub struct G2Affine { /* fields omitted */ }

Trait Implementations

impl Clone for G2Affine

fn clone(&self) -> G2Affine

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for G2Affine

impl CurveAffine for G2Affine

type Engine = Bls12

type Scalar = Fr

type Base = Fq2

type Prepared = G2Prepared

type Projective = G2

type Uncompressed = G2Uncompressed

type Compressed = G2Compressed

type Pair = G1Affine

type PairingResult = Fq12

fn zero() -> Self

Returns the additive identity.

fn one() -> Self

Returns a fixed generator of unknown exponent.

fn is_zero(&self) -> bool

Determines if this point represents the point at infinity; the additive identity.

fn mul<S: Into<<Self::Scalar as PrimeField>::Repr>>(&self, by: S) -> G2

Performs scalar multiplication of this element with mixed addition.

fn negate(&mut self)

Negates this element.

fn prepare(&self) -> Self::Prepared

Prepares this element for pairing purposes.

fn pairing_with(&self, other: &Self::Pair) -> Self::PairingResult

Perform a pairing

fn into_projective(&self) -> G2

Converts this element into its affine representation.

fn as_tuple(&self) -> (&Fq2, &Fq2)

Borrow references to the X and Y coordinates of this point.

unsafe fn as_tuple_mut(&mut self) -> (&mut Fq2, &mut Fq2)

Borrow mutable references to the X and Y coordinates of this point. Unsafe, because incorrectly modifying the coordinates violates the guarantee that the point must be on the curve and in the correct subgroup.

fn precomp_3(&self, pre: &mut [Self])

pre[0] becomes (2^64) * self, pre[1] becomes (2^128) * self, and pre[2] (becomes 2^196) * self

fn mul_precomp_3<S: Into<<Self::Scalar as PrimeField>::Repr>>(
    &self,
    other: S,
    pre: &[Self]
) -> G2

Performs scalar multiplication of this element, assuming pre = [(2^64)*self, (2^128)*self, (2^192)*self]

fn precomp_256(&self, pre: &mut [Self])

pre[i] becomes (\sum_{b such that bth bit of i is 1} 2^{32i}) * self for i in 0..25

fn mul_precomp_256<S: Into<<Self::Scalar as PrimeField>::Repr>>(
    &self,
    other: S,
    pre: &[Self]
) -> G2

Performs scalar multiplication of this element, assuming pre[i] = (\sum_{b such that bth bit of i is 1} 2^{32i}) * self for i in 0..256

fn sum_of_products(points: &[Self], scalars: &[&[u64; 4]]) -> G2

given x, compute x^3+b multiplication of many points compute s1 * p1 + ... + sn * pn simultaneously

fn find_pippinger_window(num_components: usize) -> usize

Find the optimal window for running Pippinger's algorithm; preprogrammed values

fn find_pippinger_window_via_estimate(num_components: usize) -> usize

Find the optimal window for running Pippinger's algorithm; computed values via an estimate of running time

fn sum_of_products_pippinger(
    points: &[Self],
    scalars: &[&[u64; 4]],
    window: usize
) -> G2

multiplication of many points with Pippinger's algorithm of window size w compute s1 * p1 + ... + sn * pn simultaneously

fn sum_of_products_precomp_256(
    points: &[Self],
    scalars: &[&[u64; 4]],
    pre: &[Self]
) -> G2

multiplication of many points with precompuation compute s1 * p1 + ... + sn * pn simultaneously assuming pre[j*256+i] = (\sum_{b such that bth bit of i is 1} 2^{32i}) * bases[j] for each j and i in 0..256

fn into_compressed(&self) -> Self::Compressed

Converts this element into its compressed encoding, so long as it's not the point at infinity.

fn into_uncompressed(&self) -> Self::Uncompressed

Converts this element into its uncompressed encoding, so long as it's not the point at infinity.

impl Debug for G2Affine

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Default for G2Affine

fn default() -> Self

Returns the "default value" for a type.

impl Display for G2Affine

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Eq for G2Affine

impl From<G2> for G2Affine

fn from(p: G2) -> G2Affine

Performs the conversion.

impl From<G2Affine> for G2

fn from(p: G2Affine) -> G2

Performs the conversion.

impl PartialEq<G2Affine> for G2Affine

fn eq(&self, other: &G2Affine) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &G2Affine) -> bool

This method tests for !=.

impl SerDes for G2Affine

fn serialize<W: Write>(&self, writer: &mut W, compressed: bool) -> Result<()>

Convert a G2 point to a blob.

fn deserialize<R: Read>(reader: &mut R, compressed: bool) -> Result<Self>

Deserialize a G2 element from a blob. Returns an error if deserialization fails.

impl StructuralEq for G2Affine

impl StructuralPartialEq for G2Affine

impl SubgroupCheck for G2Affine

fn in_subgroup(&self) -> bool

subgroup membership check using classical method: i.e., raise to the power of group order

impl Zeroize for G2Affine

fn zeroize(&mut self)

Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not "optimized away" by the compiler.