Struct Point

pub struct Point<E: Curve>(/* private fields */);

Torsion-free point on elliptic curve E

Any instance of Point is guaranteed to be on curve E and free of torsion component. Note that identity point (sometimes called point at infinity) is a valid point that can be obtained by calling Point::zero().

Point implements all necessary arithmetic operations: points addition, multiplication at scalar, etc.

Implementations

impl<E: Curve> Point<E>

pub fn double(&self) -> Self

Doubles the point, returns self + self

point.double() may be more efficient than point + point or 2 * point

impl<E: Curve> Point<E>

pub fn generator() -> Generator<E>

Curve generator

Curve generator is a regular point defined in curve specs. See Generator<E>.

pub fn zero() -> Self

Returns identity point $\O$ (sometimes called as point at infinity)

Identity point has special properties:

$$\forall P \in \G: P + \O = P$$ $$\forall s \in \Zq: s \cdot \O = \O$$

When you validate input from user or message received on wire, you should bear in mind that any Point<E> may be zero. If your algorithm does not accept identity points, you may check whether point is zero by calling .is_zero(). Alternatively, you may accept NonZero<Point<E>> instead, which is guaranteed to be non zero.

pub fn is_zero(&self) -> bool

Indicates whether it’s identity point

use generic_ec::{Point, curves::Secp256k1};

assert!(Point::<Secp256k1>::zero().is_zero());
assert!(!Point::<Secp256k1>::generator().to_point().is_zero());

pub fn ct_is_zero(&self) -> Choice

Indicates whether it’s identity point (in constant time)

Same as .is_zero() but performs constant-time comparison.

pub fn to_bytes(&self, compressed: bool) -> EncodedPoint<E>

Encodes a point as bytes

Function can return both compressed and uncompressed bytes representation of a point. Compressed bytes representation is more compact, but parsing takes a little bit more time. On other hand, uncompressed representation takes ~twice more space, but parsing is instant.

For some curves, compressed parameter may be ignored, and same bytes representation is returned.

use generic_ec::{Point, Scalar, curves::Secp256k1};
use rand::rngs::OsRng;

let random_point = Point::<Secp256k1>::generator() * Scalar::random(&mut OsRng);
let point_bytes = random_point.to_bytes(false);
let point_decoded = Point::from_bytes(&point_bytes)?;
assert_eq!(random_point, point_decoded);

pub fn from_bytes(bytes: impl AsRef<[u8]>) -> Result<Self, InvalidPoint>

Decodes a point from bytes

pub fn serialized_len(compressed: bool) -> usize

Returns size of bytes buffer that can fit a serialized point

compressed parameter has the same meaning as for Point::to_bytes; a buffer created with length of Point::serialized_len(compress) would fit exactly the serialization p.to_bytes(compress).

Trait Implementations

impl<E: Curve> Add<&Generator<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Generator<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Generator<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Generator<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&NonZero<Point<E>>> for &Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZero<Point<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&NonZero<Point<E>>> for Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZero<Point<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Point<E>> for &Generator<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Point<E>> for &NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Point<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Point<E>> for Generator<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Point<E>> for NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<&Point<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: &Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Generator<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: Generator<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Generator<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: Generator<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<NonZero<Point<E>>> for &Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: NonZero<Point<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<NonZero<Point<E>>> for Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: NonZero<Point<E>>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Point<E>> for &Generator<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Point<E>> for &NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Point<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Point<E>> for Generator<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add<Point<E>> for NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> Add for Point<E>

type Output = Point<E>

The resulting type after applying the + operator.

fn add(self, rhs: Point<E>) -> Self::Output

Performs the + operation.

impl<E: Curve> AddAssign<&Generator<E>> for Point<E>

fn add_assign(&mut self, rhs: &Generator<E>)

Performs the += operation.

impl<E: Curve> AddAssign<&NonZero<Point<E>>> for Point<E>

fn add_assign(&mut self, rhs: &NonZero<Point<E>>)

