pub fn fast_derive(&mut self, sys: &SysParam, rng: &mut impl RAND) {
        let mut epoch = Vec::new();
        if self.bte_nodes.is_empty() {
            return;
        }
        let now = self.current().expect("bte_nodes unexpectedly empty");
        for i in 0..sys.lambda_t {
            if i < now.tau.len() {
                epoch.push(now.tau[i]);
            } else {
                epoch.push(Bit::Zero);
            }
        }
        self.update_to(&epoch, sys, rng);
    }
/// The current key (the end of list of BTENodes) of a `SecretKey` should
/// always correspond to an epoch described by lambda_t bits. Some
/// internal operations break this invariant, leaving less than lambda_t
/// bits in the current key. This function should be called when this
/// happens; it modifies the list so the current key corresponds to the
/// first epoch of the subtree described by the current key.
///
/// For example, if lambda_t = 5, then [..., 011] will change to
/// [..., 0111, 01101, 01100].
/// The current key's `tau` now has 5 bits, and the other entries cover the
/// rest of the 011 subtree after we delete the current key.
///
/// Another example: during the very first epoch the private key is
/// [1, 01, 001, 0001, 00001, 00000].
///
/// This makes key update easy: pop off the current key, then call this
/// function.
///
/// An alternative is to only store the root nodes of the subtrees that
/// cover the remaining valid keys. Thus the first epoch, the private
/// key would simply be \[0\], and would only change to [1, 01, 001, 0001,
/// 00001] after the first update. Generally, some computations
/// happen one epoch later than they would with our current scheme. However,
/// key update is a bit fiddlier.
///
/// No-op if `self` is empty.
The current key (the end of list of BTENodes) of a `SecretKey` should
always correspond to an epoch described by lambda_t bits. Some
internal operations break this invariant, leaving less than lambda_t
bits in the current key. This function should be called when this
happens; it modifies the list so the current key corresponds to the
first epoch of the subtree described by the current key.





This makes key update easy: pop off the current key, then call this
function.

An alternative is to only store the root nodes of the subtrees that
cover the remaining valid keys. Thus the first epoch, the private
key would simply be \[0\], and would only change to [1, 01, 001, 0001,
00001] after the first update. Generally, some computations
happen one epoch later than they would with our current scheme. However,
key update is a bit fiddlier.

No-op if `self` is empty.
The current key ( the end of list of BTENodes ) of a ` SecretKey ` should always correspond to an epoch described by lambda_t bits . Some internal operations break this invariant leaving less than lambda_t bits in the current key . This function should be called when this happens ; it modifies the list so the current key corresponds to the first epoch of the subtree described by the current key . This makes key update easy : pop off the current key then call this function . An alternative is to only store the root nodes of the subtrees that cover the remaining valid keys . Thus the first epoch the private key would simply be \ [ 0 \ ] and would only change to [ 1 01 001 0001 00001 ] after the first update . Generally some computations happen one epoch later than they would with our current scheme . However key update is a bit fiddlier . No - op if ` self ` is empty .
pub fn fast_derive(&mut self, sys: &SysParam, rng: &mut impl RAND) {
        let mut epoch = Vec::new();
        if self.bte_nodes.is_empty() {
            return;
        }
        let now = self.current().expect("bte_nodes unexpectedly empty");
        for i in 0..sys.lambda_t {
            if i < now.tau.len() {
                epoch.push(now.tau[i]);
            } else {
                epoch.push(Bit::Zero);
            }
        }
        self.update_to(&epoch, sys, rng);
    }
pub fn fast_derive ( & mut self , sys : & SysParam , rng : & mut impl RAND ) { let mut epoch = Vec :: new ( ) ; if self . bte_nodes . is_empty ( ) { return ; } let now = self . current ( ) . expect ( " " ) ; for i in 0 .. sys . lambda_t { if i < now . tau . len ( ) { epoch . push ( now . tau [ i ] ) ; } else { epoch . push ( Bit :: Zero ) ; } } self . update_to ( & epoch , sys , rng ) ; }
The current key (the end of list of BTENodes) of a `SecretKey` should
always correspond to an epoch described by lambda_t bits.
The current key ( the end of list of BTENodes ) of a ` SecretKey ` should always correspond to an epoch described by lambda_t bits .
&mut self
sys
&SysParam
rng
&mut impl RAND
&mut self
sys
&SysParam
rng
&mut impl RAND