code-moniker-check 0.6.0

Rules engine for code-moniker: DSL, rule config/profiles, evaluation over the symbol graph, and suppression.
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

use crate::check::expr::AggregateKind;

pub(in crate::check) fn aggregate(
	kind: AggregateKind,
	values: Vec<f64>,
	percentile: Option<f64>,
) -> Option<f64> {
	match kind {
		AggregateKind::Sum => Some(values.iter().sum()),
		AggregateKind::Max => values.into_iter().reduce(f64::max),
		AggregateKind::Min => values.into_iter().reduce(f64::min),
		AggregateKind::Avg => average(&values),
		AggregateKind::Median => percentile_value(values, 50.0),
		AggregateKind::Percentile => percentile_value(values, percentile?),
		AggregateKind::Stddev => variance(&values).map(f64::sqrt),
		AggregateKind::Var => variance(&values),
		AggregateKind::Cv => {
			let mean = average(&values)?;
			if mean == 0.0 {
				return None;
			}
			Some(variance(&values)?.sqrt() / mean.abs())
		}
		AggregateKind::Gini => gini(&values),
	}
}

fn average(values: &[f64]) -> Option<f64> {
	(!values.is_empty()).then(|| values.iter().sum::<f64>() / values.len() as f64)
}

fn variance(values: &[f64]) -> Option<f64> {
	let mean = average(values)?;
	Some(
		values
			.iter()
			.map(|value| (value - mean).powi(2))
			.sum::<f64>()
			/ values.len() as f64,
	)
}

fn percentile_value(mut values: Vec<f64>, percentile: f64) -> Option<f64> {
	if values.is_empty() || !(0.0..=100.0).contains(&percentile) {
		return None;
	}
	values.sort_by(|left, right| left.total_cmp(right));
	let rank = (percentile / 100.0) * (values.len().saturating_sub(1)) as f64;
	let lower = rank.floor() as usize;
	let upper = rank.ceil() as usize;
	if lower == upper {
		return values.get(lower).copied();
	}
	let weight = rank - lower as f64;
	Some(values[lower] + (values[upper] - values[lower]) * weight)
}

fn gini(values: &[f64]) -> Option<f64> {
	if values.is_empty() {
		return None;
	}
	let mut sorted = values
		.iter()
		.copied()
		.filter(|value| *value >= 0.0)
		.collect::<Vec<_>>();
	if sorted.len() != values.len() {
		return None;
	}
	sorted.sort_by(|left, right| left.total_cmp(right));
	let sum = sorted.iter().sum::<f64>();
	if sum == 0.0 {
		return Some(0.0);
	}
	let weighted = sorted
		.iter()
		.enumerate()
		.map(|(index, value)| (index as f64 + 1.0) * value)
		.sum::<f64>();
	Some(
		(2.0 * weighted) / (sorted.len() as f64 * sum)
			- (sorted.len() as f64 + 1.0) / sorted.len() as f64,
	)
}

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

	#[test]
	fn descriptive_statistics_share_one_deterministic_implementation() {
		let values = vec![1.0, 1.0, 10.0];
		assert_eq!(
			aggregate(AggregateKind::Avg, values.clone(), None),
			Some(4.0)
		);
		assert_eq!(
			aggregate(AggregateKind::Median, values.clone(), None),
			Some(1.0)
		);
		assert_eq!(
			aggregate(AggregateKind::Percentile, values.clone(), Some(90.0)),
			Some(8.2)
		);
		assert_eq!(aggregate(AggregateKind::Gini, values, None), Some(0.5));
	}
}