Struct snarkvm_curves::templates::short_weierstrass_jacobian::affine::Affine

pub struct Affine<P: Parameters> {
    pub x: P::BaseField,
    pub y: P::BaseField,
    pub infinity: bool,
}

Fields

x: P::BaseField

y: P::BaseField

infinity: bool

Implementations

impl<P: Parameters> Affine<P>

pub const fn new(x: P::BaseField, y: P::BaseField, infinity: bool) -> Self

Trait Implementations

impl<P: Parameters> AffineCurve for Affine<P>

fn from_coordinates(coordinates: Self::Coordinates) -> Option<Self>

Initializes a new affine group element from the given coordinates.

fn from_coordinates_unchecked(coordinates: Self::Coordinates) -> Self

Initializes a new affine group element from the given coordinates. Note: The resulting point is not enforced to be on the curve or in the correct subgroup.

fn from_x_coordinate(x: Self::BaseField, greatest: bool) -> Option<Self>

Attempts to construct an affine point given an x-coordinate. The point is not guaranteed to be in the prime order subgroup.

If and only if greatest is set will the lexicographically largest y-coordinate be selected.

fn from_y_coordinate(_y: Self::BaseField, _greatest: bool) -> Option<Self>

Attempts to construct an affine point given a y-coordinate. The point is not guaranteed to be in the prime order subgroup.

If and only if greatest is set will the lexicographically largest y-coordinate be selected.

fn is_on_curve(&self) -> bool

Checks that the current point is on the elliptic curve.

fn batch_add_loop_1(
    a: &mut Self,
    b: &mut Self,
    half: &Self::BaseField,
    inversion_tmp: &mut Self::BaseField
)

Performs the first half of batch addition in-place: lambda := (y2 - y1) / (x2 - x1), for two given affine points.

fn batch_add_loop_2(a: &mut Self, b: Self, inversion_tmp: &mut Self::BaseField)

Performs the second half of batch addition in-place: x3 := lambda^2 - x1 - x2 y3 := lambda * (x1 - x3) - y1.

type BaseField = <P as ModelParameters>::BaseField

type Coordinates = (<Affine<P> as AffineCurve>::BaseField, <Affine<P> as AffineCurve>::BaseField, bool)

type Projective = Projective<P>

type ScalarField = <P as ModelParameters>::ScalarField

fn cofactor() -> &'static [u64]

Returns the cofactor of the curve.

fn prime_subgroup_generator() -> Self

Returns a fixed generator of unknown exponent.

fn from_random_bytes(bytes: &[u8]) -> Option<Self>

Returns a group element if the set of bytes forms a valid group element, otherwise returns None. This function is primarily intended for sampling random group elements from a hash-function or RNG output.

fn mul_bits(&self, bits: impl Iterator<Item = bool>) -> Projective<P>

Multiply this element by a big-endian boolean representation of an integer.

fn mul_by_cofactor_to_projective(&self) -> Self::Projective

Multiply this element by the cofactor and output the resulting projective element.

fn mul_by_cofactor_inv(&self) -> Self

Multiply this element by the inverse of the cofactor modulo the size of Self::ScalarField.

fn to_projective(&self) -> Projective<P>

Converts this element into its projective representation.

fn is_in_correct_subgroup_assuming_on_curve(&self) -> bool

Checks that the point is in the prime order subgroup given the point on the curve.

fn to_x_coordinate(&self) -> Self::BaseField

Returns the x-coordinate of the point.

fn to_y_coordinate(&self) -> Self::BaseField

Returns the y-coordinate of the point.

fn mul_by_cofactor(&self) -> Self

Multiply this element by the cofactor.

impl<P: Parameters> CanonicalDeserialize for Affine<P>

fn deserialize_with_mode<R: Read>(
    reader: R,
    compress: Compress,
    validate: Validate
) -> Result<Self, SerializationError>

fn deserialize_compressed<R>(reader: R) -> Result<Self, SerializationError>where
    R: Read,

fn deserialize_compressed_unchecked<R>(
    reader: R
) -> Result<Self, SerializationError>where
    R: Read,

fn deserialize_uncompressed<R>(reader: R) -> Result<Self, SerializationError>where
    R: Read,

fn deserialize_uncompressed_unchecked<R>(
    reader: R
) -> Result<Self, SerializationError>where
    R: Read,

impl<P: Parameters> CanonicalSerialize for Affine<P>

fn serialize_with_mode<W: Write>(
    &self,
    writer: W,
    compress: Compress
) -> Result<(), SerializationError>

