Struct G1Affine

pub struct G1Affine { /* private fields */ }

Trait Implementations

impl Clone for G1Affine

fn clone(&self) -> G1Affine

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CurveAffine for G1Affine

type Engine = Bls12

type Scalar = Fr

type Base = Fq

type Prepared = G1Prepared

type Projective = G1

type Uncompressed = G1Uncompressed

type Compressed = G1Compressed

type Pair = G2Affine

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

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

Converts this element into its affine representation.

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

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

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

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], ) -> G1

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], ) -> G1

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

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

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], ) -> G1

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 G1Affine

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

Formats the value using the given formatter.

impl Default for G1Affine

fn default() -> Self

Returns the “default value” for a type.

impl Display for G1Affine

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

Formats the value using the given formatter.

impl From<G1> for G1Affine

fn from(p: G1) -> G1Affine

Converts to this type from the input type.

impl From<G1Affine> for G1

fn from(p: G1Affine) -> G1

Converts to this type from the input type.

impl PartialEq for G1Affine

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl SerDes for G1Affine

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

Convert a G1 point to a blob.

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

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

impl SubgroupCheck for G1Affine

fn in_subgroup(&self) -> bool

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

impl Zeroize for G1Affine

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.

impl Copy for G1Affine

impl Eq for G1Affine

impl StructuralPartialEq for G1Affine