Struct group::Wnaf

pub struct Wnaf<W, B, S> { /* private fields */ }

A “w-ary non-adjacent form” scalar multiplication (also known as exponentiation) context.

Examples

This struct can be used to implement several patterns:

One base, one scalar

For this pattern, you can use a transient Wnaf context:

use group::Wnaf;

let result = Wnaf::new().scalar(&scalar).base(base);

Many bases, one scalar

For this pattern, you create a Wnaf context, load the scalar into it, and then process each base in turn:

use group::Wnaf;

let mut wnaf = Wnaf::new();
let mut wnaf_scalar = wnaf.scalar(&scalar);
let results: Vec<_> = bases
    .into_iter()
    .map(|base| wnaf_scalar.base(base))
    .collect();

One base, many scalars

For this pattern, you create a Wnaf context, load the base into it, and then process each scalar in turn:

use group::Wnaf;

let mut wnaf = Wnaf::new();
let mut wnaf_base = wnaf.base(base, scalars.len());
let results: Vec<_> = scalars
    .iter()
    .map(|scalar| wnaf_base.scalar(scalar))
    .collect();

Many bases, many scalars

Say you have n bases and m scalars, and want to produce n * m results. For this pattern, you need to cache the w-NAF tables for the bases and then compute the w-NAF form of the scalars on the fly for every base, or vice versa:

use group::Wnaf;

let mut wnaf_contexts: Vec<_> = (0..bases.len()).map(|_| Wnaf::new()).collect();
let mut wnaf_bases: Vec<_> = wnaf_contexts
    .iter_mut()
    .zip(bases)
    .map(|(wnaf, base)| wnaf.base(base, scalars.len()))
    .collect();
let results: Vec<_> = wnaf_bases
    .iter()
    .flat_map(|wnaf_base| scalars.iter().map(|scalar| wnaf_base.scalar(scalar)))
    .collect();

Alternatively, use the WnafBase and WnafScalar types, which enable the various tables and w-NAF forms to be cached individually per base and scalar. These types can then be directly multiplied without any additional runtime work, at the cost of fixing a specific window size (rather than choosing the window size dynamically).

Implementations

impl<G: Group> Wnaf<(), Vec<G>, Vec<i64>>

pub fn new() -> Self

Construct a new wNAF context without allocating.

impl<G: WnafGroup> Wnaf<(), Vec<G>, Vec<i64>>

pub fn base( &mut self, base: G, num_scalars: usize, ) -> Wnaf<usize, &[G], &mut Vec<i64>>

Given a base and a number of scalars, compute a window table and return a Wnaf object that can perform exponentiations with .scalar(..).

pub fn scalar( &mut self, scalar: &<G as Group>::Scalar, ) -> Wnaf<usize, &mut Vec<G>, &[i64]>

Given a scalar, compute its wNAF representation and return a Wnaf object that can perform exponentiations with .base(..).

impl<'a, G: Group> Wnaf<usize, &'a [G], &'a mut Vec<i64>>

pub fn shared(&self) -> Wnaf<usize, &'a [G], Vec<i64>>

Constructs new space for the scalar representation while borrowing the computed window table, for sending the window table across threads.

impl<'a, G: Group> Wnaf<usize, &'a mut Vec<G>, &'a [i64]>

pub fn shared(&self) -> Wnaf<usize, Vec<G>, &'a [i64]>

Constructs new space for the window table while borrowing the computed scalar representation, for sending the scalar representation across threads.

impl<B, S: AsRef<[i64]>> Wnaf<usize, B, S>

pub fn base<G: Group>(&mut self, base: G) -> G

where B: AsMut<Vec<G>>,

Performs exponentiation given a base.

impl<B, S: AsMut<Vec<i64>>> Wnaf<usize, B, S>

pub fn scalar<G: Group>(&mut self, scalar: &<G as Group>::Scalar) -> G

where B: AsRef<[G]>,

Performs exponentiation given a scalar.

Trait Implementations

impl<W: Debug, B: Debug, S: Debug> Debug for Wnaf<W, B, S>

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

Formats the value using the given formatter.