Separated out into a new trait structure

Author: wackywendell

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 
 name = "primes"
-version = "0.2.4"
+version = "0.3.0"
 authors = ["Wendell Smith <wendellwsmith@gmail.com>"]
 license="BSD-3-Clause"
 edition = "2018"

benches/benches.rs

@@ -1,9 +1,9 @@
 use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 
-use primes::PrimeSet;
+use primes::{PrimeSet, TrialDivision};
 
 fn bench_primes(c: &mut Criterion) {
-    let mut group = c.benchmark_group("PrimeSet::find");
+    let mut group = c.benchmark_group("TrialDivision::find");
 
     let mut sizes: Vec<u64> = Vec::new();
     for &base in &[5_000, 50_000] {
@@ -18,8 +18,8 @@ fn bench_primes(c: &mut Criterion) {
         group.throughput(Throughput::Elements(size));
         group.bench_with_input(BenchmarkId::from_parameter(size), &size, |b, &size| {
             b.iter(|| {
-                let mut pset = PrimeSet::new();
-                black_box(pset.find(size))
+                let mut td = TrialDivision::new();
+                black_box(td.find(size))
             })
         });
     }

src/lib.rs

@@ -6,9 +6,9 @@ A basic library for finding primes, providing a basic Iterator over all primes.
 The simplest usage is simply to create an `Iterator`:
 
 ```
-use primes::PrimeSet;
+use primes::{TrialDivision, PrimeSet};
 
-let mut pset = PrimeSet::new();
+let mut pset = TrialDivision::new();
 
 for (ix, n) in pset.iter().enumerate().take(10) {
     println!("Prime {}: {}", ix, n);
@@ -24,37 +24,37 @@ for the given test, and primes are cached for later use.
 # Example: Find the first prime after 1 million
 
 ```
-use primes::PrimeSet;
+use primes::{TrialDivision, PrimeSet};
 
-let mut pset = PrimeSet::new();
+let mut pset = TrialDivision::new();
 let (ix, n) = pset.find(1_000_000);
 
 println!("Prime {}: {}", ix, n);
 ```
 
 # Example: Find the first ten primes *after* the thousandth prime
 ```
-use primes::PrimeSet;
+use primes::{TrialDivision, PrimeSet};
 
-let mut pset = PrimeSet::new();
+let mut pset = TrialDivision::new();
 for (ix, n) in pset.iter().enumerate().skip(1_000).take(10) {
     println!("Prime {}: {}", ix, n);
 }
 ```
 
 # Example: Find the first prime greater than 1000
 ```
-use primes::PrimeSet;
+use primes::{TrialDivision, PrimeSet};
 
-let mut pset = PrimeSet::new();
+let mut pset = TrialDivision::new();
 let (ix, n) = pset.find(1_000);
 println!("The first prime after 1000 is the {}th prime: {}", ix, n);
 
 assert_eq!(pset.find(n), (ix, n));
 ```
 
-For more info on use, see `PrimeSet`, a class which handles the Sieve and has multiple methods for
-iterating over primes.
+For more info on use, see `PrimeSet`, a class which encapsulates most of the functionality and has
+multiple methods for iterating over primes.
 
 This also provides a few functions unconnected to `PrimeSet`, which will be faster for the first
 case, but slower in the long term as they do not use any caching of primes.
@@ -66,31 +66,43 @@ use std::cmp::Ordering::{Equal, Greater, Less};
 use std::ops::Index;
 use std::slice;
 
-/** A prime generator, using the Sieve of Eratosthenes.
+pub trait PrimeSetBasics {
+    /// Finds one more prime, and adds it to the list
+    fn expand(&mut self);
+
+    /// Return all primes found so far as a slice
+    fn list(&self) -> &[u64];
+}
 
-Create with `let mut pset = PrimeSet::new()`, and then use `pset.iter()` to iterate over all primes.
+/**
+A prime generator, using the Trial Division method.
+
+Create with `let mut pset = TrialDivision::new()`, and then use `pset.iter()` to iterate over all
+primes.
 **/
 #[derive(Default)]
-pub struct PrimeSet {
+pub struct TrialDivision {
     lst: Vec<u64>,
 }
 
 /// An iterator over generated primes. Created by `PrimeSet::iter` or
 /// `PrimeSet::generator`
-pub struct PrimeSetIter<'a> {
-    p: &'a mut PrimeSet,
+pub struct PrimeSetIter<'a, P: PrimeSet> {
+    p: &'a mut P,
     n: usize,
     expand: bool,
 }
 
-impl PrimeSet {
+impl TrialDivision {
     /// A new prime generator, primed with 2 and 3
-    pub fn new() -> PrimeSet {
-        PrimeSet { lst: vec![2, 3] }
+    pub fn new() -> TrialDivision {
+        TrialDivision { lst: vec![2, 3] }
     }
+}
 
+impl PrimeSetBasics for TrialDivision {
     /// Finds one more prime, and adds it to the list
-    pub fn expand(&mut self) {
+    fn expand(&mut self) {
         let mut l: u64 = self.lst[self.lst.len() - 1] + 2;
         let mut remainder = 0;
         loop {
@@ -110,22 +122,24 @@ impl PrimeSet {
         }
     }
 
-    /// Number of primes found so far
-    pub fn len(&self) -> usize {
-        self.lst.len()
+    /// Return all primes found so far as a slice
+    fn list(&self) -> &[u64] {
+        &self.lst[..]
     }
+}
 
-    pub fn is_empty(&self) -> bool {
-        false
+pub trait PrimeSet: PrimeSetBasics + Sized {
+    /// Number of primes found so far
+    fn len(&self) -> usize {
+        self.list().len()
     }
 
-    /// Return all primes found so far as a slice
-    pub fn list(&self) -> &[u64] {
-        &self.lst[..]
+    fn is_empty(&self) -> bool {
+        self.list().is_empty()
     }
 
     /// Iterator over all primes not yet found
-    pub fn generator(&mut self) -> PrimeSetIter {
+    fn generator(&mut self) -> PrimeSetIter<Self> {
         let myn = self.len();
         PrimeSetIter {
             p: self,
@@ -136,7 +150,7 @@ impl PrimeSet {
 
     /// Iterator over all primes, starting with 2. If you don't care about the "state" of the
     /// `PrimeSet`, this is what you want!
-    pub fn iter(&mut self) -> PrimeSetIter {
+    fn iter(&mut self) -> PrimeSetIter<Self> {
         PrimeSetIter {
             p: self,
             n: 0,
@@ -145,17 +159,17 @@ impl PrimeSet {
     }
 
     /// Iterator over just the primes found so far
-    pub fn iter_vec(&self) -> slice::Iter<u64> {
-        self.lst.iter()
+    fn iter_vec(&self) -> slice::Iter<u64> {
+        self.list().iter()
     }
 
     /// Find the next largest prime from a number
     ///
     /// Returns `(idx, prime)`
     ///
     /// Note that if `n` is prime, then the output will be `(idx, n)`
-    pub fn find(&mut self, n: u64) -> (usize, u64) {
-        while n > *(self.lst.last().unwrap_or(&0)) {
+    fn find(&mut self, n: u64) -> (usize, u64) {
+        while n > *(self.list().last().unwrap_or(&0)) {
             self.expand();
         }
         self.find_vec(n).unwrap()
@@ -165,8 +179,7 @@ impl PrimeSet {
     ///
     /// Note that this only requires primes up to `n.sqrt()` to be generated, and will generate
     /// them as necessary on its own.
-    #[cfg_attr(feature = "cargo-clippy", allow(clippy::wrong_self_convention))]
-    pub fn is_prime(&mut self, n: u64) -> bool {
+    fn is_prime(&mut self, n: u64) -> bool {
         if n <= 1 {
             return false;
         }
@@ -189,8 +202,8 @@ impl PrimeSet {
     /// Returns `(idx, prime)`
     ///
     /// Note that if `n` is prime, then the output will be `(idx, n)`
-    pub fn find_vec(&self, n: u64) -> Option<(usize, u64)> {
-        if n > *(self.lst.last().unwrap_or(&0)) {
+    fn find_vec(&self, n: u64) -> Option<(usize, u64)> {
+        if n > *(self.list().last().unwrap_or(&0)) {
             return None;
         }
 
@@ -200,8 +213,8 @@ impl PrimeSet {
         // Binary search algorithm
         while lim != 0 {
             let ix = base + (lim >> 1);
-            match self.lst[ix].cmp(&n) {
-                Equal => return Some((ix, self.lst[ix])),
+            match self.list()[ix].cmp(&n) {
+                Equal => return Some((ix, self.list()[ix])),
                 Less => {
                     base = ix + 1;
                     lim -= 1;
@@ -210,19 +223,19 @@ impl PrimeSet {
             }
             lim >>= 1;
         }
-        Some((base, self.lst[base]))
+        Some((base, self.list()[base]))
     }
 
     /// Get the nth prime, even if we haven't yet found it
-    pub fn get(&mut self, index: usize) -> u64 {
-        for _ in 0..(index as isize) + 1 - (self.lst.len() as isize) {
+    fn get(&mut self, index: usize) -> u64 {
+        for _ in 0..(index as isize) + 1 - (self.list().len() as isize) {
             self.expand();
         }
-        self.lst[index]
+        self.list()[index]
     }
 
     /// Get the prime factors of a number, starting from 2, including repeats
-    pub fn prime_factors(&mut self, n: u64) -> Vec<u64> {
+    fn prime_factors(&mut self, n: u64) -> Vec<u64> {
         if n == 1 {
             return Vec::new();
         }
@@ -246,17 +259,19 @@ impl PrimeSet {
     }
 }
 
-impl Index<usize> for PrimeSet {
+impl<P: PrimeSetBasics> PrimeSet for P {}
+
+impl Index<usize> for TrialDivision {
     type Output = u64;
     fn index(&self, index: usize) -> &u64 {
-        &self.lst[index]
+        &self.list()[index]
     }
 }
 
-impl<'a> Iterator for PrimeSetIter<'a> {
+impl<'a, P: PrimeSet> Iterator for PrimeSetIter<'a, P> {
     type Item = u64;
     fn next(&mut self) -> Option<u64> {
-        while self.n >= self.p.len() {
+        while self.n >= self.p.list().len() {
             if self.expand {
                 self.p.expand()
             } else {
@@ -265,7 +280,7 @@ impl<'a> Iterator for PrimeSetIter<'a> {
         }
         self.n += 1;
 
-        let m = self.p.lst[self.n - 1];
+        let m = self.p.list()[self.n - 1];
 
         Some(m)
     }

tests/basictests.rs

@@ -1,8 +1,25 @@
-use primes::{factors, factors_uniq, is_prime, PrimeSet};
+use primes::{factors, factors_uniq, is_prime, PrimeSet, PrimeSetBasics, TrialDivision};
+
+#[test]
+fn test_primesetbasics() {
+    let mut pset = TrialDivision::new();
+    let ln = pset.list().len();
+    pset.expand();
+
+    assert_eq!(pset.list().len(), ln + 1);
+}
+
+#[test]
+fn test_primeset() {
+    let mut pset = TrialDivision::new();
+    let (_idx, p) = pset.find(10);
+
+    assert_eq!(p, 11);
+}
 
 #[test]
 fn test_iter() {
-    let mut pset = PrimeSet::new();
+    let mut pset = TrialDivision::new();
     let first_few = [2u64, 3, 5, 7, 11, 13, 17, 19, 23];
     for (m, &n) in pset.iter().zip(first_few.iter()) {
         assert_eq!(m, n);
@@ -11,7 +28,7 @@ fn test_iter() {
 
 #[test]
 fn test_find() {
-    let mut pset = PrimeSet::new();
+    let mut pset = TrialDivision::new();
 
     // pset is empty, so it needs to generate the primes
     assert_eq!(pset.find_vec(1000), None);
@@ -35,7 +52,7 @@ fn test_find() {
 
 #[test]
 fn test_primes() {
-    let mut pset = PrimeSet::new();
+    let mut pset = TrialDivision::new();
 
     // note: some are repeated, because the pset list grows as it goes
 
@@ -80,7 +97,7 @@ fn test_primes() {
 
 #[test]
 fn test_factors() {
-    let mut pset = PrimeSet::new();
+    let mut pset = TrialDivision::new();
 
     let ns = [
         (1, vec![]),
@@ -113,6 +130,6 @@ fn test_factors() {
         assert_eq!(unique_factors, unique_factors_exp);
     }
 
-    pset = PrimeSet::new();
+    pset = TrialDivision::new();
     assert_eq!(pset.prime_factors(12), vec!(2, 2, 3));
 }