Struct snarkvm_console_algorithms::Scalar

pub struct Scalar<E>where
    E: Environment,{ /* private fields */ }

Implementations

impl<E> Scalar<E>where E: Environment,

pub fn from_field_lossy(field: &Field<E>) -> Result<Scalar<E>, Error>

Casts a scalar from a base field, with lossy truncation.

This method is commonly-used by hash-to-scalar algorithms, where the hash output does not need to preserve the full base field.

impl<E> Scalar<E>where E: Environment,

pub const SIZE_IN_BITS: usize = <E::Scalar>::SIZE_IN_BITS

The scalar size in bits.

pub const SIZE_IN_BYTES: usize = (<E::Scalar>::SIZE_IN_BITS + 7) / 8

The scalar size in bytes.

pub const SIZE_IN_DATA_BITS: usize = <E::Scalar>::SIZE_IN_DATA_BITS

The scalar capacity for data bits.

pub const fn new(scalar: <E as Environment>::Scalar) -> Scalar<E>

Initializes a new scalar.

Trait Implementations

impl<E> Add<&Scalar<E>> for Scalar<E>where E: Environment,

fn add(self, other: &Scalar<E>) -> <Scalar<E> as Add<&Scalar<E>>>::Output

Returns the sum of self and other.

type Output = Scalar<E>

The resulting type after applying the + operator.

impl<E> Add<Scalar<E>> for Scalar<E>where E: Environment,

fn add(self, other: Scalar<E>) -> <Scalar<E> as Add<Scalar<E>>>::Output

Returns the sum of self and other.

type Output = Scalar<E>

The resulting type after applying the + operator.

impl<E> AddAssign<&Scalar<E>> for Scalar<E>where E: Environment,

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

Adds other to self.

impl<E> AddAssign<Scalar<E>> for Scalar<E>where E: Environment,

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

Adds other to self.

impl<E> Clone for Scalar<E>where E: Clone + Environment, <E as Environment>::Scalar: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<E> Compare<Scalar<E>> for Scalar<E>where E: Environment,

fn is_less_than( &self, other: &Scalar<E> ) -> <Scalar<E> as Compare<Scalar<E>>>::Output

Returns true if self is less than other.

fn is_greater_than( &self, other: &Scalar<E> ) -> <Scalar<E> as Compare<Scalar<E>>>::Output

Returns true if self is greater than other.

fn is_less_than_or_equal( &self, other: &Scalar<E> ) -> <Scalar<E> as Compare<Scalar<E>>>::Output

Returns true if self is less than or equal to other.

fn is_greater_than_or_equal( &self, other: &Scalar<E> ) -> <Scalar<E> as Compare<Scalar<E>>>::Output

Returns true if self is greater than or equal to other.

type Output = Boolean<E>

impl<E> Debug for Scalar<E>where E: Environment,

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

Formats the value using the given formatter.

impl<E> Deref for Scalar<E>where E: Environment,

type Target = <E as Environment>::Scalar

The resulting type after dereferencing.

fn deref(&self) -> &<Scalar<E> as Deref>::Target

Dereferences the value.

impl<'de, E> Deserialize<'de> for Scalar<E>where E: Environment,

fn deserialize<D>( deserializer: D ) -> Result<Scalar<E>, <D as Deserializer<'de>>::Error>where D: Deserializer<'de>,

Deserializes the scalar from a string or bytes.

impl<E> Display for Scalar<E>where E: Environment,

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

Formats the value using the given formatter.

impl<E> Distribution<Scalar<E>> for Standardwhere E: Environment,

fn sample<R>(&self, rng: &mut R) -> Scalar<E>where R: Rng + ?Sized,

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

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

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

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

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

impl<E> Div<&Scalar<E>> for Scalar<E>where E: Environment,

fn div(self, other: &Scalar<E>) -> <Scalar<E> as Div<&Scalar<E>>>::Output

Returns the quotient of self and other.

type Output = Scalar<E>

The resulting type after applying the / operator.

impl<E> Div<Scalar<E>> for Scalar<E>where E: Environment,

fn div(self, other: Scalar<E>) -> <Scalar<E> as Div<Scalar<E>>>::Output

Returns the quotient of self and other.

type Output = Scalar<E>

The resulting type after applying the / operator.

impl<E> DivAssign<&Scalar<E>> for Scalar<E>where E: Environment,

fn div_assign(&mut self, other: &Scalar<E>)

Divides self by other.

impl<E> DivAssign<Scalar<E>> for Scalar<E>where E: Environment,

fn div_assign(&mut self, other: Scalar<E>)

Divides self by other.

impl<E> Double for Scalar<E>where E: Environment,

fn double(&self) -> <Scalar<E> as Double>::Output

Returns the double of self.

type Output = Scalar<E>

impl<E> Equal<Scalar<E>> for Scalar<E>where E: Environment,

fn is_equal(&self, other: &Scalar<E>) -> <Scalar<E> as Equal<Scalar<E>>>::Output

Returns true if self and other are equal.

fn is_not_equal( &self, other: &Scalar<E> ) -> <Scalar<E> as Equal<Scalar<E>>>::Output

