Add primes_geq and primes_lt generation functions, as well as sieve_geq and sieve_lt.

.gitignore

@@ -1,2 +1,2 @@
 /target
-/Cargo.lock
+/Cargo.lock

Cargo.toml

@@ -4,17 +4,19 @@ authors = ["Johanna Sörngård (jsorngard@gmail.com)"]
 version = "0.4.8"
 edition = "2021"
 license = "MIT OR Apache-2.0"
+keywords = ["primes", "const"]
+categories = ["mathematics", "no-std::no-alloc"]
 description = "Generate and work with prime numbers in const contexts"
 repository = "https://github.com/JSorngard/const-primes"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-
 [dev-dependencies]
-criterion = {version = "0.5", features = ["html_reports"]}
+criterion = { version = "0.5", features = ["html_reports"] }
 rand = "0.8"
 
+[features]
+std = [ "alloc"]
+alloc = []
+
 [[bench]]
 name = "prime_benches"
-harness = false
+harness = false

README.md

@@ -9,13 +9,13 @@ A crate for generating and working with prime numbers in const contexts.
 `#![no_std]` compatible.
 
 ## Examples
-Generate arrays of prime numbers with the function `primes` which uses a [segmented sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes#Segmented_sieve).
+Generate arrays of prime numbers with the function `primes` which uses a [segmented sieve of Eratosthenes](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes#Segmented_sieve):
 ```rust
 const PRIMES: [u32; 10] = primes();
 assert_eq!(PRIMES[5], 13);
 assert_eq!(PRIMES, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]);
 ```
-or with the type `Primes` which ensures that a non-zero number of primes are generated:
+or with the wrapping type [`Primes`]:
 ```rust
 const PRIMES: Primes<10> = Primes::new();
 assert_eq!(PRIMES[5], 13);
@@ -40,30 +40,54 @@ assert_eq!(PRIMES_LEQ_100, Some(25));
 assert!(CACHE.is_prime(1000).is_none());
 assert!(CACHE.count_primes_leq(1000).is_none());
 ```
-Creating a `Primes<0>` is a compile fail in const contexts and a panic otherwise.  
-
-### Other functionality
-Use `is_prime` to test whether a given number is prime
-```rust
-const CHECK: bool = is_prime(18_446_744_073_709_551_557);
-assert!(CHECK);
-```
-or `are_prime` to compute the prime status of the `N` first integers,
+Sieve a range of numbers for their prime status with `sieve`:
 ```rust
 const N: usize = 10;
-const PRIME_STATUS: [bool; N] = are_prime();
+const PRIME_STATUS: [bool; N] = sieve();
 //                        0      1      2     3     4      5     6      7     8      9
 assert_eq!(PRIME_STATUS, [false, false, true, true, false, true, false, true, false, false]);
+```  
+
+## Arbitrary ranges
+The crate provides prime generation and sieving functions with suffixes, e.g. `primes_geq` and `sieve_lt`
+that can be used to work with ranges that don't start at zero. They take two generics: the number of elements
+to store in the binary and the size of the sieve used during evaluation. The sieve size must be the cieling
+of the square root of the largest encountered value:
+```rust
+//                              ceil(sqrt(5_000_000_063)) = 70_711
+const PRIMES_GEQ: const_primes::Result<3> = primes_geq::<3, 70_711>(5_000_000_031);
+assert_eq!(PRIMES_GEQ?, [5_000_000_039, 5_000_000_059, 5_000_000_063]);
 ```
-or `are_prime_below` to compute the prime status of the `N` largest integers below a given value,
 ```rust
 const N: usize = 70711;
-const BIG_PRIME_STATUS: [bool; N] = are_prime_below(5_000_000_031);
-//                                     5_000_000_028  5_000_000_029  5_000_000_030
-assert_eq!(BIG_PRIME_STATUS[N - 3..], [false,         true,          false]);
+const PRIME_STATUS_LT: [bool; N] = sieve_lt(5_000_000_031);
+//                                    5_000_000_028  5_000_000_029  5_000_000_030
+assert_eq!(PRIME_STATUS_LT[N - 3..], [false,         true,          false]);
+```
+The sieving functions have yet to be modified for two generics, and must save the entire sieve in the binary.
+## Other functionality
+Use `is_prime` to test whether a given number is prime:
+```rust
+const CHECK: bool = is_prime(18_446_744_073_709_551_557);
+assert!(CHECK);
+```
+Find the next or previous prime numbers with `next_prime` and `previous_prime` if they exist:
+```rust
+const NEXT: Option<u64> = next_prime(25);
+const PREV: Option<u64> = previous_prime(25);
+const NOSUCH: Option<u64> = previous_prime(2);
+
+assert_eq!(NEXT, Some(29));
+assert_eq!(PREV, Some(23));
+assert_eq!(NOSUCH, None);
 ```
 and more!
 
+## Features
+
+`std`: derives the `Error` trait for the error types.  
+`alloc`: enables conversion of the type returned by `primes_geq` and `primes_lt` into `Vec`s and `Box`ed slices.
+
 ## License
 
 Licensed under either of

benches/prime_benches.rs

@@ -1,37 +1,54 @@
-use const_primes::{are_prime, is_prime, moebius, primes};
-use criterion::{criterion_group, criterion_main, BatchSize, Criterion};
+use const_primes::{is_prime, primes, primes_geq, primes_lt, sieve, sieve_geq, sieve_lt};
+use criterion::{criterion_group, criterion_main, BatchSize, Criterion, Throughput};
 use rand::prelude::*;
 use std::hint::black_box;
 
 fn benchmarks(c: &mut Criterion) {
-    c.bench_function("generate 10000 primes", |b| {
-        b.iter(|| black_box(primes::<10_000>()))
-    });
+    {
+        const N: usize = 10_000;
+        let mut prime_generation = c.benchmark_group("prime generation");
+        prime_generation.bench_function(format!("first {N} primes"), |b| {
+            b.iter(|| black_box(primes::<N>()))
+        });
+        prime_generation.bench_function(format!("{N} primes < 100000000"), |b| {
+            b.iter(|| black_box(primes_lt::<N, N>(100000000)))
+        });
+        prime_generation.bench_function(format!("{N} primes >= 99990000"), |b| {
+            b.iter(|| black_box(primes_geq::<N, N>(99990000)))
+        });
+    }
 
-    c.bench_function("is_prime on random numbers", |b| {
-        b.iter_batched(
-            || (0..10_000).map(|_| random()).collect::<Vec<u64>>(),
-            |data| {
-                for number in data.iter() {
-                    black_box(is_prime(*number));
-                }
-            },
-            BatchSize::SmallInput,
-        )
-    });
+    {
+        const N: u64 = 10_000;
+        let mut rng = StdRng::seed_from_u64(1234567890);
+        let mut primality_testing = c.benchmark_group("primality testing");
+        primality_testing.throughput(Throughput::Elements(N));
+        primality_testing.bench_function(format!("is_prime on {N} random numbers"), |b| {
+            b.iter_batched(
+                || (0..N).map(|_| rng.gen()).collect::<Vec<u64>>(),
+                |data| {
+                    for number in data.iter() {
+                        black_box(is_prime(*number));
+                    }
+                },
+                BatchSize::SmallInput,
+            )
+        });
+    }
 
-    c.bench_function("sieve 10000 integers", |b| {
-        b.iter(|| black_box(are_prime::<10_000>()))
-    });
-
-    let ints: Vec<_> = (1..1_000_000).map(|n| n).collect();
-    c.bench_function("möbius of first 1e6 integers", |b| {
-        b.iter(|| {
-            for &i in &ints {
-                black_box(moebius(i));
-            }
-        })
-    });
+    {
+        const N: usize = 10_000;
+        let mut sieving = c.benchmark_group("prime sieving");
+        sieving.bench_function(format!("first {N} integers"), |b| {
+            b.iter(|| black_box(sieve::<N>()))
+        });
+        sieving.bench_function(format!("{N} integers < 100000000"), |b| {
+            b.iter(|| black_box(sieve_lt::<N>(100000000)))
+        });
+        sieving.bench_function(format!("{N} integers >= 99990000"), |b| {
+            b.iter(|| black_box(sieve_geq::<N>(99990000)))
+        });
+    }
 }
 
 criterion_group!(benches, benchmarks);

rust-toolchain.toml

@@ -0,0 +1,2 @@
+[toolchain]
+channel = "nightly"