POPPUR爱换

 找回密码
 注册

QQ登录

只需一步,快速开始

手机号码,快捷登录

搜索
楼主: bd7x
打印 上一主题 下一主题

小日本写的PI到底算整数/浮点/还是两者多有?

[复制链接]
21#
发表于 2008-10-19 19:06 | 只看该作者
怎么算pi,初看起来小数么,要用浮点,
考虑到精度,小数点后的位数,人们觉得应该用整数,
再想想就会明白还是要用浮点,

再想想。{titter:]

原帖由 jstrend 于 2008-10-15 18:52 发表
说用浮点算的大虾请先解决下浮点计算误差的问题
回复 支持 反对

使用道具 举报

22#
发表于 2008-10-19 19:42 | 只看该作者
N年以前用K7运行某程序跑104万位,7秒
回复 支持 反对

使用道具 举报

23#
 楼主| 发表于 2008-11-4 03:35 | 只看该作者
:sweatingbullets: :sweatingbullets:
回复 支持 反对

使用道具 举报

24#
 楼主| 发表于 2008-11-4 03:51 | 只看该作者
这里是superpi官方网站:  
http://www.super-computing.org/pi_current.html   {victory:] {victory:]
回复 支持 反对

使用道具 举报

25#
发表于 2008-11-4 10:51 | 只看该作者
进来学习下
回复 支持 反对

使用道具 举报

26#
发表于 2008-11-4 16:52 | 只看该作者
连整数运算和浮点运算有什么区别都不知道的人飘过{excl:]
回复 支持 反对

使用道具 举报

27#
发表于 2008-11-11 16:32 | 只看该作者
原帖由 bessel 于 2008-10-19 19:06 发表
怎么算pi,初看起来小数么,要用浮点,
考虑到精度,小数点后的位数,人们觉得应该用整数,
再想想就会明白还是要用浮点,

再想想。{titter:]


您还是不要再想了,越想越乱
不是有个点就是浮点嘀{closedeyes:]
回复 支持 反对

使用道具 举报

28#
发表于 2008-11-11 17:17 | 只看该作者
这玩意和数学有啥 关系
整数和浮点数 没有绝对的界限 看cpu 是如何设计的

算 整数 也可以是浮点  算浮点也可以是整数

但是。x86 算PI就是浮点运算。
回复 支持 反对

使用道具 举报

29#
发表于 2008-11-11 17:27 | 只看该作者
原帖由 weiliu86 于 2008-10-15 22:28 发表
附件里有个程序,同SUPER PI采用的是同一计算方法,你们懂C语言的自己看吧:

下面补充一下SUPER PI的知识(转):
不可否认,SuperPi历史非常悠久,用的人之多,其他同类软件难以匹敌。但是对其有更多了解的人却 ...



反对 。。算法太好就让人 产生了  cpu性能差不多的幻觉。。
越是 老的算法越能体现 cpu的差距。。。

测试cpu速度和算法的好坏无关。   只有当  10年以后? 大家用super pi 算32M的时候都小于1秒 不能再精确的时候  super pi 才会被淘汰
回复 支持 反对

使用道具 举报

30#
发表于 2008-11-12 10:54 | 只看该作者
原帖由 weiliu86 于 2008-11-12 09:39 发表

晕,“x86 算PI就是浮点运算”是你的高见?

保持精度的计算,很少能用浮点,除非对浮点精度和拼接有很好的处理办法。
回复 支持 反对

使用道具 举报

31#
发表于 2008-11-12 12:42 | 只看该作者
原帖由 tomsmith123 于 2008-11-12 10:54 发表

保持精度的计算,很少能用浮点,除非对浮点精度和拼接有很好的处理办法。


http://topic.csdn.net/t/20060328/11/4644901.html

我说,上面那些高人们都不考虑那些大数不管是做加减还要乘、除和开方的吗?

[ 本帖最后由 acqwer 于 2008-11-12 12:45 编辑 ]
回复 支持 反对

使用道具 举报

32#
发表于 2008-11-12 14:44 | 只看该作者
原帖由 acqwer 于 2008-11-12 12:42 发表


http://topic.csdn.net/t/20060328/11/4644901.html

我说,上面那些高人们都不考虑那些大数不管是做加减还要乘、除和开方的吗?

乘、除和开方和浮点一定有关系?
回复 支持 反对

使用道具 举报

33#
发表于 2008-11-12 17:34 | 只看该作者
一般来说任意精度计算不用这个,
但是对付这种特别多位的计算,最快的方法要用fft。




原帖由 jstrend 于 2008-11-12 14:44 发表

乘、除和开方和浮点一定有关系?
回复 支持 反对

使用道具 举报

34#
发表于 2008-11-12 17:54 | 只看该作者
不喜欢小日本!!!
回复 支持 反对

