Math 有没有办法找到第n个素数的近似值？

是否有一个函数可以返回第n个素数的近似值？我想这是一个近似的逆素数计数函数。例如，如果我给这个函数25，它将返回一个大约100的数字，或者如果我给这个函数1000，它将返回一个大约8000的数字。我不在乎返回的数字是否为素数，但我希望它速度快（因此不生成前n个素数来返回第n个。）

我想这样做，这样我就可以使用筛子（或）生成前n个素数。因此，理想情况下，第n个的近似值永远不会低估实际第n个素数的值

---

（更新：有关查找第n个素数上界的好方法，请参阅。）

给出了低于阈值的素数，因此它可以用于给出第n个素数的近似值。

作为粗略估计，您可以使用n*ln（n）作为第n个素数的近似值。有一种更复杂但更精确的方法，你可以在维基百科上找到它的详细信息。

用筛子可能无法实现有效的实现。想想如果你想得到前10000个素数会发生什么。你可能需要对大量的数字进行筛选

---

您自己在和中的实现是在不了解appr的情况下实现这一点的好方法。素数的值

感谢所有这些答案。我怀疑有那么简单的事情，但当时我找不到。我也做了更多的研究

因为我想让a生成前n个素数，所以我想近似值大于或等于第n个素数。（因此，我想要第n个素数的上界。）

给出

n>=6

p_n <= n log n + n log log n   (1)

这是一个更严格的界限，如下表所示

n         p_n         approx 1    error%  approx 2    error%
1         2                            
10        29          31          6.90 
100       541         613         13.31
1000      7919        8840        11.63
10000     104729      114306      9.14    104921      0.18
100000    1299709     1395639     7.38    1301789     0.16
1000000   15485863    16441302    6.17    15502802    0.11
10000000  179424673   188980382   5.33    179595382   0.10

我实现了我的第n个素数近似函数，以使用

n>=7022

的第二个近似值，即

6我的最佳素数（n）估计值的第一个近似值

这是我最新的实验公式。
顺便说一句，10万亿次素数是
323780508946331
这个公式在这个尺度下运行得很好，不确定它是否继续接近
n*ln（n）+n*（ln（n））-0.9385

更严格的界限：

static const unsigned short primes_small[] = {0,2,3,5,7,11};

