len -> distinct_values, count -> len

This is a better match for what "len" normally means. For example,
`HashMap::len` doesn't return the number of buckets, but the number of
*values*. It also matches better the intuition that `len` and `is_empty`
are related (whereas `count` and `is_empty` being related is less
obvious).

Author: jonhoo

benches/serialization.rs

@@ -171,7 +171,7 @@ fn do_serialize_bench<S>(
     S: TestOnlyHypotheticalSerializerInterface,
 {
     let mut h = Histogram::<u64>::new_with_bounds(low, high, digits).unwrap();
-    let random_counts = (fraction_of_counts_len * h.len() as f64) as usize;
+    let random_counts = (fraction_of_counts_len * h.distinct_values() as f64) as usize;
     let mut vec = Vec::with_capacity(random_counts);
 
     let range = Range::new(low, high);
@@ -199,7 +199,7 @@ fn do_deserialize_bench<S>(
     S: TestOnlyHypotheticalSerializerInterface,
 {
     let mut h = Histogram::<u64>::new_with_bounds(low, high, digits).unwrap();
-    let random_counts = (fraction_of_counts_len * h.len() as f64) as usize;
+    let random_counts = (fraction_of_counts_len * h.distinct_values() as f64) as usize;
     let mut vec = Vec::with_capacity(random_counts);
 
     let range = Range::new(low, high);

examples/cli.rs

@@ -212,13 +212,13 @@ fn quantiles<R: BufRead, W: Write>(
         "StdDeviation",
         hist.stdev(),
     )?;
-    write_extra_data(&mut writer, "Max", hist.max(), "Total count", hist.count())?;
+    write_extra_data(&mut writer, "Max", hist.max(), "Total count", hist.len())?;
     write_extra_data(
         &mut writer,
         "Buckets",
         hist.buckets(),
         "SubBuckets",
-        hist.len(),
+        hist.distinct_values(),
     )?;
 
     Ok(())

src/iterators/mod.rs

@@ -180,7 +180,7 @@ where
         // unless we have ended.
         while !self.ended {
             // have we reached the end?
-            if self.current_index == self.hist.len() {
+            if self.current_index == self.hist.distinct_values() {
                 self.ended = true;
                 return None;
             }
@@ -194,7 +194,7 @@ where
                 }
             } else {
                 // nope -- alright, let's keep iterating
-                assert!(self.current_index < self.hist.len());
+                assert!(self.current_index < self.hist.distinct_values());
 
                 if self.fresh {
                     // at a new index, and not past the max, so there's nonzero counts to add
@@ -218,7 +218,7 @@ where
                 self.total_count_to_index,
                 self.count_at_index,
             ) {
-                let quantile = self.total_count_to_index as f64 / self.hist.count() as f64;
+                let quantile = self.total_count_to_index as f64 / self.hist.len() as f64;
                 let val = IterationValue {
                     value_iterated_to: metadata.value_iterated_to.unwrap_or_else(|| {
                         self.hist

src/iterators/quantile.rs

@@ -42,7 +42,7 @@ impl<'a, T: 'a + Counter> PickyIterator<T> for Iter<'a, T> {
 
         // This calculation, combined with the `quantile * count` in `value_at_quantile`, tends
         // to produce a count_at_quantile that is 1 ulp wrong. That's just the way IEEE754 works.
-        let current_quantile = running_total as f64 / self.hist.count() as f64;
+        let current_quantile = running_total as f64 / self.hist.len() as f64;
         if current_quantile < self.quantile_to_iterate_to {
             return None;
         }

src/lib.rs

@@ -284,7 +284,7 @@ impl<T: Counter> Histogram<T> {
     // ********************************************************************************************
 
     /// Get the current number of distinct values that can be represented in the histogram.
-    pub fn len(&self) -> usize {
+    pub fn distinct_values(&self) -> usize {
         self.counts.len()
     }
 
@@ -304,10 +304,16 @@ impl<T: Counter> Histogram<T> {
     }
 
     /// Get the total number of samples recorded.
+    #[deprecated(since = "6.0.0", note = "use `len` instead")]
     pub fn count(&self) -> u64 {
         self.total_count
     }
 
+    /// Get the total number of samples recorded.
+    pub fn len(&self) -> u64 {
+        self.total_count
+    }
+
     /// Returns true if this histogram has no recorded values.
     pub fn is_empty(&self) -> bool {
         self.total_count == 0
@@ -372,7 +378,9 @@ impl<T: Counter> Histogram<T> {
 
     /// Get the index of the last histogram bin.
     fn last_index(&self) -> usize {
-        self.len().checked_sub(1).expect("Empty counts array?")
+        self.distinct_values()
+            .checked_sub(1)
+            .expect("Empty counts array?")
     }
 
     // ********************************************************************************************
@@ -452,7 +460,7 @@ impl<T: Counter> Histogram<T> {
             // Counts arrays are of the same length and meaning,
             // so we can just iterate and add directly:
             let mut observed_other_total_count: u64 = 0;
-            for i in 0..source.len() {
+            for i in 0..source.distinct_values() {
                 let other_count = source
                     .count_at_index(i)
                     .expect("iterating inside source length");
@@ -562,7 +570,7 @@ impl<T: Counter> Histogram<T> {
         // If total_count is at the max value, it may have saturated, so we must restat
         let mut needs_restat = self.total_count == u64::max_value();
 
-        for i in 0..subtrahend.len() {
+        for i in 0..subtrahend.distinct_values() {
             let other_count = subtrahend
                 .count_at_index(i)
                 .expect("index inside subtrahend len must exist");
@@ -599,7 +607,7 @@ impl<T: Counter> Histogram<T> {
         }
 
         if needs_restat {
-            let l = self.len();
+            let l = self.distinct_values();
             self.restat(l);
         }
 
@@ -785,7 +793,7 @@ impl<T: Counter> Histogram<T> {
         // h.start_time = source.start_time;
         // h.end_time = source.end_time;
         h.auto_resize = source.auto_resize;
-        h.counts.resize(source.len(), T::zero());
+        h.counts.resize(source.distinct_values(), T::zero());
         h
     }
 

src/tests/subtract.rs

@@ -11,7 +11,7 @@ fn assert_min_max_count<T: Counter, B: Borrow<Histogram<T>>>(hist: B) {
     let mut min = None;
     let mut max = None;
     let mut total = 0;
-    for i in 0..h.len() {
+    for i in 0..h.distinct_values() {
         let value = h.value_for(i);
         let count = h.count_at(value);
         if count == T::zero() {
@@ -28,7 +28,7 @@ fn assert_min_max_count<T: Counter, B: Borrow<Histogram<T>>>(hist: B) {
 
     assert_eq!(min, h.min());
     assert_eq!(max, h.max());
-    assert_eq!(total, h.count());
+    assert_eq!(total, h.len());
 }
 
 #[test]
@@ -44,17 +44,17 @@ fn subtract_after_add() {
     h1.add(&h2).unwrap();
     assert_eq!(h1.count_at(TEST_VALUE_LEVEL), 2);
     assert_eq!(h1.count_at(1000 * TEST_VALUE_LEVEL), 2);
-    assert_eq!(h1.count(), 4);
+    assert_eq!(h1.len(), 4);
 
     h1 += &h2;
     assert_eq!(h1.count_at(TEST_VALUE_LEVEL), 3);
     assert_eq!(h1.count_at(1000 * TEST_VALUE_LEVEL), 3);
-    assert_eq!(h1.count(), 6);
+    assert_eq!(h1.len(), 6);
 
     h1.subtract(&h2).unwrap();
     assert_eq!(h1.count_at(TEST_VALUE_LEVEL), 2);
     assert_eq!(h1.count_at(1000 * TEST_VALUE_LEVEL), 2);
-    assert_eq!(h1.count(), 4);
+    assert_eq!(h1.len(), 4);
 
     assert_min_max_count(h1);
     assert_min_max_count(h2);
@@ -69,13 +69,13 @@ fn subtract_to_zero_counts() {
 
     assert_eq!(h1.count_at(TEST_VALUE_LEVEL), 1);
     assert_eq!(h1.count_at(1000 * TEST_VALUE_LEVEL), 1);
-    assert_eq!(h1.count(), 2);
+    assert_eq!(h1.len(), 2);
 
     let clone = h1.clone();
     h1.subtract(&clone).unwrap();
     assert_eq!(h1.count_at(TEST_VALUE_LEVEL), 0);
     assert_eq!(h1.count_at(1000 * TEST_VALUE_LEVEL), 0);
-    assert_eq!(h1.count(), 0);
+    assert_eq!(h1.len(), 0);
 
     assert_min_max_count(h1);
 }
@@ -141,14 +141,14 @@ fn subtract_values_inside_minuend_range_works() {
     assert_eq!(big.count_at(TEST_VALUE_LEVEL), 3);
     assert_eq!(big.count_at(1000 * TEST_VALUE_LEVEL), 3);
     assert_eq!(big.count_at(2 * max), 3); // overflow smaller hist...
-    assert_eq!(big.count(), 9);
+    assert_eq!(big.len(), 9);
 
     // Subtracting the smaller histogram from the bigger one should work:
     big -= &h1;
     assert_eq!(big.count_at(TEST_VALUE_LEVEL), 2);
     assert_eq!(big.count_at(1000 * TEST_VALUE_LEVEL), 2);
     assert_eq!(big.count_at(2 * max), 3); // overflow smaller hist...
-    assert_eq!(big.count(), 7);
+    assert_eq!(big.len(), 7);
 
     assert_min_max_count(h1);
     assert_min_max_count(big);
@@ -172,7 +172,7 @@ fn subtract_values_strictly_inside_minuend_range_yields_same_min_max_no_restat()
 
     assert_eq!(1, h1.min());
     assert_eq!(1000, h1.max());
-    assert_eq!(2, h1.count());
+    assert_eq!(2, h1.len());
 
     assert_min_max_count(h1);
     assert_min_max_count(h2);
@@ -340,7 +340,7 @@ fn subtract_values_minuend_saturated_total_recalculates_saturated() {
     assert_eq!(1, h1.min());
     assert_eq!(1000, h1.max());
     // still saturated
-    assert_eq!(u64::max_value(), h1.count());
+    assert_eq!(u64::max_value(), h1.len());
 
     assert_min_max_count(h1);
     assert_min_max_count(h2);
@@ -368,7 +368,7 @@ fn subtract_values_minuend_saturated_total_recalculates_not_saturated() {
     assert_eq!(1, h1.min());
     assert_eq!(1000, h1.max());
     // not saturated
-    assert_eq!(u64::max_value() / 16 * 15, h1.count());
+    assert_eq!(u64::max_value() / 16 * 15, h1.len());
 
     assert_min_max_count(h1);
     assert_min_max_count(h2);

tests/auto_resize.rs

@@ -9,15 +9,15 @@ fn histogram_autosizing_edges() {
     let mut histogram = Histogram::<u64>::new(3).unwrap();
     histogram += (1_u64 << 62) - 1;
     assert_eq!(histogram.buckets(), 52);
-    assert_eq!(histogram.len(), 54272);
+    assert_eq!(histogram.distinct_values(), 54272);
     histogram += u64::max_value();
     assert_eq!(histogram.buckets(), 54);
     // unit magnitude = floor(log_2 (1 / 2)) = 0
     // sub bucket count magnitude = floor(log_2 (2 * 10^3)) = 10
     // sub bucket half count mag = 9
     // sub bucket count = 2^(sbhcm + 1) = 2^9 = 1024
     // total array size = (54 + 1) * (sub bucket count / 2) = 56320
-    assert_eq!(histogram.len(), 56320);
+    assert_eq!(histogram.distinct_values(), 56320);
 }
 
 #[test]
@@ -27,7 +27,7 @@ fn histogram_autosizing() {
         histogram += 1_u64 << i;
     }
     assert_eq!(histogram.buckets(), 53);
-    assert_eq!(histogram.len(), 55296);
+    assert_eq!(histogram.distinct_values(), 55296);
 }
 
 #[test]

tests/data_access.rs

@@ -87,7 +87,7 @@ fn scaling_equivalence() {
     } = load_histograms();
 
     assert_near!(hist.mean() * SCALEF as f64, scaled_hist.mean(), 0.000001);
-    assert_eq!(hist.count(), scaled_hist.count());
+    assert_eq!(hist.len(), scaled_hist.len());
 
     let expected_99th = hist.value_at_quantile(0.99) * 512;
     let scaled_99th = scaled_hist.value_at_quantile(0.99);
@@ -100,7 +100,7 @@ fn scaling_equivalence() {
     // averages should be equivalent
     assert_near!(hist.mean() * SCALEF as f64, scaled_hist.mean(), 0.000001);
     // total count should be the same
-    assert_eq!(hist.count(), scaled_hist.count());
+    assert_eq!(hist.len(), scaled_hist.len());
     // 99%'iles should be equivalent
     assert_eq!(
         scaled_hist.highest_equivalent(hist.value_at_quantile(0.99) * 512),
@@ -117,7 +117,7 @@ fn scaling_equivalence() {
     // averages should be equivalent
     assert_near!(post.mean() * SCALEF as f64, scaled_post.mean(), 0.000001);
     // total count should be the same
-    assert_eq!(post.count(), scaled_post.count());
+    assert_eq!(post.len(), scaled_post.len());
     // 99%'iles should be equivalent
     assert_eq!(
         post.lowest_equivalent(post.value_at_quantile(0.99)) * SCALEF,
@@ -134,8 +134,8 @@ fn scaling_equivalence() {
 fn total_count() {
     let Loaded { hist, raw, .. } = load_histograms();
 
-    assert_eq!(raw.count(), 10001);
-    assert_eq!(hist.count(), 20000);
+    assert_eq!(raw.len(), 10001);
+    assert_eq!(hist.len(), 20000);
 }
 
 #[test]
@@ -488,7 +488,7 @@ fn iter_all() {
         // TODO: also test total count and total value once the iterator exposes this
         num += 1;
     }
-    assert_eq!(num, hist.len());
+    assert_eq!(num, hist.distinct_values());
 
     num = 0;
     let mut total_added_counts = 0;
@@ -505,7 +505,7 @@ fn iter_all() {
         total_added_counts += v.count_since_last_iteration();
         num += 1;
     }
-    assert_eq!(num, hist.len());
+    assert_eq!(num, hist.distinct_values());
     assert_eq!(total_added_counts, 20000);
 }
 
@@ -528,16 +528,16 @@ fn value_duplication() {
     let histogram1 = hist.clone();
 
     let mut num = 0;
-    let mut ranges = Vec::with_capacity(histogram1.len());
-    let mut counts = Vec::with_capacity(histogram1.len());
+    let mut ranges = Vec::with_capacity(histogram1.distinct_values());
+    let mut counts = Vec::with_capacity(histogram1.distinct_values());
     for v in histogram1.iter_all() {
         if v.count_since_last_iteration() > 0 {
             ranges.push(v.value_iterated_to());
             counts.push(v.count_since_last_iteration());
         }
         num += 1;
     }
-    assert_eq!(num, histogram1.len());
+    assert_eq!(num, histogram1.distinct_values());
 
     let mut histogram2 = Histogram::new_with_max(TRACKABLE_MAX, SIGFIG).unwrap();
     for i in 0..ranges.len() {
@@ -564,5 +564,5 @@ fn total_count_exceeds_bucket_type() {
         h.record(100_000).unwrap();
     }
 
-    assert_eq!(400, h.count());
+    assert_eq!(400, h.len());
 }