csd-rs 0.1.2

Canonical Signed Digit Conversion in Rust
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

use std::env;
use std::f64;
use std::str::FromStr;
use log::{info, debug};
use csdigit::{to_csd, to_csdnnz, to_decimal};

fn parse_args(args: &[String]) -> Result<Args, &'static str> {
let mut decimal = f64::INFINITY;
let mut decimal2 = f64::INFINITY;
let mut csdstr = String::new();
let mut loglevel = log::LevelFilter::Off;

    let mut i = 0;
    while i < args.len() {
        match args[i].as_str() {
            "--version" => {
                println!("csdigit {}", env!("CARGO_PKG_VERSION"));
                return Err("");
            }
            "-c" | "--to_csd" => {
                i += 1;
                decimal = f64::from_str(&args[i]).unwrap();
            }
            "-v" | "--verbose" => {
                loglevel = log::LevelFilter::Info;
            }
            _ => {
                csdstr = args[i].clone();
            }
        }
        i += 1;
    }

    Ok(Args {
        decimal,
        decimal2,
        csdstr,
        loglevel,
    })

}

fn setup_logging(loglevel: log::LevelFilter) {
env::set_var("RUST_LOG", "csdigit=debug");
env_logger::builder()
.format_timestamp(Some("%Y-%m-%d %H:%M:%S"))
.format(|buf, record| {
writeln!(
buf,
"[{}] {}: {}",
buf.timestamp(),
record.level(),
record.args()
)
})
.filter(None, loglevel)
.init();
}

fn main() {
let args: Vec<String> = env::args().collect();
let args = parse_args(&args[1..]).unwrap();
setup_logging(args.loglevel);
debug!("Starting crazy calculations...");

    if args.decimal != f64::INFINITY {
        let ans = to_csd(args.decimal, args.places);
        println!("{}", ans);
    }
    if args.decimal2 != f64::INFINITY {
        let ans = to_csdnnz(args.decimal2, args.nnz);
        println!("{}", ans);
    }
    if !args.csdstr.is_empty() {
        let ans = to_decimal(&args.csdstr);
        println!("{}", ans);
    }

    info!("Script ends here");

}

struct Args {
decimal: f64,
decimal2: f64,
csdstr: String,
loglevel: log::LevelFilter,
}

fn run() {
main();
}

#[cfg(test)]
mod tests {
use super::\*;

    #[test]
    fn test_parse_args() {
        let args = vec![
            String::from("-c"),
            String::from("3.14"),
            String::from("-v"),
        ];
        let result = parse_args(&args);
        assert_eq!(result.is_ok(), true);
        let args = result.unwrap();
        assert_eq!(args.decimal, 3.14);
        assert_eq!(args.decimal2, f64::INFINITY);
        assert_eq!(args.csdstr, String::new());
        assert_eq!(args.loglevel, log::LevelFilter::Info);
    }

}