Struct num_prime::buffer::NaiveBuffer

pub struct NaiveBuffer { /* private fields */ }

NaiveBuffer implements a very simple Sieve of Eratosthenes

Implementations

impl NaiveBuffer

pub fn new() -> Self

impl NaiveBuffer

pub fn primorial<T: PrimalityBase + Product>(&mut self, n: usize) -> T

This function calculates primorial function on n

pub fn primes(
    &mut self,
    limit: u64
) -> Take<<Self as PrimeBuffer<'_>>::PrimeIter>

Returns all primes ≤ limit. The primes are sorted.

pub fn into_primes(self, limit: u64) -> IntoIter<u64>

Returns all primes ≤ limit and takes ownership. The primes are sorted.

pub fn nprimes(
    &mut self,
    count: usize
) -> Take<<Self as PrimeBuffer<'_>>::PrimeIter>

Returns primes of certain amount counting from 2. The primes are sorted.

pub fn into_nprimes(self, count: usize) -> IntoIter<u64>

Returns primes of certain amount counting from 2 and takes ownership. The primes are sorted.

pub fn nth_prime(&mut self, n: u64) -> u64

Calculate and return the nth prime. Note that n counts from 1

Theoretically the result can be larger than 2^64, but it will takes forever to calculate that so we just return u64 instead of Option<u64> here.

pub fn prime_phi(
    &mut self,
    x: u64,
    a: usize,
    cache: &mut LruCache<(u64, usize), u64>
) -> u64

Legendre’s phi function, used as a helper function for Self::prime_pi

pub fn prime_pi(&mut self, limit: u64) -> u64

Calculate and return the prime pi function, i.e. number of primes ≤ limit.

Meissel-Lehmer method will be used if the input limit is large enough.

Trait Implementations

impl<'a> PrimeBuffer<'a> for NaiveBuffer

type PrimeIter = Iter<'a, u64>

fn contains(&self, num: u64) -> bool

Test if the number is in the buffer. If a number is not in the buffer, then it’s either a composite or large than PrimeBuffer::bound()

fn clear(&mut self)

clear the prime buffer to save memory

fn iter(&'a self) -> Self::PrimeIter

Directly return an iterator of existing primes

fn bound(&self) -> u64

Get the largest primes in the list

fn reserve(&mut self, limit: u64)

Generate primes until the largest prime in the buffer is equal or larger than limit