static unsigned long nth_prime_upper(unsigned long n) {
  double fn = (double) n;
  double flogn, flog2n, upper;
  if (n < 6)  return primes_small[n];
  flogn  = log(n);
  flog2n = log(flogn);

  if      (n >= 688383)    /* Dusart 2010 page 2 */
    upper = fn * (flogn + flog2n - 1.0 + ((flog2n-2.00)/flogn));
  else if (n >= 178974)    /* Dusart 2010 page 7 */
    upper = fn * (flogn + flog2n - 1.0 + ((flog2n-1.95)/flogn));
  else if (n >=  39017)    /* Dusart 1999 page 14 */
    upper = fn * (flogn + flog2n - 0.9484);
  else                    /* Modified from Robin 1983 for 6-39016 _only_ */
    upper = fn * ( flogn  +  0.6000 * flog2n );

  if (upper >= (double) ULONG_MAX) {
     /* Adjust this as needed for your type and exception method */
    if (n <= 425656284035217743UL) return 18446744073709551557UL;
    fprintf(stderr, "nth_prime_upper overflow\n"; exit(-1);
  }

  return (unsigned long) ceil(upper);
}

static const无符号短素数_small[]={0,2,3,5,7,11}；
静态无符号长n×素数上界（无符号长n）{
双fn=（双）n；
双花，花2N，上部；
如果（n<6）返回素数u小[n]；
flogn=log（n）；
flog2n=对数（flogn）；
如果（n>=688383）/*Dusart 2010第2页*/
上限=fn*（flogn+flog2n-1.0+（（flog2n-2.00）/flogn））；
如果（n>=178974）/*杜萨特2010第7页*/
上限=fn*（flogn+flog2n-1.0+（（flog2n-1.95）/flogn））；
如果（n>=39017）/*Dusart 1999第14页*/
上限=fn*（flogn+flog2n-0.9484）；
else/*从Robin 1983修改为6-39016*/
上限=fn*（flogn+0.6000*flog2n）；
如果（上限>=（双）ULONG_最大值）{
/*根据您的类型和异常方法的需要进行调整*/
如果（n补充Dana J的上界，这个公式应该给你一个好的下界

P(n) = (((2 Log(3, n + 2))/(Log(2.5, 2) + Log(3, 3)) + (2 Log(3, n - 2))/(Log(3, 2) + Log(3, 3)))/2) n;

不幸的是，这个公式似乎被打破了。
p8597
=88789，但是这个公式给出了88759.3，这是一个低估。n>=8602似乎可以。从检查素数到2e9，我得到：
p8621=89009，p∈ [88746.289014.4]，三角洲∈ [-0.9718，-0.9407]
通过选择8621，您可以使用常数-0.9407获得更好的近似值。下一个改进是在
p15957
。是的，论文一定是错的。根据Dussart的说法，界实际上是成立的：“第k个素数大于k（lnk+lnk−1） 为了k≥2.”，Math.Comp.，68（225），411--415.@DavidJohnstone:文章链接好像坏了。请提供一个更新的链接好吗？@Gaurav，这是一个目前正在工作的链接，在第n个素数的上限：这是最好的答案，但我认为里面有一个小错误。语句
flogn=log（flogn）；
应该是
flog2n=log（flogn）；
@GregS，谢谢！修复了。我还添加了一段关于使用逆素数界限的内容。只需将你的筛子分段。而且，绝对是埃拉托什。
1/2*(3-(8+ln(2.3))*n-n^2+1/2*(-1+
abs(-(1/2)+n+sqrt(ln(ln(n)/ln(2))*(-ln(ln(2))+ln(ln(n))+
(8*ln(3)*ln((n*ln(8*n))/ln(n)))/ln(2)))/(2*ln(ln((n*ln(8*n))/
ln(n))/ln(2))))+abs(ln(n)/ln(3)+ln(ln((n*ln(8*n))/ln(n))/ln(2))/
ln(2)))*(2*abs(ln((n*ln(8*n))/ln(n))/ln(3)+ln(ln((n*ln(8*n))/ln(n))/
ln(2))/ln(2))+abs(1/ln(ln(n)/ln(2))*(ln(ln(3))-ln(ln(n))+2*n*ln(ln(n)/
ln(2))+sqrt(((8*ln(3)*ln(n))/ln(2)-ln(ln(2))+ln(ln((n*ln(8*n))/ln(n))))*
ln(ln((n*ln(8*n))/ln(n))/ln(2)))))))

static const unsigned short primes_small[] = {0,2,3,5,7,11};

static unsigned long nth_prime_upper(unsigned long n) {
  double fn = (double) n;
  double flogn, flog2n, upper;
  if (n < 6)  return primes_small[n];
  flogn  = log(n);
  flog2n = log(flogn);

  if      (n >= 688383)    /* Dusart 2010 page 2 */
    upper = fn * (flogn + flog2n - 1.0 + ((flog2n-2.00)/flogn));
  else if (n >= 178974)    /* Dusart 2010 page 7 */
    upper = fn * (flogn + flog2n - 1.0 + ((flog2n-1.95)/flogn));
  else if (n >=  39017)    /* Dusart 1999 page 14 */
    upper = fn * (flogn + flog2n - 0.9484);
  else                    /* Modified from Robin 1983 for 6-39016 _only_ */
    upper = fn * ( flogn  +  0.6000 * flog2n );

  if (upper >= (double) ULONG_MAX) {
     /* Adjust this as needed for your type and exception method */
    if (n <= 425656284035217743UL) return 18446744073709551557UL;
    fprintf(stderr, "nth_prime_upper overflow\n"; exit(-1);
  }

  return (unsigned long) ceil(upper);
}

P(n) = (((2 Log(3, n + 2))/(Log(2.5, 2) + Log(3, 3)) + (2 Log(3, n - 2))/(Log(3, 2) + Log(3, 3)))/2) n;