ndhistogram 0.12.0

multi-dimensional histogramming for 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

use std::{
    collections::HashMap,
    hash::{BuildHasher, RandomState},
};

use ndhistogram::{
    axis::Uniform, error::AxisError, ndhistogram, sparsehistogram, AxesTuple, DefaultHasher, Error,
    HashHistogram, Histogram, VecHistogram,
};

#[test]
fn test_vec_histogram_as_vec() {
    let mut hist = ndhistogram!(Uniform::new(1, 0.0, 1.0).unwrap());
    hist.fill(&0.5);
    let actual = hist.as_vec();
    let expected: &Vec<f64> = &vec![0.0, 1.0, 0.0];
    assert_eq!(expected, actual);
}

#[test]
fn test_vec_histogram_as_slice() {
    let mut hist = ndhistogram!(Uniform::new(1, 0.0, 1.0).unwrap());
    hist.fill(&0.5);
    let actual = hist.as_slice();
    let expected: &[f64] = &[0.0, 1.0, 0.0];
    assert_eq!(expected, actual);
}

#[test]
fn test_vec_histogram_into_vec() {
    let mut hist = ndhistogram!(Uniform::new(1, 0.0, 1.0).unwrap());
    hist.fill(&0.5);
    let actual: Vec<f64> = hist.into();
    let expected: Vec<f64> = vec![0.0, 1.0, 0.0];
    assert_eq!(expected, actual);
}

#[test]
fn test_vec_histogram_from_vec() {
    let axes: AxesTuple<_> = (Uniform::new(1, 0.0, 1.0).unwrap(),).into();
    let hist = VecHistogram::<_, _>::from_vec(axes, vec![0.0, 1.0, 0.0]);
    assert!(hist.is_ok());
}

#[test]
fn test_vec_histogram_from_vec_with_invalid_bin_numbers() {
    let axes: AxesTuple<_> = (Uniform::new(1, 0.0, 1.0).unwrap(),).into();
    let result = VecHistogram::<_, _>::from_vec(axes, vec![0.0]);
    assert_eq!(
        result,
        Err(Error::AxisError(AxisError::InvalidNumberOfBins))
    );
}

#[test]
fn test_hashhistogram_as_map() {
    let mut hist = sparsehistogram!(Uniform::new(1, 0.0, 1.0).unwrap());
    hist.fill(&0.5);
    let actual = hist.as_map();
    let expected: &HashMap<usize, f64, DefaultHasher> = &HashMap::from_iter([(1, 1.0)]);
    assert_eq!(expected, actual);
}

#[test]
fn test_hashhistogram_into_map() {
    let mut hist = sparsehistogram!(Uniform::new(1, 0.0, 1.0).unwrap());
    hist.fill(&0.5);
    let actual: HashMap<usize, f64, DefaultHasher> = hist.into();
    let expected: HashMap<usize, f64, DefaultHasher> = HashMap::from_iter([(1, 1.0)]);
    assert_eq!(expected, actual);
}

#[test]
fn test_hash_histogram_from_hashmap() {
    let axes: AxesTuple<_> = (Uniform::new(1, 0.0, 1.0).unwrap(),).into();
    let hist = HashHistogram::<_, _>::from_map(axes, HashMap::from_iter([(1, 1.0)]));
    assert!(hist.is_ok());
}

#[test]
fn test_hash_histogram_from_hashmap_with_invalid_bin_numbers() {
    let axes: AxesTuple<_> = (Uniform::new(1, 0.0, 1.0).unwrap(),).into();
    let result = HashHistogram::<_, _>::from_map(axes, HashMap::from_iter([(3, 1.0)]));
    assert_eq!(
        result,
        Err(Error::AxisError(AxisError::InvalidNumberOfBins))
    );
}

#[test]
fn test_hash_histogram_with_user_supplied_hasher() {
    let axes: AxesTuple<_> = (Uniform::new(1, 0.0, 1.0).unwrap(),).into();

    #[derive(Default)]
    struct CustomHasher;

    impl BuildHasher for CustomHasher {
        type Hasher = std::hash::DefaultHasher;

        fn build_hasher(&self) -> Self::Hasher {
            std::hash::DefaultHasher::default()
        }
    }

    let mut hist = HashHistogram::with_hasher(axes, CustomHasher);
    hist.fill(&0.5);
    let actual: HashMap<usize, f64, CustomHasher> = hist.into();
    let expected: HashMap<usize, f64, CustomHasher> = HashMap::from_iter([(1, 1.0)]);
    assert_eq!(actual, expected);
}