fn serialized_size(&self, compress: Compress) -> usize

fn serialize_compressed<W>(&self, writer: W) -> Result<(), SerializationError>where
    W: Write,

fn compressed_size(&self) -> usize

fn serialize_uncompressed<W>(&self, writer: W) -> Result<(), SerializationError>where
    W: Write,

fn uncompressed_size(&self) -> usize

impl<P: Clone + Parameters> Clone for Affine<P>where
    P::BaseField: Clone,
    P::BaseField: Clone,

fn clone(&self) -> Affine<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Debug + Parameters> Debug for Affine<P>where
    P::BaseField: Debug,
    P::BaseField: Debug,

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

Formats the value using the given formatter.

impl<P: Parameters> Default for Affine<P>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, P: Parameters> Deserialize<'de> for Affine<P>where
    P::BaseField: Deserialize<'de>,
    P::BaseField: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<P: Parameters> Display for Affine<P>

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

Formats the value using the given formatter.

impl<P: Parameters> Distribution<Affine<P>> for Standard

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Affine<P>

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>where
    R: Rng,
    Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>where
    F: Fn(T) -> S,
    Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl<P: Parameters> From<Affine<P>> for Projective<P>

The affine point X, Y is represented in the Jacobian coordinates with Z = 1.

fn from(p: Affine<P>) -> Projective<P>

Converts to this type from the input type.

impl<P: Parameters> From<Projective<P>> for Affine<P>

fn from(p: Projective<P>) -> Affine<P>

Converts to this type from the input type.

impl<P: Parameters> FromBytes for Affine<P>

fn read_le<R: Read>(reader: R) -> IoResult<Self>

Reads Self from reader as little-endian bytes.

fn from_bytes_le(bytes: &[u8]) -> Result<Self, Error>where
    Self: Sized,

Returns Self from a byte array in little-endian order.

impl<P: Hash + Parameters> Hash for Affine<P>where
    P::BaseField: Hash,
    P::BaseField: Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<P: Parameters> Mul<<P as ModelParameters>::ScalarField> for Affine<P>

type Output = Projective<P>

The resulting type after applying the * operator.

fn mul(self, other: P::ScalarField) -> Self::Output

Performs the * operation.

impl<P: Parameters> Neg for Affine<P>

type Output = Affine<P>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<P: PartialEq + Parameters> PartialEq<Affine<P>> for Affine<P>where
    P::BaseField: PartialEq,
    P::BaseField: PartialEq,

fn eq(&self, other: &Affine<P>) -> bool

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

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

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

impl<P: Parameters> PartialEq<Affine<P>> for Projective<P>

fn eq(&self, other: &Affine<P>) -> bool

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

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

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

impl<P: Parameters> PartialEq<Projective<P>> for Affine<P>

fn eq(&self, other: &Projective<P>) -> bool

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

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

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

impl<P: Parameters> Serialize for Affine<P>where
    P::BaseField: Serialize,
    P::BaseField: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<P: Parameters> ToBytes for Affine<P>

fn write_le<W: Write>(&self, writer: W) -> IoResult<()>

Writes self into writer as little-endian bytes.

fn to_bytes_le(&self) -> Result<Vec<u8, Global>, Error>where
    Self: Sized,

Returns self as a byte array in little-endian order.

impl<M: ShortWeierstrassParameters, F: Field> ToConstraintField<F> for SWAffine<M>where
    M::BaseField: ToConstraintField<F>,

fn to_field_elements(&self) -> Result<Vec<F>, ConstraintFieldError>

impl<P: Parameters> ToMinimalBits for Affine<P>

fn to_minimal_bits(&self) -> Vec<bool>

Returns self as a minimal boolean array.

impl<P: Parameters> Valid for Affine<P>

fn check(&self) -> Result<(), SerializationError>

fn batch_check<'a>(
    batch: impl Iterator<Item = &'a Self> + Send
) -> Result<(), SerializationError>where
    Self: 'a,

impl<P: Parameters> Zero for Affine<P>

fn zero() -> Self

fn is_zero(&self) -> bool

impl<P: Copy + Parameters> Copy for Affine<P>where
    P::BaseField: Copy,
    P::BaseField: Copy,

impl<P: Eq + Parameters> Eq for Affine<P>where
    P::BaseField: Eq,
    P::BaseField: Eq,

impl<P: Parameters> StructuralEq for Affine<P>

impl<P: Parameters> StructuralPartialEq for Affine<P>