форк від zero/shannon-entropy-rs
143 рядки
3.1 KiB
Rust
143 рядки
3.1 KiB
Rust
|
|
// Calculate the shannon entropy of a given string for a given alphabeth
|
|
pub fn shannon_entropy(s: &str) -> f32 {
|
|
let mut entropy = 0f32;
|
|
|
|
if s.is_empty() {
|
|
return entropy;
|
|
}
|
|
|
|
for c in 0..=255 {
|
|
let count = s.matches(char::from(c)).count() as f32;
|
|
let slen = s.len() as f32;
|
|
let p : f32 = count / slen;
|
|
println!("{}, {:?} {:?} {:?}", c, count, slen, p);
|
|
if p > 0.0 {
|
|
entropy += - p * p.log2();
|
|
}
|
|
}
|
|
|
|
entropy
|
|
}
|
|
|
|
// Calculate the shannon entropy of a given string detecting the used alphabeth
|
|
pub fn str_shannon_entropy(s: &str) -> f32 {
|
|
let mut entropy = 0f32;
|
|
|
|
if s.is_empty() {
|
|
return entropy;
|
|
}
|
|
entropy = 1f32;
|
|
|
|
entropy
|
|
}
|
|
|
|
|
|
// Tests
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::shannon_entropy;
|
|
|
|
#[test]
|
|
fn it_works() {
|
|
let test_strings = vec![
|
|
("hello world", 2.8453512),
|
|
("hello worldd", 2.8553884),
|
|
("a", 0.0),
|
|
("", 0.0),
|
|
];
|
|
|
|
for (test, answer) in test_strings {
|
|
let entropy: f32 = shannon_entropy(test);
|
|
assert_eq!(entropy, answer);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_entropy_empty() {
|
|
let h = shannon_entropy("");
|
|
assert_eq!(h, 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_entropy_a() {
|
|
let h = shannon_entropy("a");
|
|
assert_eq!(h, 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_entropy_aaaaa() {
|
|
let h = shannon_entropy("aaaaa");
|
|
assert_eq!(h, 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_entropy_ab() {
|
|
let h = shannon_entropy("ab");
|
|
assert_eq!(h, 1.0);
|
|
}
|
|
|
|
#[test]
|
|
fn test_entropy_aab() {
|
|
let h = shannon_entropy("aab");
|
|
assert_eq!(h, 0.9182958);
|
|
}
|
|
|
|
#[test]
|
|
fn test_entropy_equal_distribution1() {
|
|
let mut stringmerda = String::new();
|
|
|
|
for _ in 0..2 {
|
|
for i in 0..=255 {
|
|
stringmerda.push(char::from(i));
|
|
}
|
|
}
|
|
|
|
// println!("{:#?}", stringmerda.as_bytes());
|
|
println!("{}", stringmerda.len());
|
|
// let h = shannon_entropy(&stringmerda);
|
|
|
|
// assert_eq!(h, 8.0);
|
|
}
|
|
|
|
pub fn shannon_entropy2(bytes: &[u8]) -> f32 {
|
|
let mut entropy = 0.0;
|
|
let mut counts = [0; 256];
|
|
|
|
for &b in bytes {
|
|
counts[b as usize] += 1;
|
|
}
|
|
|
|
for &count in counts.iter() {
|
|
if count == 0 { continue }
|
|
|
|
let p: f32 = (count as f32) / (bytes.len() as f32);
|
|
entropy -= p * p.log(2.0);
|
|
}
|
|
|
|
entropy
|
|
}
|
|
|
|
// #[test]
|
|
// fn test_entropy_equal_distribution2() {
|
|
// let mut bytes = [0u8; 256*2];
|
|
// for i in 0..bytes.len() {
|
|
// bytes[i] = (i % 256) as u8;
|
|
// }
|
|
|
|
// println!("{}", bytes.len());
|
|
// let pippo = String::from_utf8_lossy(&bytes);
|
|
// println!("{}", pippo.len());
|
|
// let h = shannon_entropy(&pippo);
|
|
// assert_eq!(h, 8.0);
|
|
// }
|
|
|
|
#[test]
|
|
fn test_entropy_helloworld() {
|
|
let h = shannon_entropy("hello, world");
|
|
assert_eq!(h, 3.0220551);
|
|
let h = shannon_entropy("hello world");
|
|
assert_eq!(h, 2.8453512);
|
|
}
|
|
}
|