dozr 0.4.1

A flexible `sleep`-like command-line utility for pausing execution with fun timing features.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use clap::Parser;

use rand::rngs::ThreadRng;
use rand_distr::{Distribution, Normal, Exp, LogNormal, Pareto, Uniform, Triangular, Gamma};

use std::time::Duration;

#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
pub struct Cli {
    /// The type of distribution to sample from.
    #[arg(long)]
    pub distribution: String,

    /// Number of samples to generate.
    #[arg(long, default_value = "1000")]
    pub count: usize,

    /// Mean for Normal and Log-Normal distributions (e.g., "1s").
    #[arg(long, value_parser = humantime::parse_duration)]
    pub mean: Option<Duration>,

    /// Standard deviation for Normal and Log-Normal distributions (e.g., "0.1").
    #[arg(long)]
    pub std_dev: Option<f64>,

    /// Lambda (rate parameter) for Exponential distribution (e.g., "0.5").
    #[arg(long)]
    pub lambda: Option<f64>,

    /// Scale parameter for Pareto distribution (e.g., "1.0").
    #[arg(long)]
    pub pareto_scale: Option<f64>,

    /// Shape parameter for Pareto distribution (e.g., "1.5").
    #[arg(long)]
    pub pareto_shape: Option<f64>,

    /// Minimum value for Uniform distribution (e.g., "1s").
    #[arg(long, value_parser = humantime::parse_duration)]
    pub min: Option<Duration>,

    /// Maximum value for Uniform distribution (e.g., "5s").
    #[arg(long, value_parser = humantime::parse_duration)]
    pub max: Option<Duration>,

    /// Minimum value for Triangular distribution (e.g., "0.0").
    #[arg(long)]
    pub triangular_min: Option<f64>,

    /// Maximum value for Triangular distribution (e.g., "1.0").
    #[arg(long)]
    pub triangular_max: Option<f64>,

    /// Mode value for Triangular distribution (e.g., "0.5").
    #[arg(long)]
    pub triangular_mode: Option<f64>,

    /// Shape parameter for Gamma distribution (e.g., "2.0").
    #[arg(long)]
    pub gamma_shape: Option<f64>,

    /// Scale parameter for Gamma distribution (e.g., "1.0").
    #[arg(long)]
    pub gamma_scale: Option<f64>,

    
}

fn main() -> anyhow::Result<()> {
    let args = Cli::parse();
    let mut rng = ThreadRng::default();

    for _ in 0..args.count {
        let sample = match args.distribution.as_str() {
            "normal" => {
                let mean_duration = args.mean.expect("Mean is required for normal distribution");
                let mean_secs = mean_duration.as_secs_f64();
                let std_dev = args.std_dev.expect("Standard deviation is required for normal distribution");
                Normal::new(mean_secs, std_dev)?.sample(&mut rng)
            }
            "exponential" => {
                let lambda = args.lambda.expect("Lambda is required for exponential distribution");
                Exp::new(lambda)?.sample(&mut rng)
            }
            "log_normal" => {
                let mean_secs = args.mean.expect("Mean is required for log-normal distribution").as_secs_f64();
                let std_dev = args.std_dev.expect("Standard deviation is required for log-normal distribution");
                LogNormal::new(mean_secs, std_dev)?.sample(&mut rng)
            }
            "pareto" => {
                let scale = args.pareto_scale.expect("Scale is required for pareto distribution");
                let shape = args.pareto_shape.expect("Shape is required for pareto distribution");
                Pareto::new(scale, shape)?.sample(&mut rng)
            }
            "uniform" => {
                let min_secs = args.min.expect("Min is required for uniform distribution").as_secs_f64();
                let max_secs = args.max.expect("Max is required for uniform distribution").as_secs_f64();
                Uniform::new(min_secs, max_secs)?.sample(&mut rng)
            }
            "triangular" => {
                let min = args.triangular_min.expect("Min is required for triangular distribution");
                let max = args.triangular_max.expect("Max is required for triangular distribution");
                let mode = args.triangular_mode.expect("Mode is required for triangular distribution");
                Triangular::new(min, max, mode)?.sample(&mut rng)
            }
            "gamma" => {
                let shape = args.gamma_shape.expect("Shape is required for gamma distribution");
                let scale = args.gamma_scale.expect("Scale is required for gamma distribution");
                Gamma::new(shape, scale)?.sample(&mut rng)
            }
            _ => panic!("Unsupported distribution type"),
        };
        println!("{}", sample.max(0.0));
    }

    Ok(())
}