Struct group::WnafBase

pub struct WnafBase<G: Group, const WINDOW_SIZE: usize> { /* private fields */ }

A fixed window table for a group element, precomputed to improve the speed of scalar multiplication.

This struct is designed for usage patterns that have long-term cached bases and/or scalars, or Cartesian products of bases and scalars. The Wnaf API enables one or the other to be cached, but requires either the base window tables or the scalar w-NAF forms to be computed repeatedly on the fly, which can become a significant performance issue for some use cases.

WnafBase and WnafScalar enable an alternative trade-off: by fixing the window size at compile time, the precomputations are guaranteed to only occur once per base and once per scalar. Users should select their window size based on how long the bases are expected to live; a larger window size will consume more memory and take longer to precompute, but result in faster scalar multiplications.

Examples

use group::{WnafBase, WnafScalar};

let wnaf_bases: Vec<_> = bases.into_iter().map(WnafBase::<_, 4>::new).collect();
let wnaf_scalars: Vec<_> = scalars.iter().map(WnafScalar::new).collect();
let results: Vec<_> = wnaf_bases
    .iter()
    .flat_map(|base| wnaf_scalars.iter().map(|scalar| base * scalar))
    .collect();

Note that this pattern requires specifying a fixed window size (unlike previous patterns that picked a suitable window size internally). This is necessary to ensure in the type system that the base and scalar Wnafs were computed with the same window size, allowing the result to be computed infallibly.

Implementations

impl<G: Group, const WINDOW_SIZE: usize> WnafBase<G, WINDOW_SIZE>

pub fn new(base: G) -> Self

Computes a window table for the given base with the specified WINDOW_SIZE.

Trait Implementations

impl<G: Clone + Group, const WINDOW_SIZE: usize> Clone for WnafBase<G, WINDOW_SIZE>

fn clone(&self) -> WnafBase<G, WINDOW_SIZE>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Debug + Group, const WINDOW_SIZE: usize> Debug for WnafBase<G, WINDOW_SIZE>

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

Formats the value using the given formatter.

impl<G: Group, const WINDOW_SIZE: usize> Mul<&WnafScalar<<G as Group>::Scalar, WINDOW_SIZE>> for &WnafBase<G, WINDOW_SIZE>

type Output = G

The resulting type after applying the * operator.

fn mul(self, rhs: &WnafScalar<G::Scalar, WINDOW_SIZE>) -> Self::Output

Performs the * operation.