Struct NonZero 

pub struct NonZero<T>(/* private fields */);

Non zero Point or Scalar

Implementations

impl<T> NonZero<T>

pub fn into_inner(self) -> T

Returns wrapped value

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

pub fn from_point(point: Point<E>) -> Option<Self>

Constructs non-zero point

Returns None if point is zero

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

Constructs non-zero point (constant time)

Returns None if point is zero

impl<E: Curve> NonZero<Scalar<E>>

pub fn random<R: RngCore>(rng: &mut R) -> Self

Generates random non-zero scalar

Guarantees

1. Uniform distribution
   Output scalar is uniformly distributed (given that provided PRNG outputs uniformly distributed bytes), with possible negligible bias respective to curve target security level
2. Constant-time
   Random generation algorithm does not branch on input randomness, and in particular, it does not use rejection-sampling strategy (might not be the case with negligible probability respective to the curve target security level¹)
3. Reproducible
   When random generation algorithm is given the same PRNG with the same seed, it always outputs the same scalar on all platforms

If you don’t need constant-time/reproducibility properties, you can use random_vartime instead which is typically faster.

Panics

Panics if randomness source returned 100 zero scalars in a row. It happens with negligible probability, e.g. for secp256k1 curve it’s about $2^{-25600}$, which practically means that randomness source is broken.

---

1. we use rejection-sampling strategy in case if a zero scalar is generated, however, probability of that happening is negligible ↩

pub fn random_vartime<R: RngCore>(rng: &mut R) -> Self

Generates random non-zero scalar using variable time algorithm

Guarantees

1. Uniform distribution
   Output scalar is uniformly distributed (given that provided PRNG outputs uniformly distributed bytes), with possible negligible bias respective to curve target security level

Unlike random method, this one is not constant-time nor reproducible, but often it’s faster.

Panics

Panics if randomness source returned 100 zero scalars in a row. It happens with negligible probability, e.g. for secp256k1 curve it’s about $2^{-25600}$, which practically means that randomness source is broken.

pub fn from_hash<D: Digest>(data: &impl Digestable) -> Self

Available on crate feature hash-to-scalar only.

Hashes the input and outputs scalar

Input can be any structured data that implements Digestable trait (see udigest crate).

How it works

It works by instantiating HashRng CSPRNG seeded from provided data. Then it’s used to derive the scalar.

Security considerations

It’s not constant time. It doesn’t follow any existing standards for hash to scalar primitive.

Example

use generic_ec::{Scalar, NonZero, curves::Secp256k1};
use sha2::Sha256;

#[derive(udigest::Digestable)]
struct Data<'a> {
    nonce: &'a [u8],
    param_a: &'a str,
    param_b: u128,
    // ...
}

let scalar = NonZero::<Scalar<Secp256k1>>::from_hash::<Sha256>(&Data {
    nonce: b"some data",
    param_a: "some other data",
    param_b: 12345,
    // ...
});

pub fn one() -> Self

Constructs $S = 1$

pub fn from_scalar(scalar: Scalar<E>) -> Option<Self>

Constructs non-zero scalar

Returns None if scalar is zero

pub fn ct_from_scalar(scalar: Scalar<E>) -> CtOption<Self>

Constructs non-zero scalar (constant time)

Returns None if scalar is zero

pub fn invert(&self) -> NonZero<Scalar<E>>

Returns scalar inverse $S^{-1}$

Similar to Scalar::invert, but this function is always defined as inverse is defined for all non-zero scalars

pub fn into_secret(self) -> NonZero<SecretScalar<E>>

Upgrades the non-zero scalar into non-zero SecretScalar

impl<E: Curve> NonZero<SecretScalar<E>>

pub fn random<R: RngCore + CryptoRng>(rng: &mut R) -> Self

Generates random non-zero scalar

Guarantees

1. Uniform distribution
   Output scalar is uniformly distributed (given that provided PRNG outputs uniformly distributed bytes), with possible negligible bias respective to curve target security level