Returns true if self and other are not equal.

type Output = Boolean<E>

impl<E> FromBits for Scalar<E>where E: Environment,

fn from_bits_le(bits_le: &[bool]) -> Result<Scalar<E>, Error>

Initializes a new scalar from a list of little-endian bits.

• If bits_le is longer than E::Scalar::size_in_bits(), the excess bits are enforced to be 0s.
• If bits_le is shorter than E::Scalar::size_in_bits(), it is padded with 0s up to scalar size.

fn from_bits_be(bits_be: &[bool]) -> Result<Scalar<E>, Error>

Initializes a new scalar from a list of big-endian bits without leading zeros.

impl<E> FromBytes for Scalar<E>where E: Environment,

fn read_le<R>(reader: R) -> Result<Scalar<E>, Error>where R: Read,

Reads the scalar from a buffer.

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

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

impl<E> FromField for Scalar<E>where E: Environment,

fn from_field( field: &<Scalar<E> as FromField>::Field ) -> Result<Scalar<E>, Error>

Casts a scalar from a base field element.

This method guarantees the following:

1. If the field element is larger than the scalar field modulus, then the operation will fail.
2. If the field element is smaller than the scalar field modulus, then the operation will succeed. - This is particularly useful for the case where a user called, Scalar::from_field(scalar.to_field()), and the scalar bit representation is between size_in_data_bits < bits.len() < size_in_bits.

type Field = Field<E>

impl<E> FromStr for Scalar<E>where E: Environment,

fn from_str(string: &str) -> Result<Scalar<E>, Error>

Parses a string into a scalar.

type Err = Error

The associated error which can be returned from parsing.

impl<E> Hash for Scalar<E>where E: Hash + Environment, <E as Environment>::Scalar: Hash,

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

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> Inverse for Scalar<E>where E: Environment,

fn inverse(&self) -> Result<<Scalar<E> as Inverse>::Output, Error>

Returns the inverse of self.

type Output = Scalar<E>

impl<E> Mul<&Group<E>> for Scalar<E>where E: Environment,

fn mul(self, other: &Group<E>) -> <Scalar<E> as Mul<&Group<E>>>::Output

Returns the product of self and other.

type Output = Group<E>

The resulting type after applying the * operator.

impl<E> Mul<&Scalar<E>> for Group<E>where E: Environment,

fn mul(self, other: &Scalar<E>) -> <Group<E> as Mul<&Scalar<E>>>::Output

Returns the product of self and other.

type Output = Group<E>

The resulting type after applying the * operator.

impl<E> Mul<&Scalar<E>> for Scalar<E>where E: Environment,

fn mul(self, other: &Scalar<E>) -> <Scalar<E> as Mul<&Scalar<E>>>::Output

Returns the product of self and other.

type Output = Scalar<E>

The resulting type after applying the * operator.

impl<E> Mul<Group<E>> for Scalar<E>where E: Environment,

fn mul(self, other: Group<E>) -> <Scalar<E> as Mul<Group<E>>>::Output

Returns the product of self and other.

type Output = Group<E>

The resulting type after applying the * operator.

impl<E> Mul<Scalar<E>> for Group<E>where E: Environment,

fn mul(self, other: Scalar<E>) -> <Group<E> as Mul<Scalar<E>>>::Output

Returns the product of self and other.

type Output = Group<E>

The resulting type after applying the * operator.

impl<E> Mul<Scalar<E>> for Scalar<E>where E: Environment,

fn mul(self, other: Scalar<E>) -> <Scalar<E> as Mul<Scalar<E>>>::Output

Returns the product of self and other.

type Output = Scalar<E>

The resulting type after applying the * operator.

impl<E> MulAssign<&Scalar<E>> for Group<E>where E: Environment,

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

Multiplies self by other.

impl<E> MulAssign<&Scalar<E>> for Scalar<E>where E: Environment,

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

Multiplies self by other.

impl<E> MulAssign<Scalar<E>> for Group<E>where E: Environment,

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

Multiplies self by other.

impl<E> MulAssign<Scalar<E>> for Scalar<E>where E: Environment,

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

Multiplies self by other.

impl<E> Neg for Scalar<E>where E: Environment,

fn neg(self) -> <Scalar<E> as Neg>::Output

Returns the negation of self.

type Output = Scalar<E>

The resulting type after applying the - operator.

impl<E> One for Scalar<E>where E: Environment,

fn one() -> Scalar<E>

Returns the 1 element of the scalar.

fn is_one(&self) -> bool

Returns true if the element is one.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

impl<E> Ord for Scalar<E>where E: Environment,

fn cmp(&self, other: &Scalar<E>) -> Ordering

Returns the lexicographic ordering of self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl<E> Parser for Scalar<E>where E: Environment,

fn parse(string: &str) -> Result<(&str, Scalar<E>), Err<VerboseError<&str>>>

Parses a string into a scalar circuit.

impl<E> PartialEq<Scalar<E>> for Scalar<E>where E: PartialEq<E> + Environment, <E as Environment>::Scalar: PartialEq<<E as Environment>::Scalar>,

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

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

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

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