Performs the += operation.

impl<E: Curve> AddAssign<&Point<E>> for Point<E>

fn add_assign(&mut self, rhs: &Point<E>)

Performs the += operation.

impl<E: Curve> AddAssign<Generator<E>> for Point<E>

fn add_assign(&mut self, rhs: Generator<E>)

Performs the += operation.

impl<E: Curve> AddAssign<NonZero<Point<E>>> for Point<E>

fn add_assign(&mut self, rhs: NonZero<Point<E>>)

Performs the += operation.

impl<E: Curve> AddAssign for Point<E>

fn add_assign(&mut self, rhs: Point<E>)

Performs the += operation.

impl<E> AlwaysHasAffineY<E> for Point<E>

where E: AlwaysHasAffineY + Curve,

fn y(&self) -> Coordinate<E>

Retrieves affine $y$ coordinate

impl<E> AlwaysHasAffineYAndSign<E> for Point<E>

where E: AlwaysHasAffineYAndSign + Curve,

fn y_and_sign(&self) -> (Sign, Coordinate<E>)

Retrieves affine $y$ coordinate and sign of $x$ coordinate

fn from_y_and_sign(x_sign: Sign, y: &Coordinate<E>) -> Option<Self>

Constructs point from its $y$ coordinate and sign of $x$ coordinate

impl<E: Curve> AsRaw for Point<E>

type Raw = <E as Curve>::Point

Wrapped point/scalar

fn as_raw(&self) -> &E::Point

Returns reference to wrapped value

impl<E: Curve> AsRef<Point<E>> for Point<E>

fn as_ref(&self) -> &Point<E>

Converts this type into a shared reference of the (usually inferred) input type.

impl<E: Clone + Curve> Clone for Point<E>

where E::Point: Clone,

fn clone(&self) -> Point<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Curve> ConditionallySelectable for Point<E>

fn conditional_select(a: &Self, b: &Self, choice: Choice) -> Self

Select a or b according to choice.

fn conditional_assign(&mut self, other: &Self, choice: Choice)

Conditionally assign other to self, according to choice.

fn conditional_swap(a: &mut Self, b: &mut Self, choice: Choice)

Conditionally swap self and other if choice == 1; otherwise, reassign both unto themselves.

impl<E: Curve> ConstantTimeEq for Point<E>

fn ct_eq(&self, other: &Self) -> Choice

Determine if two items are equal.

fn ct_ne(&self, other: &Self) -> Choice

Determine if two items are NOT equal.

impl<E: Curve> Debug for Point<E>

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

Formats the value using the given formatter.

impl<E: Default + Curve> Default for Point<E>

where E::Point: Default,

fn default() -> Point<E>

Returns the “default value” for a type.

impl<'de, E: Curve> Deserialize<'de> for Point<E>

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, E: Curve> DeserializeAs<'de, Point<E>> for Compact

Available on crate feature serde only.

fn deserialize_as<D>(deserializer: D) -> Result<Point<E>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E: Curve> Digestable for Point<E>

Available on crate feature udigest only.

