重大消息-一种新的任意精度对数算法研制成功

liangbch

有这个想法，想发个SCI的论文，但是我的英文太好，需要慢慢来，不知mathe能否给我指点指点？

liangbch

我还是非常佩服gxqcn,mathe的。gxqcn的工作效率很高。mathe的数学太强了，几乎什么都会。我则属于那种比较笨的人，只是做事有恒心，不太计较功利而已。

wayne

liangbch 发表于 2017-12-28 22:34
那到不至于，测试是在循环中运行的，循环次数很多，直到总的测试时间达到1秒。另外，循环的开销也已经扣 ...

我是下载了你写的Mathematica测试代码，才这么评价的。至少从我的角度来看，　我可以把Mathematica的测试代码的性能提升一个层次。
＝＝＝＝＝＝＝＝
但不管怎么样，恭喜你，毕竟算法层面的改进是　本质性的。

zeroieme

祝贺发论文，给新算法想好名字了么

wayne

你能把修改后的代码发的这儿吗？我重测一下

回答如下：
关于Mathematica测试代码，你的代码应该做两大改动。
1）将原代码里的

1. AbsoluteTiming[Do[Log[x], {n}]][[1]] - AbsoluteTiming[Do[Null, {n}]][[1]]

复制代码

最后的  AbsoluteTiming[Do[Null, {n}] 去掉。 因为Mathematica是高度抽象的,  不同于C/C++语言几乎跟汇编指令执行序是一一对应的。你这里的空转语句 不仅没有准确测试时间，相反 增加了计算时间。不信，咱们单独跑跑下面的代码看看，哪个花的时间长：

在我的电脑上，重复计算Log[97]的10000位精度10^8次，第一个加了抛开空转时间的逻辑，花 268.41 秒，第二个花了 246.956 秒，反而比第一个返回的结果小。 ^_^

In[11]:= cnt = 100000000; AbsoluteTiming[Do[N[Log[97], 10000], {cnt}] - Do[Null, {cnt}]]
Out[11]= {268.41, 0}
In[12]:= AbsoluteTiming[Do[N[Log[97], 10000], {cnt}]]
Out[12]= {246.956, Null}

2）Mathematica里的计时器函数的精度的最小粒度是 $TimeUnit秒 ，经过实测，我的电脑上Windows系统是1/1000s ，即1ms, Linux下是 1/100s，即 10ms。
而10000位以下的精度，Mathematica基本上都是ms级别就返回的，刚好落在了这个时间精度的最小粒度的尺度下。所以我们最好是采取重复计算足够多的次数，拉开计算误差。这样才有效。

liangbch

关于扣除到空循环这种写法，这不是我的发明，我借鉴了 mpfr的测试代码， 请参阅 http://www.mpfr.org/mpfr-3.1.2/timings.mma
另外我的测试结果和你的不一样，我的测试结果显示，在多数情况下，扣除空循环的后的时间小于总的时间消耗。

1. 扣除空循环的结果
   
2. 20:took 0.00289386 ms (375148 eval in 1085.62ms) (大）
   
3. 30:took 0.00278837 ms (408408 eval in 1138.79ms) (小）
   
4. 40:took 0.0035554 ms (530536 eval in 1886.27ms)  (小）
   
5. 50:took 0.00358436 ms (379624 eval in 1360.71ms) (大）
   
6. 60:took 0.00463612 ms (288784 eval in 1338.84ms) (大）
   
7. 70:took 0.00461459 ms (229168 eval in 1057.52ms) (小）
   
8. 80:took 0.00555623 ms (187568 eval in 1042.17ms) (小）
   
9. 90:took 0.00555823 ms (314384 eval in 1747.42ms) (小）
   
10. 100:took 0.00678125 ms (268432 eval in 1820.3ms) (小）
    
11. 125:took 0.00751549 ms (192064 eval in 1443.46ms) (小）
    
12. 158:took 0.0106093 ms (135152 eval in 1433.86ms)  (小）
    
13. 199:took 0.0130916 ms (95616 eval in 1251.76ms)  (小）
    
14. 251:took 0.0186463 ms (67488 eval in 1258.4ms)  (大）
    
15. 316:took 0.0252592 ms (47776 eval in 1206.78ms) (小）
    
16. 398:took 0.0350932 ms (33792 eval in 1185.87ms) (大）
    
17. 501:took 0.0423744 ms (23936 eval in 1014.27ms) (小）
    
18. 630:took 0.06941 ms (16960 eval in 1177.19ms)    (大）
    
19. 794:took 0.0884218 ms (11984 eval in 1059.65ms) (小）
    
20. 1000:took 0.117257 ms (16960 eval in 1988.68ms) (小）
    

复制代码

1. 不扣出空循环的时间消耗
   
2. 20:took 0.00280741 ms (375148 eval in 1053.19ms)
   
3. 30:took 0.00281503 ms (408408 eval in 1149.68ms)
   
4. 40:took 0.00359441 ms (530536 eval in 1906.97ms)
   
5. 50:took 0.00355281 ms (379624 eval in 1348.73ms)
   
6. 60:took 0.00461239 ms (288784 eval in 1331.98ms)
   
7. 70:took 0.0046971 ms (229168 eval in 1076.42ms)
   
8. 80:took 0.00562833 ms (187568 eval in 1055.7ms)
   
9. 90:took 0.00558067 ms (314384 eval in 1754.47ms)
   
10. 100:took 0.00678518 ms (268432 eval in 1821.36ms)
    
11. 125:took 0.00759855 ms (192064 eval in 1459.41ms)
    
12. 158:took 0.0106693 ms (135152 eval in 1441.98ms)
    
13. 199:took 0.0132259 ms (95616 eval in 1264.61ms)
    
14. 251:took 0.0184745 ms (67488 eval in 1246.81ms)
    
15. 316:took 0.0258251 ms (47776 eval in 1233.82ms)
    
16. 398:took 0.0348993 ms (33792 eval in 1179.32ms)
    
17. 501:took 0.0426715 ms (23936 eval in 1021.39ms)
    
18. 630:took 0.0667121 ms (16960 eval in 1131.44ms)
    
19. 794:took 0.09111 ms (11984 eval in 1091.86ms)
    
20. 1000:took 0.118267 ms (8480 eval in 1002.9ms)

复制代码

所以，这不是问题。
关于 计算log(x)一亿次并精确到1万位，平均每次只需2.68微秒，如果有你这方面的经验，你一定会觉得这不大对劲，事实上，他至少比正常情况下快了千倍以上。我不知道你为什么要拿97来测试。但巧的是97是个小质数，我猜想mathematica把log(97)当做一个常数，预存了它，调用log(97)时，直接取出来给你，而我计算的是 \( \sqrt{3}-1 \) 这不是一个特殊的数，避开mathematica的这一特性。
另外，只有精度较低时，空循环的成本才不可忽视，所以我认为，欲测试空循环的成本，使用更小的精度更有道理，10000位精度有点儿大了。

落叶

疯狂计算器在计算对数时，用到了ln(2)并存起来,当第二次计算对数时会比第一次快一倍左右。

liangbch

关于重复一定次数，我的代码中并没有这样的问题。关于时间的精度，我早有考虑。最初，我的测试 bcmp_log1,bcmp_log2, Pari/GP, mpfr的代码中，时间函数的分辨率较高（用QueryPerformanceCounter实现），因此，重复次数较少，但是，我首先发现maple的用于测试时间的函数，分辨率太低了，为了公平起见，我统一采用相同的测试逻辑，即重复次数不断翻翻，直到总的时间消耗超过一秒为止，这样就使得误差在可接受的范围内。另外，我发现在mathamatica中，AbsoluteTiming函数比Timing有更高的时间分辨率，所以我改为用AbsoluteTiming来测试时间（ mpfr的测试代码中用的是Timing函数).
关于时间分辨率的具体数值，我的测试结果（windows7 64位,mathematica 10.3）和你给出的结果不太一样。
对于AbsoluteTiming，我没有得到精确的值，我估计其精度可达微秒级。
对于Timing，我得到的结果是，分辨率为15.6毫秒，即这个函数的返回值总是15.6毫秒的倍数。
对于Maple的time函数，它的返回总是1毫秒的整倍数，但并不意味着分辨率是1毫秒，其分辨率和Mathematica的Timing函数差不多,也是15.6毫秒左右。它的返回值是离散的，可能的取值有15,16,31,32,46毫秒等。

落叶

（关于 计算log(x)一亿次并精确到1万位），这个一万位是一万比特位还是一万十进制位？

liangbch

10进制的位，不是1比特