Extend the benchmark app to gen/save random floats

Author: aldanor

extras/simple-bench/Cargo.toml

@@ -8,4 +8,6 @@ edition = "2018"
 fast-float = { path = "../.." }
 structopt = "0.3"
 anyhow = "1.0"
+lexical = "5.2"
 lexical-core = "0.7"
+fastrand = "1.4"

extras/simple-bench/src/main.rs

@@ -1,11 +1,13 @@
 mod random;
 
-use std::fs::read_to_string;
+use std::fs;
+use std::iter;
 use std::path::PathBuf;
 use std::str::FromStr;
 use std::time::Instant;
 
-use lexical_core::FromLexical;
+use fastrand::Rng;
+use lexical::FromLexical;
 use structopt::StructOpt;
 
 use fast_float::Float;
@@ -49,12 +51,12 @@ enum Cmd {
         /// Number of random floats generated
         #[structopt(short, default_value = "100000")]
         number: usize,
-        /// Consise random float strings (if not, 17 digits are used)
-        #[structopt(short)]
-        concise: bool,
         /// Random generator seed
-        #[structopt(short)]
+        #[structopt(short, default_value = "0")]
         seed: u64,
+        /// Also save the generated inputs to file
+        #[structopt(short = "f", parse(from_os_str))]
+        filename: Option<PathBuf>,
     },
 }
 
@@ -163,16 +165,28 @@ fn main() {
     let opt: Opt = StructOpt::from_args();
     let (inputs, inputs_name) = match opt.command {
         Cmd::File { filename } => (
-            read_to_string(&filename)
+            fs::read_to_string(&filename)
                 .unwrap()
                 .trim()
                 .lines()
                 .map(String::from)
                 .collect::<Vec<_>>(),
             filename.to_str().unwrap().to_owned(),
         ),
-        _ => {
-            unimplemented!()
+        Cmd::Random {
+            gen,
+            number,
+            seed,
+            filename,
+        } => {
+            let mut rng = Rng::with_seed(seed);
+            let inputs: Vec<String> = iter::repeat_with(|| gen.gen(&mut rng))
+                .take(number)
+                .collect();
+            if let Some(filename) = filename {
+                fs::write(filename, inputs.join("\n")).unwrap();
+            }
+            (inputs, format!("{}", gen))
         }
     };
     let repeat = opt.repeat.max(1);

extras/simple-bench/src/random.rs

@@ -1,6 +1,8 @@
+use std::fmt::{self, Display};
 use std::str::FromStr;
 
 use anyhow::{bail, Error, Result};
+use fastrand::Rng;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
 pub enum RandomGen {
@@ -14,6 +16,21 @@ pub enum RandomGen {
     BigInts,
 }
 
+impl Display for RandomGen {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            Self::Uniform => write!(f, "uniform"),
+            Self::OneOverRand32 => write!(f, "one_over_rand32"),
+            Self::SimpleUniform32 => write!(f, "simple_uniform32"),
+            Self::SimpleInt32 => write!(f, "simple_int32"),
+            Self::IntEInt => write!(f, "int_e_int"),
+            Self::SimpleInt64 => write!(f, "simple_int64"),
+            Self::BigIntDotInt => write!(f, "bigint_int_dot_int"),
+            Self::BigInts => write!(f, "big_ints"),
+        }
+    }
+}
+
 impl FromStr for RandomGen {
     type Err = Error;
 
@@ -45,4 +62,24 @@ impl RandomGen {
             "big_ints",
         ]
     }
+
+    pub fn gen(&self, rng: &mut Rng) -> String {
+        match self {
+            Self::Uniform
+            | Self::OneOverRand32
+            | Self::SimpleUniform32
+            | Self::SimpleInt32
+            | Self::SimpleInt64 => lexical::to_string(match self {
+                Self::Uniform => rng.f64(),
+                Self::OneOverRand32 => 1. / rng.u32(1..) as f64,
+                Self::SimpleUniform32 => rng.u32(..) as f64 / u32::MAX as f64,
+                Self::SimpleInt32 => rng.u32(..) as f64,
+                Self::SimpleInt64 => rng.u64(..) as f64,
+                _ => unreachable!(),
+            }),
+            Self::IntEInt => format!("{}e{}", rng.u32(..), rng.u32(..99)),
+            Self::BigInts => format!("{}{}{}", rng.u64(..), rng.u64(..), rng.u64(..)),
+            Self::BigIntDotInt => format!("{}.{}", rng.u32(..), rng.u32(..)),
+        }
+    }
 }