pub fn new(gens_capacity: usize, party_capacity: usize) -> Self {
        let mut gens = BulletproofGens {
            gens_capacity,
            party_capacity,
            G_vec: Vec::new(),
            H_vec: Vec::new(),
        };

        let max_index = party_capacity * gens_capacity;
        for i in 0..max_index {
            if i % gens_capacity == 0 {
                gens.G_vec.push(Vec::new());
                gens.H_vec.push(Vec::new());
            }

            let G_i = Self::generator(*H, (i * 2) + 1);
            let H_i = Self::generator(*H, i * 2);

            let last_index = gens.G_vec.len() - 1;
            gens.H_vec[last_index].push(H_i);
            gens.G_vec[last_index].push(G_i);
        }

        gens
    }
/// Create a new `BulletproofGens` object.
///
/// # Inputs
///
/// * `gens_capacity` is the number of generators to precompute
///    for each party.  For rangeproofs, it is sufficient to pass
///    `64`, the maximum bitsize of the rangeproofs.
///
/// * `party_capacity` is the maximum number of parties that can
///    produce an aggregated proof.
Create a new `BulletproofGens` object.
Create a new ` BulletproofGens ` object .
pub fn new(gens_capacity: usize, party_capacity: usize) -> Self {
        let mut gens = BulletproofGens {
            gens_capacity,
            party_capacity,
            G_vec: Vec::new(),
            H_vec: Vec::new(),
        };
        let max_index = party_capacity * gens_capacity;
        for i in 0..max_index {
            if i % gens_capacity == 0 {
                gens.G_vec.push(Vec::new());
                gens.H_vec.push(Vec::new());
            }
            let G_i = Self::generator(*H, (i * 2) + 1);
            let H_i = Self::generator(*H, i * 2);
            let last_index = gens.G_vec.len() - 1;
            gens.H_vec[last_index].push(H_i);
            gens.G_vec[last_index].push(G_i);
        }
        gens
    }
pub fn new ( gens_capacity : usize , party_capacity : usize ) -> Self { let mut gens = BulletproofGens { gens_capacity , party_capacity , G_vec : Vec :: new ( ) , H_vec : Vec :: new ( ) , } ; let max_index = party_capacity * gens_capacity ; for i in 0 .. max_index { if i % gens_capacity == 0 { gens . G_vec . push ( Vec :: new ( ) ) ; gens . H_vec . push ( Vec :: new ( ) ) ; } let G_i = Self :: generator ( * H , ( i * 2 ) + 1 ) ; let H_i = Self :: generator ( * H , i * 2 ) ; let last_index = gens . G_vec . len ( ) - 1 ; gens . H_vec [ last_index ] . push ( H_i ) ; gens . G_vec [ last_index ] . push ( G_i ) ; } gens }
Create a new `BulletproofGens` object.
Create a new ` BulletproofGens ` object .
gens_capacity
usize
party_capacity
usize
gens_capacity
usize
party_capacity
usize
inputs
`gens_capacity` is the number of generators to precompute
for each party.  For rangeproofs, it is sufficient to pass
`64`, the maximum bitsize of the rangeproofs.

`party_capacity` is the maximum number of parties that can
produce an aggregated proof.
` gens_capacity ` is the number of generators to precompute for each party . For rangeproofs it is sufficient to pass ` 64 ` the maximum bitsize of the rangeproofs . ` party_capacity ` is the maximum number of parties that can produce an aggregated proof .