使用道具 举报

35#
发表于 2008-11-12 20:21 | 只看该作者

贴个PI 程序,看看吧?

太长了,局部。
pi_c50/                                                                                             0040775 0000764 0000764 00000000000 07443503674 010567  5                                                                                                    ustar   dara                            dara                                                                                                                                                                                                                   pi_c50/pi_c50.c                                                                                     0100664 0000764 0000764 00000017421 07443503674 012014  0                                                                                                    ustar   dara                            dara                                                                                                                                                                                                                   /*----------------------------------------------------------------------
program to calculate pi, version 5.0
This uses Klingenstierna's formula. The atan(1/10) term is
handled with fast shifts, and the atan(1/515) term uses a
sophisticated check to prevent overflow when dividing by 515^2
(inspired by Adrian Umpleby). Where

                    remainder*10000 + term[x]

can overflow, use instead

           (remainder - 53045 + 53045)*10000 + term[x]

Upon dividing by 515^2,

       ((remainder - 53045)*10000 + term[x])/265225 + 2000

and the quantity in parentheses is guaranteed to be less than a long
integer in size. It turns out that this is faster than using an unsigned
long remainder, and much faster than using 64 bit arithmetic. Execution
time is now down to 4.73 seconds for 5000 digits on my 486 66MHz computer,
a 2% speed boost over version 4.8, and easily the fastest pi calculator
I've seen that adds up series.

If you have gcc, compile with the -O3 optimization option. This is rather
important, since among other things the remainder from integer division
is automatically used instead of being computed all over again, and this
makes the whole thing run 30% faster.

Special thanks to Randall Williams, who crunched out the first C version
of this program and much of whose code is still here, and to Bill Lanam,
who pointed out that I didn't need assembly after all. Thanks to Bob
Farrington, Larry Shultis, and Adrian Umpleby for great ideas, and to
Gordon Spinks for making it more portable.              -jasonp@isr.umd.edu
-----------------------------------------------------------------------*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void printout(void);
void atan10(long denom);
void atan239(long denom);
void atan515(long denom);

int *term;
long *sum, firstword, words;

int main(int argc, char *argv[]){
    int remainder;
    long denom, digits = 0, x;
    clock_t end,start;

    if(argc != 2){
        printf("nusage: pi50 NumberOfDigits > OutputFilenn");
    }
    else{
        digits = atol( argv[1] );
    }

   if( digits<50 || digits>210000 ){
       printf("Setting default to 50 digits.n");
       digits=50;
        }
                                 /* Allocate array space and initialize */
   words = digits / 4 + 3;
   sum = (long *)calloc( words + 2, sizeof(long) );
   term = (int *)calloc( words + 2, sizeof(int) );
   if( sum == NULL || term == NULL ) {
       printf("Memory allocation failed. Try fewer digits.n");
       exit(EXIT_FAILURE);
   }

                                          /* ----- 32*atan(1/10) -------*/
   start = clock();
   denom = 3; sum[1] = 32;

   for (firstword=2; firstword<=words; firstword++) {
      atan10(denom);
      denom += 4;
   }
                                        /* ----- -4*atan(1/239) ------- */
   firstword = 2; denom = 3; remainder = 40;

   for( x=2; x<=words; x++){
       digits = (long)remainder * 10000;
       term[x] = digits / 239;                     /* first term */
       remainder = digits % 239;                    
       sum[x] -= term[x];
   }

   while( firstword<words ){
      atan239(denom);
      denom += 4;
        }
                                      /* ----- -16*atan(1/515) ------- */
   firstword = 2; denom = 3; remainder = 160;

   for( x=2; x<=words; x++){
       digits = (long)remainder * 10000;
       term[x] = digits / 515;                     /* first term */
       remainder = digits % 515;                    
       sum[x] -= term[x];
   }
回复 支持 反对

使用道具 举报

