数学中国

 找回密码
 注册
搜索
热搜: 活动 交友 discuz
楼主: elim

e 的数值计算

[复制链接]
发表于 2019-10-7 17:49 | 显示全部楼层
elim 发表于 2019-10-7 09:30
没有根据说能算十万位. 你的计算器会溢出.

记 T(m) 为 a(m)-e 小数点后面 0 的个数,
我们可以有(大胆猜测,小心求证):
m*ln(m)*e/pi < T(m) < m*ln(m)*根号(e/pi)
回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-10-7 20:30 | 显示全部楼层
本帖最后由 elim 于 2019-10-7 08:43 编辑

就算这个不等式成立,m=109时T(m)也没过500啊.

应该承认, 如果这个不等式成立, 对应的算法是非常了不起的! 但算法究竟是什么? 怎么证明这个结果?
回复 支持 反对

使用道具 举报

发表于 2019-10-7 23:49 | 显示全部楼层
本帖最后由 王守恩 于 2019-10-8 00:05 编辑
elim 发表于 2019-10-7 20:30
就算这个不等式成立,m=109时T(m)也没过500啊.

应该承认, 如果这个不等式成立, 对应的算法是非常了不起 ...


谢谢elim老师!n=109(m=n^2=109^2) 能过10万位。n=107(m=n^2=107^2) 没过10万位。
回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-10-8 00:10 | 显示全部楼层
王守恩 发表于 2019-10-7 08:49
谢谢elim老师!n=109(m=n^2=109^2) 能过10万位。n=107(m=n^2=107^2) 没过10万位。

m = n^2 就没太大价值了. 另外, 需要给出算法的递归公式, 然后证明这个收敛估计.
回复 支持 反对

使用道具 举报

发表于 2019-10-8 00:21 | 显示全部楼层
本帖最后由 王守恩 于 2019-10-8 00:33 编辑
elim 发表于 2019-10-3 20:53
纯粹一堆数是决定不了数列,确定不了算法的.更谈不上好算法了.

误差为O(1/n!)的算法怎么超越,不是一 ...


误差为O(1/n!)的算法,要过 10 万位需要 n = 25206。
回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-10-8 00:44 | 显示全部楼层
王守恩 发表于 2019-10-7 09:21
误差为O(1/n!)的算法,要过 10 万位需要 n = 25206。

所以说算法了不起. 但是真是假不知道. 参考资料在哪里?
回复 支持 反对

使用道具 举报

发表于 2019-10-8 00:53 | 显示全部楼层
本帖最后由 王守恩 于 2019-10-8 01:29 编辑
elim 发表于 2019-10-8 00:44
所以说算法了不起. 但是真是假不知道. 参考资料在哪里?


谢谢 elim 老师!渴望得到您的指导。
回复 支持 反对

使用道具 举报

 楼主| 发表于 2019-10-8 01:05 | 显示全部楼层
你看看 Stirling 公式, 或许对表达你的想法有所帮助. 网上搜一下
回复 支持 反对

使用道具 举报

发表于 2019-10-10 07:27 | 显示全部楼层
本帖最后由 王守恩 于 2019-10-11 08:43 编辑
elim 发表于 2019-10-8 01:05
你看看 Stirling 公式, 或许对表达你的想法有所帮助. 网上搜一下


谢谢 elim 老师!先放松一下。

a(n),b(n),c(n)合在一起恰好跑遍所有正整数。不多不少,每个正整数恰好只出现 1 次。您能找出反例来吗?

a(n)={1, 4, 07, 09, 12, 15, 16, 19, 22, 25, 27, 30, 32, 34, 37, 40, 43, 45, 47, 50, 52, 55, 58, 60, 63, 65}
b(n)={2, 5, 08, 11, 14, 18, 20, 23, 26, 29, 33, 36, 38, 41, 44, 48, 51, 54, 56, 59, 62, 66, 69, 72, 75, 77}
c(n)={3, 6, 10, 13, 17, 21, 24, 28, 31, 35, 39, 42, 46, 49, 53, 57, 61, 64, 67, 71, 74, 79, 82, 85, 89, 92}
360截图20191010073652638.png
回复 支持 反对

使用道具 举报

发表于 2019-10-10 16:53 | 显示全部楼层
VC++计算高精度自然对数e(20万位)
/*
** Nicolas TU : July 2019
**
** Subject:
**
**    A very easy program to compute e with many digits.
**    No optimisations, no tricks, just a basic program to learn how
**    to compute in multiprecision.  
**
** Formula:
**
**    e = 1+1/1!+1/2!+...+1/k!+...
**
** Data:
**
**    A big real (or multiprecision real) is defined in base B as:
**      X = x(0) + x(1)/B^1 + ... + x(n-1)/B^(n-1)
**      where 0<=x(i)<B
**
** Results: (PentiumII, 450Mhz)
**   
**    1000   decimals :   0.02seconds
**    10000  decimals :   1.2s
**    100000 decimals :  97.0s
**    200000 decimals : 375.0s
**
** With a little work it's possible to reduce those computation
** times by a factor of 3 and more.
*/
#include <stdio.h>
#include <stdlib.h>
long B=10000; /* Working base */
long LB=4;    /* Log10(base)  */
/*
** Set the big real x to the small integer Integer
*/
void SetToInteger (long n, long *x, long Integer) {
  long i;
  for (i=1; i<n; i++) x[i] = 0;
  x[0] = Integer;
}
/*
** Is the big real x equal to zero ?
*/
long IsZero (long n, long *x) {
  long i;
  for (i=0; i<n; i++)  
    if (x[i])        return 0;
        return 1;
}
/*
** Addition of big reals : x += y
**  Like school addition with carry management
*/
void Add (long n, long *x, long *y) {
  long carry=0, i;
  for (i=n-1; i>=0; i--) {
    x[i] += y[i]+carry;
    if (x[i]<B) carry = 0;
    else {
      carry = 1;
      x[i] -= B;
    }
  }  
}
/*
** Division of the big real x by the integer d
**  Like school division with carry management
*/
void Div (long n, long *x, long d) {
  long carry=0, xi, q, i;
  for (i=0; i<n; i++) {
    xi    = x[i]+carry*B;
    q     = xi/d;
    carry = xi-q*d;   
    x[i]  = q;        
  }  
}
/*
** Print the big real x
*/
void Print (long n, long *x) {
  long i;
  printf ("%d.", x[0]);
  for (i=1; i<n; i++) {
    printf ("%.4d", x[i]);
    if (i%25==0) printf ("%8d\n", i*4);
  }
  printf ("\n");
}
/*
** Computation of the constant e
*/
void main () {
  long NbDigits=100000, size=1+NbDigits/LB;
  long *e  = (long *)malloc(size*sizeof(long));
  long *uk = (long *)malloc(size*sizeof(long));
  long k=1;
  /*
  ** Formula used : e = 1+1/1!+1/2!+...+1/k!+...
  */
  SetToInteger (size, e,  1); /* e  = 1 */
  SetToInteger (size, uk, 1);        /* uk = 1 */
   while (!IsZero(size, uk)) {
    Div (size, uk, k);  /* uk = u(k-1)/k */
    Add (size, e,  uk); /* e  = e + uk */
    k++;
  }  
  Print (size, e); /* Print out of e */
  free (e);
  free (uk);
}
回复 支持 反对

使用道具 举报

您需要登录后才可以回帖 登录 | 注册

本版积分规则

Archiver|手机版|小黑屋|数学中国 ( 京ICP备05040119号 )

GMT+8, 2019-11-19 02:57 , Processed in 0.179479 second(s), 16 queries .

Powered by Discuz! X3.4

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表