从（long）double转换为size_t

Question

I'm trying to implement Sieve of Eratosthenes as efficient as possible. I'd like to set length of my prime array to upper bond of pi(n) < 1.25506n / ln n but I'm not sure how to proceed with conversions to do it safely, nor which combination of types is the best for this.

Maximal length of my list would be limited by maximal size of array.

My guess is that ideal combination depends of how size_t is implemented internally and it's upper limit.

I'd like to get result as close to ceil( 1.25506n / ln n) without ever getting smaller number.

Any advises on how to do that?

Answer 1

Here's a way to do this:

#include <cstddef>
#include <cfloat>
#include <cmath>

std::size_t piUpperBound(std::size_t n) {
    double x = n;
    double num = nextafter(x, DBL_MAX);

    x = log(x);
    double den = nextafter(x, -DBL_MAX);

    double result = num/den;
    result = nextafter(1.25506, DBL_MAX)*nextafter(result, DBL_MAX);
    result = nextafter(result, DBL_MAX);

    return ceil(result);
}

This code supposes that log has at most 1 ulp error.

The basic idea is to use nextafter , which provides us the next possible floating point number. After each operation I call nextafter , to modify the number in a way so the resulting expression keeps being an upper bound.

A better bound could be created, if we suppose, that division, multiplication is correctly rounded (true for IEEE-754), and instead of nextafter , we could adjust rounding mode (to always round up or down).

Notes:

• Using ceil for the original expression may be conservative. For example, if pi(...)=12.2, there are 12 primes number at most, not 13.
• This formula is very conservative, as you can see here . So, actually, this whole floating-point business is not required. Even if the code miscalculates a little bit, it will still be an upper bound by a large margin.