impl<E> PartialOrd<Scalar<E>> for Scalar<E>where E: Environment,

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

Returns the lexicographic ordering of self and other.

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl<E> Pow<&Scalar<E>> for Scalar<E>where E: Environment,

fn pow(self, other: &Scalar<E>) -> <Scalar<E> as Pow<&Scalar<E>>>::Output

Returns the power of self to the power of other.

type Output = Scalar<E>

The result after applying the operator.

impl<E> Pow<Scalar<E>> for Scalar<E>where E: Environment,

fn pow(self, other: Scalar<E>) -> <Scalar<E> as Pow<Scalar<E>>>::Output

Returns the power of self to the power of other.

type Output = Scalar<E>

The result after applying the operator.

impl<'a, E> Product<&'a Scalar<E>> for Scalar<E>where E: Environment,

fn product<I>(iter: I) -> Scalar<E>where I: Iterator<Item = &'a Scalar<E>>,

Returns the product of self and other.

impl<E> Product<Scalar<E>> for Scalar<E>where E: Environment,

fn product<I>(iter: I) -> Scalar<E>where I: Iterator<Item = Scalar<E>>,

Returns the product of self and other.

impl<E> Serialize for Scalar<E>where E: Environment,

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

Serializes the scalar into a string or as bytes.

impl<E> SizeInBits for Scalar<E>where E: Environment,

fn size_in_bits() -> usize

Returns the scalar size in bits.

impl<E> SizeInBytes for Scalar<E>where E: Environment,

fn size_in_bytes() -> usize

Returns the scalar size in bytes.

impl<E> SizeInDataBits for Scalar<E>where E: Environment,

fn size_in_data_bits() -> usize

Returns the scalar capacity for data bits.

impl<E> Square for Scalar<E>where E: Environment,

fn square(&self) -> <Scalar<E> as Square>::Output

Returns the square of self.

type Output = Scalar<E>

impl<E> Sub<&Scalar<E>> for Scalar<E>where E: Environment,

fn sub(self, other: &Scalar<E>) -> <Scalar<E> as Sub<&Scalar<E>>>::Output

Returns the difference of self and other.

type Output = Scalar<E>

The resulting type after applying the - operator.

impl<E> Sub<Scalar<E>> for Scalar<E>where E: Environment,

fn sub(self, other: Scalar<E>) -> <Scalar<E> as Sub<Scalar<E>>>::Output

Returns the difference of self and other.

type Output = Scalar<E>

The resulting type after applying the - operator.

impl<E> SubAssign<&Scalar<E>> for Scalar<E>where E: Environment,

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

Subtracts other from self.

impl<E> SubAssign<Scalar<E>> for Scalar<E>where E: Environment,

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

Subtracts other from self.

impl<'a, E> Sum<&'a Scalar<E>> for Scalar<E>where E: Environment,

fn sum<I>(iter: I) -> Scalar<E>where I: Iterator<Item = &'a Scalar<E>>,

Returns the sum of self and other.

impl<E> Sum<Scalar<E>> for Scalar<E>where E: Environment,

fn sum<I>(iter: I) -> Scalar<E>where I: Iterator<Item = Scalar<E>>,

Returns the sum of self and other.

impl<E> Ternary for Scalar<E>where E: Environment,

fn ternary( condition: &<Scalar<E> as Ternary>::Boolean, first: &Scalar<E>, second: &Scalar<E> ) -> <Scalar<E> as Ternary>::Output

Returns first if condition is true, otherwise returns second.

type Boolean = Boolean<E>

type Output = Scalar<E>

impl<E> ToBits for Scalar<E>where E: Environment,

fn to_bits_le(&self) -> Vec<bool, Global>

Outputs the little-endian bit representation of self without trailing zeros.

fn to_bits_be(&self) -> Vec<bool, Global>

Outputs the big-endian bit representation of self without leading zeros.

impl<E> ToBytes for Scalar<E>where E: Environment,

fn write_le<W>(&self, writer: W) -> Result<(), Error>where W: Write,

Writes the scalar to a buffer.

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

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

impl<E> ToField for Scalar<E>where E: Environment,

fn to_field(&self) -> Result<<Scalar<E> as ToField>::Field, Error>

Returns the scalar as a field element.

type Field = Field<E>

impl<E> TypeName for Scalar<E>where E: Environment,

fn type_name() -> &'static str

Returns the type name as a string.

impl<E> Zero for Scalar<E>where E: Environment,

fn zero() -> Scalar<E>

Returns the 0 element of the scalar.

fn is_zero(&self) -> bool

Returns true if the element is zero.

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

impl<E> Copy for Scalar<E>where E: Copy + Environment, <E as Environment>::Scalar: Copy,

impl<E> Eq for Scalar<E>where E: Eq + Environment, <E as Environment>::Scalar: Eq,

impl<E> GroupTrait<Scalar<E>> for Group<E>where E: Environment,

impl<E> ScalarTrait for Scalar<E>where E: Environment,

impl<E> StructuralEq for Scalar<E>where E: Environment,

impl<E> StructuralPartialEq for Scalar<E>where E: Environment,