fn unambiguously_encode<B>(&self, encoder: EncodeValue<'_, B>)

where B: Buffer,

Unambiguously encodes the value

impl<E: Curve> From<Generator<E>> for Point<E>

fn from(_: Generator<E>) -> Self

Converts to this type from the input type.

impl<E: Curve> From<NonZero<Point<E>>> for Point<E>

fn from(point: NonZero<Point<E>>) -> Self

Converts to this type from the input type.

impl<E: Curve + NoInvalidPoints> FromRaw for Point<E>

fn from_raw(raw: Self::Raw) -> Self

Infallibly wraps raw value

impl<E> HasAffineX<E> for Point<E>

where E: HasAffineX + Curve,

fn x(&self) -> Option<Coordinate<E>>

Retrieves affine $x$ coordinate

impl<E> HasAffineXAndParity<E> for Point<E>

where E: HasAffineXAndParity + Curve,

fn x_and_parity(&self) -> Option<(Coordinate<E>, Parity)>

Retrieves affine $x$ coordinate and parity of $y$ coordinate

fn from_x_and_parity(x: &Coordinate<E>, y_parity: Parity) -> Option<Self>

Constructs point from its $x$ coordinate and parity of $y$ coordinate

impl<E> HasAffineXY<E> for Point<E>

where E: HasAffineXY + Curve,

fn coords(&self) -> Option<Coordinates<E>>

Retrieves affine $x, y$ coordinates

fn from_coords(coords: &Coordinates<E>) -> Option<Self>

Constructs point from its $x, y$ coordinates

impl<E> HasAffineY<E> for Point<E>

where E: HasAffineY + Curve,

fn y(&self) -> Option<Coordinate<E>>

Retrieves affine $y$ coordinate

impl<E: Curve> Hash for Point<E>

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<E: Curve> IsZero for Point<E>

fn is_zero(&self) -> bool

Checks whether self is zero

impl<E: Curve> Mul<&NonZero<Scalar<E>>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<Scalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&NonZero<Scalar<E>>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<Scalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&NonZero<SecretScalar<E>>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<SecretScalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&NonZero<SecretScalar<E>>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &NonZero<SecretScalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for &NonZero<Scalar<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for &NonZero<SecretScalar<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for &Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for &SecretScalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for NonZero<Scalar<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for NonZero<SecretScalar<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Point<E>> for SecretScalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&Scalar<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&SecretScalar<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &SecretScalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<&SecretScalar<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: &SecretScalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<Scalar<E>>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<Scalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<Scalar<E>>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<Scalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<SecretScalar<E>>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<SecretScalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<NonZero<SecretScalar<E>>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: NonZero<SecretScalar<E>>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for &NonZero<Scalar<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for &NonZero<SecretScalar<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for &Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for &SecretScalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for NonZero<Scalar<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for NonZero<SecretScalar<E>>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for Scalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Point<E>> for SecretScalar<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Point<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<Scalar<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: Scalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<SecretScalar<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: SecretScalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> Mul<SecretScalar<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the * operator.

fn mul(self, rhs: SecretScalar<E>) -> Self::Output

Performs the * operation.

impl<E: Curve> MulAssign<&NonZero<Scalar<E>>> for Point<E>

fn mul_assign(&mut self, rhs: &NonZero<Scalar<E>>)

Performs the *= operation.

impl<E: Curve> MulAssign<&NonZero<SecretScalar<E>>> for Point<E>

fn mul_assign(&mut self, rhs: &NonZero<SecretScalar<E>>)

Performs the *= operation.

impl<E: Curve> MulAssign<&Scalar<E>> for Point<E>

fn mul_assign(&mut self, rhs: &Scalar<E>)

Performs the *= operation.

impl<E: Curve> MulAssign<&SecretScalar<E>> for Point<E>

fn mul_assign(&mut self, rhs: &SecretScalar<E>)

Performs the *= operation.

impl<E: Curve> MulAssign<NonZero<Scalar<E>>> for Point<E>

fn mul_assign(&mut self, rhs: NonZero<Scalar<E>>)

Performs the *= operation.

impl<E: Curve> MulAssign<NonZero<SecretScalar<E>>> for Point<E>

fn mul_assign(&mut self, rhs: NonZero<SecretScalar<E>>)

Performs the *= operation.

impl<E: Curve> MulAssign<Scalar<E>> for Point<E>

fn mul_assign(&mut self, rhs: Scalar<E>)

Performs the *= operation.

impl<E: Curve> MulAssign<SecretScalar<E>> for Point<E>

fn mul_assign(&mut self, rhs: SecretScalar<E>)

Performs the *= operation.

impl<E: Curve> Neg for &Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Curve> Neg for Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Curve> Ord for Point<E>

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<E: Curve> PartialEq<NonZero<Point<E>>> for Point<E>

fn eq(&self, other: &NonZero<Point<E>>) -> bool

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

const 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<E: PartialEq + Curve> PartialEq for Point<E>

where E::Point: PartialEq,

fn eq(&self, other: &Point<E>) -> bool

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

const 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<E: Curve> PartialOrd<NonZero<Point<E>>> for Point<E>

fn partial_cmp(&self, other: &NonZero<Point<E>>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E: Curve> PartialOrd for Point<E>

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<E: Curve> Serialize for Point<E>

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<E: Curve> SerializeAs<Point<E>> for Compact

Available on crate feature serde only.

fn serialize_as<S>(source: &Point<E>, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<E: Curve> Sub<&Generator<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Generator<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Generator<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Generator<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&NonZero<Point<E>>> for &Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZero<Point<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&NonZero<Point<E>>> for Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZero<Point<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Point<E>> for &Generator<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Point<E>> for &NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Point<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Point<E>> for Generator<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Point<E>> for NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<&Point<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Generator<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Generator<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Generator<E>> for Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Generator<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<NonZero<Point<E>>> for &Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZero<Point<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<NonZero<Point<E>>> for Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZero<Point<E>>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Point<E>> for &Generator<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Point<E>> for &NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Point<E>> for &Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Point<E>> for Generator<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub<Point<E>> for NonZero<Point<E>>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> Sub for Point<E>

type Output = Point<E>

The resulting type after applying the - operator.

fn sub(self, rhs: Point<E>) -> Self::Output

Performs the - operation.

impl<E: Curve> SubAssign<&Generator<E>> for Point<E>

fn sub_assign(&mut self, rhs: &Generator<E>)

Performs the -= operation.

impl<E: Curve> SubAssign<&NonZero<Point<E>>> for Point<E>

fn sub_assign(&mut self, rhs: &NonZero<Point<E>>)

Performs the -= operation.

impl<E: Curve> SubAssign<&Point<E>> for Point<E>

fn sub_assign(&mut self, rhs: &Point<E>)

Performs the -= operation.

impl<E: Curve> SubAssign<Generator<E>> for Point<E>

fn sub_assign(&mut self, rhs: Generator<E>)

Performs the -= operation.

impl<E: Curve> SubAssign<NonZero<Point<E>>> for Point<E>

fn sub_assign(&mut self, rhs: NonZero<Point<E>>)

Performs the -= operation.

impl<E: Curve> SubAssign for Point<E>

fn sub_assign(&mut self, rhs: Point<E>)

Performs the -= operation.

impl<'s, E: Curve> Sum<&'s NonZero<Point<E>>> for Point<E>

fn sum<I: Iterator<Item = &'s NonZero<Point<E>>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<'a, E: Curve> Sum<&'a Point<E>> for Point<E>

fn sum<I: Iterator<Item = &'a Point<E>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<E: Curve> Sum<NonZero<Point<E>>> for Point<E>

fn sum<I: Iterator<Item = NonZero<Point<E>>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<E: Curve> Sum for Point<E>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<E: Curve> TryFrom<Point<E>> for NonZero<Point<E>>

type Error = ZeroPoint

The type returned in the event of a conversion error.

fn try_from(point: Point<E>) -> Result<Self, Self::Error>

Performs the conversion.

impl<E: Curve> TryFromRaw for Point<E>

fn ct_try_from_raw(point: E::Point) -> CtOption<Self>

Wraps raw value (constant time)

fn try_from_raw(raw: Self::Raw) -> Option<Self>

Wraps raw value

impl<E: Curve> Zero for Point<E>

fn zero() -> Self

Constructs zero value of Self

fn is_zero(x: &Self) -> Choice

Checks (in constant-time) if x is zero

impl<E: Curve> Zeroize for Point<E>

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<E: Copy + Curve> Copy for Point<E>

where E::Point: Copy,

impl<E: Eq + Curve> Eq for Point<E>

where E::Point: Eq,

impl<E: Curve> StructuralPartialEq for Point<E>