ndarray-histogram 0.5.0

Histogram support for n-dimensional arrays.
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

use ndarray::prelude::*;
use ndarray_slice::Slice1Ext;
use quickcheck_macros::quickcheck;
use std::collections::HashMap;

#[test]
fn test_sorted_get_mut() {
	let mut a = arr1(&[1, 3, 2, 10]);
	let j = *a.clone().view_mut().select_nth_unstable(2).1;
	assert_eq!(j, 3);
	let j = *a.clone().view_mut().select_nth_unstable(1).1;
	assert_eq!(j, 2);
	let j = *a.view_mut().select_nth_unstable(3).1;
	assert_eq!(j, 10);
}

#[cfg_attr(miri, ignore)]
#[quickcheck]
fn test_sorted_get_many_mut(mut xs: Vec<i64>) -> bool {
	let n = xs.len();
	if n == 0 {
		true
	} else {
		let mut v = Array::from(xs.clone());

		// Insert each index twice, to get a set of indexes with duplicates, not sorted
		let mut indexes: Vec<usize> = (0..n).collect();
		indexes.append(&mut (0..n).collect());
		let mut indexes = Array::from(indexes);
		indexes.sort_unstable();
		let (indexes, _duplicates) = indexes.partition_dedup();

		let mut map = HashMap::new();
		v.select_many_nth_unstable(&indexes, &mut map);
		let sorted_v = indexes.map(|index| *map[index]);
		xs.sort();
		println!("Sorted: {:?}. Truth: {:?}", sorted_v, xs);
		Array::from_vec(xs) == sorted_v
	}
}

#[cfg_attr(miri, ignore)]
#[quickcheck]
fn test_sorted_get_mut_as_sorting_algorithm(mut xs: Vec<i64>) -> bool {
	let n = xs.len();
	if n == 0 {
		true
	} else {
		let mut v = Array::from(xs.clone());
		let sorted_v: Vec<_> = (0..n).map(|i| *v.select_nth_unstable(i).1).collect();
		xs.sort();
		xs == sorted_v
	}
}