Struct AffinePoint

pub struct AffinePoint<'a, E: Engine, G: GenericCurveAffine>
where
    <G as GenericCurveAffine>::Base: PrimeField,
{
    pub x: FieldElement<'a, E, G::Base>,
    pub y: FieldElement<'a, E, G::Base>,
    pub value: Option<G>,
}

Fields

x: FieldElement<'a, E, G::Base>

y: FieldElement<'a, E, G::Base>

value: Option<G>

Implementations

impl<'a, E: Engine, G: GenericCurveAffine> AffinePoint<'a, E, G>

where <G as GenericCurveAffine>::Base: PrimeField,

pub fn get_x(&self) -> FieldElement<'a, E, G::Base>

pub fn get_y(&self) -> FieldElement<'a, E, G::Base>

pub fn alloc<CS: ConstraintSystem<E>>( cs: &mut CS, value: Option<G>, params: &'a RnsParameters<E, G::Base>, ) -> Result<Self, SynthesisError>

pub fn from_xy_unchecked( x: FieldElement<'a, E, G::Base>, y: FieldElement<'a, E, G::Base>, ) -> Self

pub fn constant(value: G, params: &'a RnsParameters<E, G::Base>) -> Self

pub fn zero(params: &'a RnsParameters<E, G::Base>) -> Self

pub fn is_constant(&self) -> bool

pub fn get_value(&self) -> Option<G>

pub fn equals<CS: ConstraintSystem<E>>( cs: &mut CS, this: Self, other: Self, ) -> Result<(Boolean, (Self, Self)), SynthesisError>

pub fn negate<CS: ConstraintSystem<E>>( self, cs: &mut CS, ) -> Result<(Self, Self), SynthesisError>

pub fn conditionally_negate<CS: ConstraintSystem<E>>( self, cs: &mut CS, flag: &Boolean, ) -> Result<(Self, (Self, Self)), SynthesisError>

pub fn add_unequal<CS: ConstraintSystem<E>>( self, cs: &mut CS, other: Self, ) -> Result<(Self, (Self, Self)), SynthesisError>

pub fn add_unequal_unchecked<CS: ConstraintSystem<E>>( self, cs: &mut CS, other: Self, ) -> Result<(Self, (Self, Self)), SynthesisError>

pub fn sub_unequal<CS: ConstraintSystem<E>>( self, cs: &mut CS, other: Self, ) -> Result<(Self, (Self, Self)), SynthesisError>

pub fn double<CS: ConstraintSystem<E>>( self, cs: &mut CS, ) -> Result<(Self, Self), SynthesisError>

pub fn double_and_add<CS: ConstraintSystem<E>>( self, cs: &mut CS, other: Self, ) -> Result<(Self, (Self, Self)), SynthesisError>

pub fn double_and_add_unchecked<CS: ConstraintSystem<E>>( self, cs: &mut CS, other: Self, ) -> Result<(Self, (Self, Self)), SynthesisError>

pub fn mul_by_fixed_scalar<CS: ConstraintSystem<E>>( self, _cs: &mut CS, _scalar: &G::Scalar, ) -> Result<(Self, Self), SynthesisError>

pub fn select<CS: ConstraintSystem<E>>( cs: &mut CS, flag: &Boolean, first: Self, second: Self, ) -> Result<(Self, (Self, Self)), SynthesisError>

pub fn is_on_curve_for_zero_a<CS: ConstraintSystem<E>>( self, cs: &mut CS, curve_b: G::Base, ) -> Result<(Boolean, Self), SynthesisError>

pub fn mul_by_skewed_scalar_decomposition<CS: ConstraintSystem<E>>( self, cs: &mut CS, entries: &[Boolean], offset_generator: G, ) -> Result<(Self, Self), SynthesisError>

impl<'a, E: Engine> AffinePoint<'a, E, E::G1Affine>

pub fn mul<CS: ConstraintSystem<E>>( self, cs: &mut CS, scalar: &Num<E>, bit_limit: Option<usize>, ) -> Result<(Self, Self), SynthesisError>

pub fn multiexp<CS: ConstraintSystem<E>>( cs: &mut CS, scalars: &[Num<E>], points: &[Self], bit_limit: Option<usize>, ) -> Result<Self, SynthesisError>

pub fn multiexp_using_endomorphism<CS: ConstraintSystem<E>>( cs: &mut CS, scalars: &[Num<E>], points: &[Self], endo_parameters: &EndomorphismParameters<E>, ) -> Result<Self, SynthesisError>

Trait Implementations

impl<'a, E: Clone + Engine, G: Clone + GenericCurveAffine> Clone for AffinePoint<'a, E, G>

where <G as GenericCurveAffine>::Base: PrimeField, G::Base: Clone,

fn clone(&self) -> AffinePoint<'a, E, G>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a, E: Debug + Engine, G: Debug + GenericCurveAffine> Debug for AffinePoint<'a, E, G>

where <G as GenericCurveAffine>::Base: PrimeField, G::Base: Debug,

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

Formats the value using the given formatter.