Add a combinatorial prime number counter

Cargo.toml

@@ -22,6 +22,7 @@ prime).
 primal-check = { path = "primal-check", version = "0.2" }
 primal-estimate = { path = "primal-estimate", version = "0.2" }
 primal-sieve = { path = "primal-sieve", version = "0.2" }
+primal-count = { path = "primal-count", version = "0.1" }
 
 [dev-dependencies]
 primal-slowsieve = { path = "primal-slowsieve", version = "0.2" }
@@ -42,5 +43,6 @@ members = [
     "primal-estimate",
     "primal-sieve",
     "primal-slowsieve",
+    "primal-count",
     "generators",
 ]

benches/bench.rs

@@ -1,10 +1,31 @@
 #[macro_use]
 extern crate criterion;
 extern crate primal;
-use criterion::{Criterion, Fun};
+use criterion::{Criterion, Fun, ParameterizedBenchmark};
 
 const N: usize = 1_000_000;
 const STEP: usize = 101;
+const SIZES: [usize; 8] = [100, 10_000, 100_000, 1_000_000, 10_000_000, 100_000_000, 1_000_000_000, 10_000_000_000];
+
+macro_rules! create_benchmarks {
+    ($(
+        fn $group_id: ident($input: expr) {
+            $first_name: expr => $first_func: expr,
+            $($rest_name: expr => $rest_func: expr,)*
+        }
+    )*) => {
+        $(
+            fn $group_id(c: &mut Criterion) {
+                let input = $input;
+
+                let bench = ParameterizedBenchmark::new(
+                    $first_name, $first_func, input.into_iter().cloned())
+                    $( .with_function($rest_name, $rest_func) )*;
+                c.bench(stringify!($group_id), bench);
+            }
+        )*
+    }
+}
 
 fn is_prime(c: &mut Criterion) {
     let miller_rabin = Fun::new(
@@ -35,6 +56,38 @@ fn is_prime(c: &mut Criterion) {
         "is_prime", vec![miller_rabin, sieve, sieve_with_init], ());
 }
 
-criterion_group!(benches, is_prime);
-criterion_main!(benches);
+create_benchmarks!{
+    fn prime_pi(SIZES) {
+        "PrimeCounter" => |b, upto: &usize| {
+            let mut s = primal::PrimeCounter::new(*upto + 1);
+            b.iter(|| s.prime_pi(*upto));
+        },
+        "Sieve" => |b, upto: &usize| {
+            let s = primal::Sieve::new(*upto + 1);
+            b.iter(|| s.prime_pi(*upto));
+        },
+
+        "PrimeCounter with init" => |b, upto: &usize| {
+            b.iter(|| {
+                let mut s = primal::PrimeCounter::new(*upto + 1);
+                s.prime_pi(*upto)
+            });
+        },
+        "Sieve with init" => |b, upto: &usize| {
+            b.iter(|| {
+                let s = primal::Sieve::new(*upto + 1);
+                s.prime_pi(*upto)
+            });
+        },
 
+        "StreamingSieve" => |b, upto: &usize| {
+            b.iter(|| primal::StreamingSieve::prime_pi(*upto))
+        },
+        "Primes" => |b, upto: &usize| {
+            b.iter(|| primal::Primes::all().take_while(|x| *x <= *upto).count())
+        },
+    }
+}
+
+criterion_group!(benches, is_prime, prime_pi);
+criterion_main!(benches);

primal-count/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "primal-count"
+version = "0.1.0"
+authors = ["Kaimyn Chapman <[email protected]>"]
+
+homepage = "https://github.com/huonw/primal"
+repository = "https://github.com/huonw/primal"
+documentation = "http://docs.rs/primal-sieve/"
+license = "MIT/Apache-2.0"
+keywords = ["math", "mathematics", "primes", "number-theory"]
+
+description = """
+A combinatorial prime counting library
+"""
+
+[dependencies]
+primal-sieve = { path = "../primal-sieve", version = "0.2.9" }
+
+[dev-dependencies]
+primal = { path = "..", version = "0.2" }
+bencher = "0.1.5"
+criterion = "0.2"
+
+[[bench]]
+name = "bench"
+harness = false

primal-count/benches/bench.rs

@@ -0,0 +1,58 @@
+#[macro_use]
+extern crate criterion;
+extern crate primal_count;
+use criterion::{Criterion, ParameterizedBenchmark};
+use primal_count::PrimeCounter;
+
+const SIZES: [usize; 7] = [
+    100,
+    10_000,
+    100_000,
+    1_000_000,
+    10_000_000,
+    10_000_000_000,
+    100_000_000_000,
+];
+
+macro_rules! create_benchmarks {
+    ($(
+        fn $group_id: ident($input: expr) {
+            $first_name: expr => $first_func: expr,
+            $($rest_name: expr => $rest_func: expr,)*
+        }
+    )*) => {
+        $(
+            fn $group_id(c: &mut Criterion) {
+                let input = $input;
+
+                let bench = ParameterizedBenchmark::new(
+                    $first_name, $first_func, input.into_iter().cloned())
+                    $( .with_function($rest_name, $rest_func) )*;
+                c.bench(stringify!($group_id), bench);
+            }
+        )*
+    }
+}
+
+create_benchmarks! {
+    fn new(SIZES) {
+        "PrimeCounter" => |b, upto: &usize| b.iter(|| PrimeCounter::new(*upto)),
+    }
+
+    fn prime_pi(SIZES) {
+        "PrimeCounter" => |b, upto: &usize| {
+            let mut s = PrimeCounter::new(*upto + 1);
+            b.iter(|| s.prime_pi(*upto));
+        },
+
+        "PrimeCounter with init" => |b, upto: &usize| {
+            b.iter(|| {
+                let mut s = PrimeCounter::new(*upto + 1);
+                s.prime_pi(*upto)
+                });
+        },
+    }
+}
+
+criterion_group!(benches, new, prime_pi);
+criterion_main!(benches);

primal-count/src/lib.rs

@@ -0,0 +1,4 @@
+mod prime_count;
+mod util;
+pub use prime_count::PrimeCounter;
+pub use util::{int_cubic_root, int_quartic_root, int_square_root};