/// A very collision-resistant hash function.  It is guaranteed to be perfectly
/// collision-resistant on the following [`Stage`]s:
/// - 16-bit machines: Up to 6 bells
/// - 32-bit machines: Up to 9 bells
/// - 64-bit machines: Up to 16 bells
///
/// This hashing algorithm works by reading the row as a number using the stage as a base, thus
/// guaranteeing that (ignoring overflow), two [`Row`]s will only be hashed to the same value
/// if they are in fact the same.  This is ludicrously inefficient in terms of hash density,
/// but it is fast and perfect and in most cases will suffice.
A very collision-resistant hash function.  It is guaranteed to be perfectly
collision-resistant on the following [`Stage`]s:
16-bit machines: Up to 6 bells
32-bit machines: Up to 9 bells
64-bit machines: Up to 16 bells

This hashing algorithm works by reading the row as a number using the stage as a base, thus
guaranteeing that (ignoring overflow), two [`Row`]s will only be hashed to the same value
if they are in fact the same.  This is ludicrously inefficient in terms of hash density,
but it is fast and perfect and in most cases will suffice.
A very collision - resistant hash function . It is guaranteed to be perfectly collision - resistant on the following [ ` Stage ` ] s : 16 - bit machines : Up to 6 bells 32 - bit machines : Up to 9 bells 64 - bit machines : Up to 16 bells This hashing algorithm works by reading the row as a number using the stage as a base thus guaranteeing that ( ignoring overflow ) two [ ` Row ` ] s will only be hashed to the same value if they are in fact the same . This is ludicrously inefficient in terms of hash density but it is fast and perfect and in most cases will suffice .
pub fn fast_hash(&self) -> usize {
        let mut accum = 0;
        let mut multiplier = 1;
        for b in self.bell_iter() {
            accum += b.index() * multiplier;
            multiplier *= self.stage().num_bells();
        }
        accum
    }
pub fn fast_hash ( & self ) -> usize { let mut accum = 0 ; let mut multiplier = 1 ; for b in self . bell_iter ( ) { accum += b . index ( ) * multiplier ; multiplier *= self . stage ( ) . num_bells ( ) ; } accum }
A very collision-resistant hash function.
A very collision - resistant hash function .
&self