2. Constant-time
   Random generation algorithm does not branch on input randomness, and in particular, it does not use rejection-sampling strategy (might not be the case with negligible probability respective to the curve target security level¹)
3. Reproducible
   When random generation algorithm is given the same PRNG with the same seed, it always outputs the same scalar on all platforms

If you don’t need constant-time/reproducibility properties, you can use random_vartime instead which is typically faster.

Panics

Panics if randomness source returned 100 zero scalars in a row. It happens with negligible probability, e.g. for secp256k1 curve it’s about $2^{-25600}$, which practically means that randomness source is broken.

---

1. we use rejection-sampling strategy in case if a zero scalar is generated, however, probability of that happening is negligible ↩

pub fn random_vartime<R: RngCore + CryptoRng>(rng: &mut R) -> Self

Generates random non-zero scalar using variable time algorithm

Guarantees

1. Uniform distribution
   Output scalar is uniformly distributed (given that provided PRNG outputs uniformly distributed bytes), with possible negligible bias respective to curve target security level

Unlike random method, this one is not constant-time nor reproducible, but often it’s faster.

Panics

Panics if randomness source returned 100 zero scalars in a row. It happens with negligible probability, e.g. for secp256k1 curve it’s about $2^{-25600}$, which practically means that randomness source is broken.

pub fn one() -> Self

Constructs $S = 1$

pub fn from_secret_scalar(scalar: SecretScalar<E>) -> Option<Self>

Constructs non-zero scalar

Returns None if scalar is zero

pub fn ct_from_secret_scalar(secret_scalar: SecretScalar<E>) -> CtOption<Self>

Constructs non-zero scalar (constant time)

Returns None if scalar is zero

pub fn invert(&self) -> NonZero<SecretScalar<E>>

Returns scalar inverse $S^{-1}$

Similar to SecretScalar::invert, but this function is always defined as inverse is defined for all non-zero scalars

Trait Implementations

impl<E: Curve> Add<&NonZero<Point<E>>> for &NonZero<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<&NonZero<Point<E>>> for NonZero<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<&NonZero<Scalar<E>>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&NonZero<Scalar<E>>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&NonZero<Scalar<E>>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&NonZero<Scalar<E>>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&NonZero<Scalar<E>>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&NonZero<SecretScalar<E>>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&NonZero<SecretScalar<E>>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: &NonZero<SecretScalar<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 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<&Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&SecretScalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<&SecretScalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<NonZero<Point<E>>> for &NonZero<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<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<Scalar<E>>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<NonZero<Scalar<E>>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<NonZero<Scalar<E>>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<NonZero<Scalar<E>>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<NonZero<Scalar<E>>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<NonZero<SecretScalar<E>>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<NonZero<SecretScalar<E>>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

