Struct Synthetic 

pub struct Synthetic<F, G> { /* private fields */ }

A linear combination of free generators and concrete points.

Free terms are indexed by u32 and bound later via Self::eval. Concrete terms carry their point directly.

Implementations

impl<F, G> Synthetic<F, G>

pub fn concrete(weighted_points: impl IntoIterator<Item = (F, G)>) -> Self

Construct from known weighted points.

pub fn max_free_index(&self) -> Option<u32>

The maximum free generator index, or None if there are no free terms.

pub fn generators() -> impl Iterator<Item = Self>

where F: Ring,

Yield symbolic generators G_0, G_1, G_2, ... with unit weight.

pub fn generators_array<const N: usize>() -> [Self; N]

where F: Ring,

Return [G_0, G_1, ..., G_{N-1}] as symbolic generators with unit weight.

impl<F: Additive, G: Space<F>> Synthetic<F, G>

pub fn eval(self, generators: &[G], strategy: &impl Strategy) -> G

Evaluate, substituting concrete generators for the free indices.

generators[i] provides the point for free index i.

Panics

Panics if generators does not contain an entry for every free index.

Trait Implementations

impl<'a, F: Additive, G: Space<F>> Add<&'a Synthetic<F, G>> for Synthetic<F, G>

type Output = Synthetic<F, G>

The resulting type after applying the + operator.

fn add(self, rhs: &'a Self) -> Self::Output

Performs the + operation.

impl<'a, F: Additive, G: Space<F>> AddAssign<&'a Synthetic<F, G>> for Synthetic<F, G>

fn add_assign(&mut self, rhs: &'a Self)

Performs the += operation.

impl<F: Additive, G: Space<F>> Additive for Synthetic<F, G>

fn zero() -> Self

The neutral element for addition.

fn double(&mut self)

Add an element to itself.

fn scale(&self, bits_le: &[u64]) -> Self

Scale this number by a positive integer.

impl<F: Clone, G: Clone> Clone for Synthetic<F, G>

fn clone(&self) -> Synthetic<F, G>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug, G: Debug> Debug for Synthetic<F, G>

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

Formats the value using the given formatter.

impl<F, G> Default for Synthetic<F, G>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, F: Space<F>, G: Space<F>> Mul<&'a F> for Synthetic<F, G>

type Output = Synthetic<F, G>

The resulting type after applying the * operator.

fn mul(self, rhs: &'a F) -> Self::Output

Performs the * operation.

impl<'a, F: Space<F>, G: Space<F>> MulAssign<&'a F> for Synthetic<F, G>

fn mul_assign(&mut self, rhs: &'a F)

Performs the *= operation.

impl<F: Additive, G: Space<F>> Neg for Synthetic<F, G>

type Output = Synthetic<F, G>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F: Additive, G: Space<F>> PartialEq for Synthetic<F, G>

fn eq(&self, other: &Self) -> 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<F: Space<F>, G: Space<F>> Space<F> for Synthetic<F, G>

fn msm(points: &[Self], scalars: &[R], _strategy: &impl ParStrategy) -> Self

Calculate sum_i points[i] * scalars[i].

impl<'a, F: Additive, G: Space<F>> Sub<&'a Synthetic<F, G>> for Synthetic<F, G>

type Output = Synthetic<F, G>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Self) -> Self::Output

Performs the - operation.

impl<'a, F: Additive, G: Space<F>> SubAssign<&'a Synthetic<F, G>> for Synthetic<F, G>

fn sub_assign(&mut self, rhs: &'a Self)

Performs the -= operation.

impl<F: Additive, G: Space<F>> Eq for Synthetic<F, G>

impl<F: Additive, G: Space<F>> Object for Synthetic<F, G>