36#
发表于 2008-11-12 20:22 | 只看该作者
while( firstword<words ){
      atan515(denom);
      denom+=4;
   }           

   for(x=words; x>=1; x--) {                /*release carries & borrows*/
      if (sum[x]<0) {
         sum[x-1] += sum[x] / 10000;
         sum[x] = sum[x] % 10000;
         sum[x-1]--; sum[x] += 10000;
      }
      if (sum[x] >= 10000) {
         sum[x-1] += sum[x] / 10000;
         sum[x] = sum[x] % 10000;
      }                                       
   }

   end = clock();                                    /* -----Finish up */
   printout();
   printf("nComputation time = %6.2f secondsn",
         (float)(end-start)/(float)CLOCKS_PER_SEC );
   free(sum); free(term); exit(0);
}
/*-----------------------------------------------------------------*/
void atan10(long denom) {
    int remainder1, remainder2;
    long dividend, denom2 = denom+2, x;

    sum[firstword] -= 3200 / denom;
    remainder1 = 3200 % denom;

    sum[firstword] += 32 / denom2;
    remainder2 = 32 % denom2;

    for( x=firstword+1; x<=words; x++) {
       dividend = (long)remainder1 * 10000;
       sum[x] -= dividend / denom;
       remainder1 = dividend % denom;

       dividend = (long)remainder2 * 10000;
       sum[x] += dividend / denom2;
       remainder2 = dividend % denom2;
   }
}
/*---------------------------------------------------------------*/
void atan239(long denom) {
    int remainder1 = term[firstword++],  /*perform 1st divide implicitly*/
        remainder2 = 0, remainder3 = 0,
        remainder4 = 0;
    long dividend, denom2 = denom+2, temp, x;

    for( x=firstword; x<=words; x++) {
       temp = term[x];

       dividend = (long)remainder1 * 10000 + temp;    /*add next term*/
       temp = dividend / 57121;
       remainder1 = dividend % 57121;

       dividend = (long)remainder2 * 10000 + temp;
       sum[x] += dividend / denom;
       remainder2 = dividend % denom;         

       dividend = (long)remainder3 * 10000 + temp;  /*subtract next term*/
       temp = dividend / 57121;
       remainder3 = dividend % 57121;

       dividend = (long)remainder4 * 10000 + temp;
       sum[x] -= dividend / denom2;
       remainder4 = dividend % denom2;
       term[x] = temp;
    }

    firstword++;
    if( term[firstword] == 0 ) firstword++;
}
/*---------------------------------------------------------------*/
void atan515(long denom) {
       long remainder1 = term[firstword++], /*perform 1st divide implicitly*/
           remainder2 = 0, remainder3 = 0, x,
           remainder4 = 0, dividend, denom2 = denom + 2, temp;

       for( x=firstword; x<=words; x++) {         
          temp = term[x];
          if( remainder1<214745 ) {
             dividend = remainder1*10000 + temp;      /*add next term*/
             temp = dividend / 265225;
             remainder1 = dividend % 265225;
          }
          else {
             remainder1 -= 53045;
             dividend = remainder1 * 10000 + temp;
             temp = dividend / 265225;
             remainder1 = dividend % 265225;
             temp += 2000;
          }

          dividend = remainder2 * 10000 + temp;
          sum[x] += dividend / denom;
          remainder2 = dividend % denom;         

          if( remainder3<214745 ) {                   /*subtract next term*/
             dividend = remainder3 * 10000 + temp;
             temp = dividend / 265225;
             remainder3 = dividend % 265225;
          }
          else {
             remainder3 -= 53045;
             dividend = remainder3 * 10000 + temp;
             temp = dividend / 265225;
             remainder3 = dividend % 265225;
             temp += 2000;
          }

          dividend = remainder4 * 10000 + temp;
          sum[x] -= dividend / denom2;
          remainder4 = dividend % denom2;
          term[x] = temp;
       }

       firstword++;
       if( term[firstword] == 0 ) firstword++;
}
回复 支持 反对

使用道具 举报

37#
发表于 2008-11-12 20:25 | 只看该作者

一个精致的PI 程序,基于FFT

http://myownlittleworld.com/misc ... ters/piprogram.html
注意看,基本上是整数运算。
回复 支持 反对

使用道具 举报

38#
发表于 2008-11-13 02:12 | 只看该作者
Number of Floating Point Operations:
    pi_fftcs.c + fftsg_h.c:
        42*nfft*(log_2(nfft))^2           [Operations]


原帖由 tomsmith123 于 2008-11-12 20:25 发表
http://myownlittleworld.com/miscellaneous/computers/piprogram.html
注意看,基本上是整数运算。
回复 支持 反对

使用道具 举报

39#
发表于 2008-11-13 07:35 | 只看该作者
原帖由 bessel 于 2008-11-13 02:12 发表
Number of Floating Point Operations:
    pi_fftcs.c + fftsg_h.c:
        42*nfft*(log_2(nfft))^2           [Operations]

浮点部分主要是FFT,除了FFT,还有大量的整数运算。
回复 支持 反对

使用道具 举报

40#
发表于 2008-11-13 09:26 | 只看该作者
原帖由 tomsmith123 于 2008-11-13 07:35 发表

浮点部分主要是FFT,除了FFT,还有大量的整数运算。

比例少不代表占用CPU少,更何况比例也不少,仔细看看中间的循环次数。
回复 支持 反对

使用道具 举报

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

本版积分规则

广告投放或合作|网站地图|处罚通告|

GMT+8, 2025-8-21 01:45

Powered by Discuz! X3.4

© 2001-2017 POPPUR.

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