fn add(self, rhs: NonZero<SecretScalar<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 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<Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<SecretScalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add<SecretScalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E: Curve> Add for NonZero<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 for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Scalar<E>

The resulting type after applying the + operator.

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

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<&NonZero<Scalar<E>>> for Scalar<E>

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

Performs the += operation.

impl<E: Curve> AddAssign<&NonZero<SecretScalar<E>>> for Scalar<E>

fn add_assign(&mut self, rhs: &NonZero<SecretScalar<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<NonZero<Scalar<E>>> for Scalar<E>

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

Performs the += operation.

impl<E: Curve> AddAssign<NonZero<SecretScalar<E>>> for Scalar<E>

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

Performs the += operation.

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

where Point<E>: HasAffineX<E>,

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

Retrieves affine $x$ coordinate of a point

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

where Point<E>: HasAffineXY<E>,

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

Constructs a point from affine coordinates

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

where Point<E>: HasAffineY<E>,

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

Retrieves affine $y$ coordinate

impl<E: Curve> AsRef<Scalar<E>> for NonZero<SecretScalar<E>>

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

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

impl<T> AsRef<T> for NonZero<T>

fn as_ref(&self) -> &T

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

impl<T: Clone> Clone for NonZero<T>

fn clone(&self) -> NonZero<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: ConstantTimeEq> ConstantTimeEq for NonZero<T>

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<T: Debug> Debug for NonZero<T>

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

Formats the value using the given formatter.

impl<T> Deref for NonZero<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'de, T> Deserialize<'de> for NonZero<T>

where NonZero<T>: TryFrom<T>, <NonZero<T> as TryFrom<T>>::Error: Display, T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'de, T> DeserializeAs<'de, NonZero<T>> for Compact

where Compact: DeserializeAs<'de, T>, NonZero<T>: TryFrom<T>, <NonZero<T> as TryFrom<T>>::Error: Display,

Available on crate feature serde only.

fn deserialize_as<D>(deserializer: D) -> Result<NonZero<T>, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Digestable for NonZero<T>

where T: Digestable,

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

where B: Buffer,

Unambiguously encodes the value

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

fn from(g: 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> From<NonZero<Scalar<E>>> for Scalar<E>

fn from(scalar: NonZero<Scalar<E>>) -> Self

Converts to this type from the input type.

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

fn from(secret_scalar: NonZero<SecretScalar<E>>) -> Self

Converts to this type from the input type.

impl<T: Hash> Hash for NonZero<T>

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<T> IsZero for NonZero<T>

fn is_zero(&self) -> bool

Returns false as NonZero<T> cannot be zero

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<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 &NonZero<Point<E>>

type Output = NonZero<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 &NonZero<Scalar<E>>

type Output = NonZero<Scalar<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 &NonZero<SecretScalar<E>>

type Output = NonZero<Scalar<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<Scalar<E>>> for &Scalar<E>

type Output = Scalar<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 &SecretScalar<E>

type Output = Scalar<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 Generator<E>

type Output = NonZero<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 NonZero<Point<E>>

type Output = NonZero<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 NonZero<Scalar<E>>

type Output = NonZero<Scalar<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 NonZero<SecretScalar<E>>

type Output = NonZero<Scalar<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<Scalar<E>>> for Scalar<E>

type Output = Scalar<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 SecretScalar<E>

type Output = Scalar<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 &Generator<E>

type Output = NonZero<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 &NonZero<Point<E>>

type Output = NonZero<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 &NonZero<Scalar<E>>

type Output = NonZero<Scalar<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 &NonZero<SecretScalar<E>>

type Output = NonZero<Scalar<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<&NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<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 Generator<E>

type Output = NonZero<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 NonZero<Point<E>>

type Output = NonZero<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 NonZero<Scalar<E>>

type Output = NonZero<Scalar<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 NonZero<SecretScalar<E>>

type Output = NonZero<Scalar<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<&NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<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 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<&Scalar<E>> for &NonZero<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 &NonZero<Scalar<E>>

type Output = Scalar<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 &NonZero<SecretScalar<E>>

type Output = Scalar<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 NonZero<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 NonZero<Scalar<E>>

type Output = Scalar<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 NonZero<SecretScalar<E>>

type Output = Scalar<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 &NonZero<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 &NonZero<Scalar<E>>

type Output = Scalar<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 NonZero<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 NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Point<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<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 &NonZero<Point<E>>

type Output = NonZero<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 &NonZero<Scalar<E>>

type Output = NonZero<Scalar<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 &NonZero<SecretScalar<E>>

type Output = NonZero<Scalar<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<Scalar<E>>> for &Scalar<E>

type Output = Scalar<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 &SecretScalar<E>

type Output = Scalar<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 Generator<E>

type Output = NonZero<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 NonZero<Point<E>>

type Output = NonZero<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 NonZero<SecretScalar<E>>

type Output = NonZero<Scalar<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<Scalar<E>>> for Scalar<E>

type Output = Scalar<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 SecretScalar<E>

type Output = Scalar<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 &Generator<E>

type Output = NonZero<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 &NonZero<Point<E>>

type Output = NonZero<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 &NonZero<Scalar<E>>

type Output = NonZero<Scalar<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 &NonZero<SecretScalar<E>>

type Output = NonZero<Scalar<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<NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<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 Generator<E>

type Output = NonZero<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 NonZero<Point<E>>

type Output = NonZero<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 NonZero<Scalar<E>>

type Output = NonZero<Scalar<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<NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<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 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<Scalar<E>> for &NonZero<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 &NonZero<Scalar<E>>

type Output = Scalar<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 &NonZero<SecretScalar<E>>

type Output = Scalar<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 NonZero<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 NonZero<Scalar<E>>

type Output = Scalar<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 NonZero<SecretScalar<E>>

type Output = Scalar<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 &NonZero<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 &NonZero<Scalar<E>>

type Output = Scalar<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 NonZero<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 NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Scalar<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = NonZero<Scalar<E>>

The resulting type after applying the * operator.

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

Performs the * operation.

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

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

Performs the *= operation.

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

fn mul_assign(&mut self, rhs: &NonZero<Scalar<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<Scalar<E>>> for Scalar<E>

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

Performs the *= operation.

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

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

Performs the *= operation.

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

fn mul_assign(&mut self, rhs: &NonZero<SecretScalar<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<&NonZero<SecretScalar<E>>> for Scalar<E>

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

Performs the *= operation.

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

fn mul_assign(&mut self, rhs: NonZero<Scalar<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<Scalar<E>>> for Scalar<E>

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

Performs the *= operation.

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

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

Performs the *= operation.

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

fn mul_assign(&mut self, rhs: NonZero<SecretScalar<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<NonZero<SecretScalar<E>>> for Scalar<E>

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

Performs the *= operation.

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

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

Performs the *= operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Curve> Neg for &NonZero<Scalar<E>>

type Output = NonZero<Scalar<E>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Curve> Neg for &NonZero<SecretScalar<E>>

type Output = NonZero<SecretScalar<E>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

type Output = NonZero<Point<E>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Curve> Neg for NonZero<Scalar<E>>

type Output = NonZero<Scalar<E>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Curve> Neg for NonZero<SecretScalar<E>>

type Output = NonZero<SecretScalar<E>>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E: Curve> One for NonZero<Scalar<E>>

fn one() -> Self

Constructs one value of Self

fn is_one(x: &Self) -> Choice

Checks (in constant-time) if x is one

impl<T: Ord> Ord for NonZero<T>

fn cmp(&self, other: &NonZero<T>) -> 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 ==.

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> PartialEq<NonZero<Scalar<E>>> for Scalar<E>

fn eq(&self, other: &NonZero<Scalar<E>>) -> 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<T> PartialEq<T> for NonZero<T>

where T: PartialEq,

fn eq(&self, other: &T) -> 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<T: PartialEq> PartialEq for NonZero<T>

fn eq(&self, other: &NonZero<T>) -> 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<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<NonZero<Scalar<E>>> for Scalar<E>

fn partial_cmp(&self, other: &NonZero<Scalar<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<T> PartialOrd<T> for NonZero<T>

where T: PartialOrd,

fn partial_cmp(&self, other: &T) -> 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<T: PartialOrd> PartialOrd for NonZero<T>

fn partial_cmp(&self, other: &NonZero<T>) -> 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<'s, E: Curve> Product<&'s NonZero<Scalar<E>>> for NonZero<Scalar<E>>

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

Takes an iterator and generates Self from the elements by multiplying the items.

impl<'s, E: Curve> Product<&'s NonZero<SecretScalar<E>>> for NonZero<SecretScalar<E>>

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

Takes an iterator and generates Self from the elements by multiplying the items.

impl<E: Curve> Product for NonZero<Scalar<E>>

fn product<I: Iterator<Item = NonZero<Scalar<E>>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<E: Curve> Product for NonZero<SecretScalar<E>>

fn product<I: Iterator<Item = NonZero<SecretScalar<E>>>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<E: Curve> Samplable for NonZero<Scalar<E>>

fn random<R: RngCore>(rng: &mut R) -> Self

Uniformly samples an instance of Self from source of randomness using constant-time method

fn random_vartime<R: RngCore>(rng: &mut R) -> Self

Uniformly samples an instance of Self from source of randomness using vartime method

impl<E: Curve> Samplable for NonZero<SecretScalar<E>>

fn random<R: RngCore>(rng: &mut R) -> Self

Uniformly samples an instance of Self from source of randomness using constant-time method

fn random_vartime<R: RngCore>(rng: &mut R) -> Self

Uniformly samples an instance of Self from source of randomness using vartime method

impl<T> Serialize for NonZero<T>

where T: From<NonZero<T>> + Clone + Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T> SerializeAs<NonZero<T>> for Compact

where Compact: SerializeAs<T>,

Available on crate feature serde only.

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

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<E: Curve> Sub<&NonZero<Point<E>>> for &NonZero<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<&NonZero<Point<E>>> for NonZero<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<&NonZero<Scalar<E>>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&NonZero<Scalar<E>>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&NonZero<Scalar<E>>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&NonZero<Scalar<E>>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&NonZero<Scalar<E>>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&NonZero<SecretScalar<E>>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&NonZero<SecretScalar<E>>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &NonZero<SecretScalar<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 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<&Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&SecretScalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<&SecretScalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<NonZero<Point<E>>> for &NonZero<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<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<Scalar<E>>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<NonZero<Scalar<E>>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<NonZero<Scalar<E>>> for &SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<NonZero<Scalar<E>>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<NonZero<Scalar<E>>> for SecretScalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<NonZero<SecretScalar<E>>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<NonZero<SecretScalar<E>>> for &Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<NonZero<SecretScalar<E>>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<NonZero<SecretScalar<E>>> for Scalar<E>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

fn sub(self, rhs: NonZero<SecretScalar<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 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<Scalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<Scalar<E>> for &NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<Scalar<E>> for NonZero<SecretScalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<SecretScalar<E>> for &NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub<SecretScalar<E>> for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E: Curve> Sub for NonZero<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 for NonZero<Scalar<E>>

type Output = Scalar<E>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Scalar<E>

The resulting type after applying the - operator.

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

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<&NonZero<Scalar<E>>> for Scalar<E>

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

Performs the -= operation.

impl<E: Curve> SubAssign<&NonZero<SecretScalar<E>>> for Scalar<E>

fn sub_assign(&mut self, rhs: &NonZero<SecretScalar<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<NonZero<Scalar<E>>> for Scalar<E>

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

Performs the -= operation.

impl<E: Curve> SubAssign<NonZero<SecretScalar<E>>> for Scalar<E>

fn sub_assign(&mut self, rhs: NonZero<SecretScalar<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<'s, E: Curve> Sum<&'s NonZero<Scalar<E>>> for Scalar<E>

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

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

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

fn sum<I: Iterator<Item = &'s NonZero<SecretScalar<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<NonZero<Scalar<E>>> for Scalar<E>

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

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

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

fn sum<I: Iterator<Item = NonZero<SecretScalar<E>>>>(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> TryFrom<Scalar<E>> for NonZero<Scalar<E>>

type Error = ZeroScalar

The type returned in the event of a conversion error.

fn try_from(scalar: Scalar<E>) -> Result<Self, Self::Error>

Performs the conversion.

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

type Error = ZeroScalar

The type returned in the event of a conversion error.

fn try_from(secret_scalar: SecretScalar<E>) -> Result<Self, Self::Error>

Performs the conversion.

impl<T> Zeroize for NonZero<T>

where T: Zeroize,

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<T: Copy> Copy for NonZero<T>

impl<T: Eq> Eq for NonZero<T>

impl<T> StructuralPartialEq for NonZero<T>