moma 0.3.8

Moving Origin Modular Arithmetic (MOMA), a library for modeling complex systems
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

//! Tools for number-theoretic analysis related to MOMA.

use crate::primes;

/// A tool to analyze the "dampening" of composite numbers within a range.
///
/// The dampening score measures how many composites in a range [lower, upper]
/// are divisible by a given set of small primes. A higher score means the
/// composites in the range are "less random" and more likely to be multiples
/// of small primes.
pub struct CompositeDampener {
    pub lower: u64,
    pub upper: u64,
    pub small_primes: Vec<u64>,
}

impl CompositeDampener {
    /// Creates a new `CompositeDampener`.
    pub fn new(lower: u64, upper: u64, small_primes: Vec<u64>) -> Self {
        Self {
            lower,
            upper,
            small_primes,
        }
    }

    /// Calculates the dampening score for the given range.
    ///
    /// The score is the ratio of composites hit by `small_primes` to the total
    /// number of composites in the range. It ranges from 0.0 to 1.0.
    pub fn score(&self) -> f64 {
        let composites: Vec<u64> = (self.lower + 1..self.upper)
            .filter(|&n| !primes::is_prime(n))
            .collect();

        if composites.is_empty() {
            return 0.0;
        }

        let hits = composites
            .iter()
            .filter(|&c| self.small_primes.iter().any(|sp| c % sp == 0))
            .count();

        hits as f64 / composites.len() as f64
    }
}