num-format 0.1.2

A Rust crate for producing string-representations of numbers, formatted according to international standards
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

#![allow(unused_variables)]

use std::time::Duration;

use criterion::{criterion_group, criterion_main, Benchmark, Criterion};
use num_format::{format::Locale, Buffer, ToFormattedString, WriteFormatted};

fn bench_usize(c: &mut Criterion) {
    let measurement_time = Duration::from_millis(5_000); // Default is 5 seconds
    let sample_size = 100; // Default is 100
    let warm_up_time = Duration::from_millis(3_000); // Default is 3 seconds

    c.bench(
        "usize",
        Benchmark::new("std/to_string/10_000", |b| {
            b.iter(|| {
                let s = 10_000usize.to_string();
            })
        })
        .with_function("itoa/buffer/10_000", |b| {
            b.iter(|| {
                let mut bytes = [b'\0'; 40];
                let n = itoa::write(&mut bytes[..], 10_000usize).unwrap();
            })
        })
        .with_function("itoa/write/10_000", |b| {
            b.iter(|| {
                let mut s = String::new();
                itoa::fmt(&mut s, 10_000usize).unwrap();
            })
        })
        .with_function("num-format/buffer/10_000", |b| {
            b.iter(|| {
                let mut buf = Buffer::default();
                buf.write_formatted(&10_000usize, &Locale::en);
            })
        })
        .with_function("num-format/write/10_000", |b| {
            b.iter(|| {
                let mut s = String::new();
                s.write_formatted(&10_000usize, &Locale::en).unwrap();
            })
        })
        .with_function("num-format/to_string/10_000", |b| {
            b.iter(|| {
                let s = 10_000usize.to_formatted_string(&Locale::en);
            })
        })
        .with_function("std/to_string/MAX", |b| {
            b.iter(|| {
                let s = std::usize::MAX.to_string();
            })
        })
        .with_function("itoa/buffer/MAX", |b| {
            b.iter(|| {
                let mut bytes = [b'\0'; 40];
                let n = itoa::write(&mut bytes[..], std::usize::MAX).unwrap();
            })
        })
        .with_function("itoa/write/MAX", |b| {
            b.iter(|| {
                let mut s = String::new();
                itoa::fmt(&mut s, std::usize::MAX).unwrap();
            })
        })
        .with_function("num-format/buffer/MAX", |b| {
            b.iter(|| {
                let mut buf = Buffer::default();
                buf.write_formatted(&std::usize::MAX, &Locale::en);
            })
        })
        .with_function("num-format/write/MAX", |b| {
            b.iter(|| {
                let mut s = String::new();
                s.write_formatted(&std::usize::MAX, &Locale::en).unwrap();
            })
        })
        .with_function("num-format/to_string/MAX", |b| {
            b.iter(|| {
                let s = std::usize::MAX.to_formatted_string(&Locale::en);
            })
        })
        .measurement_time(measurement_time)
        .sample_size(sample_size)
        .warm_up_time(warm_up_time),
    );
}

criterion_group! {
    name = benches;
    config = Criterion::default();
    targets = bench_usize
}
criterion_main!(benches);