Bin Numbers from stdin

Question

I often like to get a feel for a text file containing a lot of numbers quickly by making a histogram. One can do this in plotting software like Gnuplot, but sometimes having something in the terminal is nice (or can even make plotting later easier).

To this end, I wrote a program that reads numbers from stdin and sorts them into bins of equal width. The output of the program is the bin centers and counts in each bin.

I am new to Rust. I found the clap library for parsing command line arguments, and I tried to use some language features for manipulating vectors.

I suspect the algorithm can be improved. Because the code outputs the bins sorted by bin center, I store the bin edges in a vector as they are created. However, to avoid comparing floats when checking if a bin is already present, I have another parallel vector with bin ID numbers that I compare instead.

// binner
// Command-line tool for reading in a list of numbers and writing 
// bins and counts for a specified bin width 
//
// bins are defined [lower, upper), such that each output point
// has the form:
// (x,y) = ((lower + upper) / 2, counts)
// and lower - upper = specified binwidth
#[macro_use]
extern crate clap;
use std::io::{self, BufRead};
use std::cmp::Ordering;
use clap::{Arg, App}; // for parsing command-line arguments
fn bins(values: &Vec<f64>, binwidth: f64, binstart: f64) -> Vec<(f64, u32)> {
 // Input: a vector of floats and a bin width 
 // Output: a vector of bin edges and counts for each bin
 // unique integer identifier for each bin, to be used to check if bin is present
 // the actual bin edges will be computed as floats, so this avoids 
 // checking for strict float equality
 let mut bin_ids: Vec<i32> = Vec::new();
 // computed bin edge values and counts 
 let mut edges_counts: Vec<(f64, u32)> = Vec::new();
 for val in values {
 let bin_id = (val / binwidth).floor() as i32;
 // check if the bin is already in the vector
 match bin_ids.iter().position(|&b| b == bin_id) {
 // if it is, add to the corresponding counts
 Some(i) => { edges_counts[i].1 += 1 },
 // else, add a new bin
 _ => {
 bin_ids.push(bin_id);
 edges_counts.push(
 (binwidth * (((val - binstart) / 
 binwidth).floor() + 0.5) + binstart, 1)
 );
 },
 };
 }
 // sort result by edge, then return. Since floats may contain NaN,
 // we need to use partial_cmp since edges are floats,
 // and specify what to do for errors
 edges_counts.sort_by(|a, b| a.0.partial_cmp(&b.0).unwrap_or(Ordering::Equal));
 return edges_counts;
}
fn main() {
 // parse command line arguments and set up help with clap-rs
 let arg_matches = App::new("binner")
 .version("1.0")
 .about("Read numbers from standard input, output bins and counts")
 .arg(Arg::with_name("binwidth")
 .short("w")
 .value_name("WIDTH")
 .help("Set bin width")
 .takes_value(true)
 .default_value("1.0"))
 .arg(Arg::with_name("binstart")
 .short("s")
 .value_name("EDGE START")
 .help("Set bin edge start")
 .takes_value(true)
 .default_value("0.0"))
 .arg(Arg::with_name("INPUT")
 .help("Input stream")
 .index(1))
 .get_matches();
 // type-checking macro explaind in clap example 12_typed_values.rs
 let binwidth: f64 = value_t!(arg_matches, "binwidth", f64).unwrap_or(1.0);
 let binstart: f64 = value_t!(arg_matches, "binstart", f64).unwrap_or(0.0);
 // parse stdin to make a list of values 
 let stdin = io::stdin();
 let mut values: Vec<f64> = Vec::new();
 for line in stdin.lock().lines() {
 let elem: f64 = match line.unwrap().trim().parse() {
 Ok(num) => num,
 Err(_) => {
 eprintln!("Invalid value entered");
 continue;
 },
 };
 values.push(elem);
 }
 // compute bins and print
 let result = bins(&values, binwidth, binstart); 
 for bin in &result {
 println!("{}\t{}", bin.0, bin.1);
 }
}
#[cfg(test)]
mod tests{
 use super::bins;
 #[test]
 fn sequence() {
 // bin 10 numbers. bin edges start at binwdith / 2 intervals
 let vals = vec![1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5];
 let out = vec![(1.5, 2), (2.5, 2), (3.5, 2), (4.5, 2), (5.5, 2)];
 assert_eq!(bins(&vals, 1.0, 1.0), out); 
 }
 #[test]
 fn unordered() {
 let vals = vec![1.0, 55.6, -15.2, 55.9];
 let out = vec![(-15.5, 1), (1.5, 1), (55.5, 2)];
 assert_eq!(bins(&vals, 1.0, 1.0), out); 
 }
}

A simple use-case might be

seq 0 1 1000 | binner -w 10

which bins integers from 0 to 1000 in bins of width 10.

Answer 1

negative

// and lower - upper = specified binwidth

Wait a minute! Strike that, reverse it. Thank you.

Also typo nit: "explaind"

helper

Please introduce a helper that maps from val to bin_id. I am skeptical that bin ids are compatible with edge counts currently, since binstart does not participate in computing a bin_id. This matters when binstart is not a multiple of binwidth.