POPPUR爱换

标题: 小日本写的PI到底算整数/浮点/还是两者多有? [打印本页]

作者: bd7x 时间: 2008-10-14 18:12
标题: 小日本写的PI到底算整数/浮点/还是两者多有?
外面说法不一,大家给说一下

作者: trrrry 时间: 2008-10-14 20:50
我怎么觉得是用整数指令运算的

作者: fengysonny 时间: 2008-10-15 10:38
什么是浮点数？

算π肯定是浮点运算呀！

作者: 徐大侠 时间: 2008-10-15 10:43
没研究过，但按照常理应该是纯粹整数计算。想不出计算100万位Pi要怎么利用浮点流水线。

作者: nom-soccery 时间: 2008-10-15 10:44
Ramanujan公式

1914年，印度数学家Srinivasa Ramanujan在他的论文里发表了一系列共14条圆周率的计算公式，这是其中之一。这个公式每计算一项可以得到8位的十进制精度。1985年Gosper用这个公式计算到了圆周率的17,500,000位。
1989年，David & Gregory Chudnovsky兄弟将Ramanujan公式改良成为：

这个公式被称为Chudnovsky公式，每计算一项可以得到15位的十进制精度。1994年Chudnovsky兄弟利用这个公式计算到了4,044,000,000位。
Chudnovsky公式的另一个更方便于计算机编程的形式是：

[ 本帖最后由 nom-soccery 于 2008-10-15 10:46 编辑 ]

作者: 不归人 时间: 2008-10-15 11:03
提示: 作者被禁止或删除内容自动屏蔽

作者: yemingym 时间: 2008-10-15 12:25
哈哈，有小数点就是浮点了吗？{sweat:]

作者: arkee100 时间: 2008-10-15 16:14
SUPER PI是整数运算

作者: shadewither 时间: 2008-10-15 16:55
加密了？看一下汇编不就知道了{glare:]

作者: loverzhp 时间: 2008-10-15 17:05
专业。。。

作者: Ricepig 时间: 2008-10-15 17:23

原帖由 nom-soccery 于 2008-10-15 10:44 发表
Ramanujan公式

1914年，印度数学家Srinivasa Ramanujan在他的论文里发表了一系列共14条圆周率的计算公式，这是其中之一。这个 ...

super pi不是用这种级数的方法算的

作者: ccrx 时间: 2008-10-15 17:26
整数运算

作者: jstrend 时间: 2008-10-15 18:52
说用浮点算的大虾请先解决下浮点计算误差的问题

作者: fordash 时间: 2008-10-15 20:40
哦有兴趣了开始我也以为是靠浮点的。
现在一想整数比较对
比如肉u 3.2g2140 算 pi 就不如3g 5200

作者: xeon-pan 时间: 2008-10-15 22:04
应该不是浮点数，不是有个点就是浮点数的。。。

作者: yuanxm88 时间: 2008-10-16 21:20
提示: 作者被禁止或删除内容自动屏蔽

作者: 决不浪漫 时间: 2008-10-17 00:19
为了高级顶一顶

作者: fordash 时间: 2008-10-19 05:31

原帖由 weiliu86 于 2008-10-15 22:28 发表
附件里有个程序，同SUPER PI采用的是同一计算方法，你们懂C语言的自己看吧：

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

gz高人就是多啊。学习了。

作者: JOYRIDE88 时间: 2008-10-19 11:37
哇哇～

见识学习一下

作者: bessel 时间: 2008-10-19 19:00
你还是没回答用浮点还是用整数.

原帖由 weiliu86 于 2008-10-15 22:28 发表
附件里有个程序，同SUPER PI采用的是同一计算方法，你们懂C语言的自己看吧：

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

作者: bessel 时间: 2008-10-19 19:06
怎么算pi,初看起来小数么，要用浮点，
考虑到精度，小数点后的位数，人们觉得应该用整数，
再想想就会明白还是要用浮点，

再想想。{titter:]

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

作者: 花泥 时间: 2008-10-19 19:42
N年以前用K7运行某程序跑104万位，7秒

作者: bd7x 时间: 2008-11-4 03:35
:sweatingbullets: :sweatingbullets:

作者: bd7x 时间: 2008-11-4 03:51
这里是superpi官方网站：
http://www.super-computing.org/pi_current.html {victory:] {victory:]

作者: permediaX 时间: 2008-11-4 10:51
进来学习下

作者: leesd 时间: 2008-11-4 16:52
连整数运算和浮点运算有什么区别都不知道的人飘过{excl:]

作者: jstrend 时间: 2008-11-11 16:32

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

再想想。{titter:]

您还是不要再想了，越想越乱
不是有个点就是浮点嘀{closedeyes:]

作者: maomaodown 时间: 2008-11-11 17:17
这玩意和数学有啥关系
整数和浮点数没有绝对的界限看cpu 是如何设计的

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

但是。x86 算PI就是浮点运算。

作者: maomaodown 时间: 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 才会被淘汰

作者: tomsmith123 时间: 2008-11-12 10:54

原帖由 weiliu86 于 2008-11-12 09:39 发表

晕，“x86 算PI就是浮点运算”是你的高见？

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

作者: acqwer 时间: 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 编辑 ]

作者: jstrend 时间: 2008-11-12 14:44

原帖由 acqwer 于 2008-11-12 12:42 发表

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

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

乘、除和开方和浮点一定有关系？

作者: bessel 时间: 2008-11-12 17:34
一般来说任意精度计算不用这个，
但是对付这种特别多位的计算，最快的方法要用fft。

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

乘、除和开方和浮点一定有关系？

作者: 生气想爆炸 时间: 2008-11-12 17:54
不喜欢小日本!!!

作者: tomsmith123 时间: 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];
}

作者: tomsmith123 时间: 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++;
}

作者: tomsmith123 时间: 2008-11-12 20:25
标题: 一个精致的PI 程序，基于FFT
http://myownlittleworld.com/misc ... ters/piprogram.html
注意看，基本上是整数运算。

作者: bessel 时间: 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
注意看，基本上是整数运算。

作者: tomsmith123 时间: 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，还有大量的整数运算。

作者: acqwer 时间: 2008-11-13 09:26

原帖由 tomsmith123 于 2008-11-13 07:35 发表

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

比例少不代表占用CPU少，更何况比例也不少，仔细看看中间的循环次数。

作者: tomsmith123 时间: 2008-11-13 10:40

原帖由 acqwer 于 2008-11-13 09:26 发表

比例少不代表占用CPU少，更何况比例也不少，仔细看看中间的循环次数。

迭代中用一条浮点，会辅以若干条整数计算，看程序比较清楚。

作者: bessel 时间: 2008-11-13 16:55
你明白什么叫做煮熟的鸭子了吧，呵呵。

:loveliness:

原帖由 acqwer 于 2008-11-13 09:26 发表

比例少不代表占用CPU少，更何况比例也不少，仔细看看中间的循环次数。

作者: 百分百好牛 时间: 2008-11-15 00:02
好贴，当然要留下俺光辉的足迹。
:)

作者: caodick 时间: 2008-11-16 16:49
标题: 潭上高手不少哟.够噱头.
(一)浮点数
                                 (This Part mainly Froe Bill's Article)在这之前,先来看几个术语:
FPU->Floating Point Unit,浮点运算部件
BCD->Binary Coded Decimal 压缩的二十进制数,是用4个位来表示数字0~9,一个byte表示两个十进制数,比如01111001表示89
科学计数法:这是科学的~~~~具体含义查查初中还是小学的数学课本 D:)

浮点运算使用三种不同的数据:
      1)整数(Integer),又分为字,短整数(Short Integer)和长整数(Long Integer)
      2)实数(Real)分单精度(Single Real)和双精度(Double Real)
      3)压缩的二十进制数(BCD)

下面是其位数(bits)和能表示的大致范围和

      Type          Length       Range
      -----------------------------------------------
      Word Integer 16 bit       -32768 to 32768
      Short Integer  32 bit       -2.14e9 to 2.14e9
      Long Integer 64 bit       -9.22e18 to 9.22e18
      Single Real 32 bit       1.18e-38 to 3.40e38
      Double Real 64 bit       2.23e-308 to 1.79e308
      extended Real  80 bit       3.37e-1932 to 1.18e4932
      Packed BCD    80 bit       -1e18 to 1e18

双精度数和扩展精度数表示范围对一般应用来说已经足够大了!

1)整数,以补码形式存储,正数的补码是其本身,负数补码是其绝对值的各位变反后加1,下面是实际存储的例子:
      0024          var1 dw 24
      FFFE          var2 dw -2
      000004D2       var3 dd 1234
      FFFFFF85       var4 dd -123
      0000000000002694var5 dq 9876
      FFFFFFFFFFFFFEBFvar6 dq -321

2)BCD数
      在FPU中用80位表示正好是浮点堆寄存器的宽度,在其格式如下存储:
Bit
      79___72_71________________________________________0
      符号          ---18个二十进制数--------
看下面的例子:
      00000000000000012345       var1  dt 12345
      80000000000000000100       var2  dt -100

3)浮点数,这个复杂点,有三种格式

      单精度:_31_30________23_22___________0
            符号指数       有效数

      双精度:_63_62__________52_51__________________0
            符号指数          有效数

      扩展精度数:
            _79_78____________64_63___________________0
            符号指数             有效数
例子:
      C377999A                   var1  dd    -247.6
      40000000                   var2  dd    2.0
      486F4200                   var3  real4  2.45e+5
      4059100000000000          var4  dq    100.25
      3F543BF727136A40          var5  real8  0.00123

      C377999A                   var1  dd    -247.6
      40000000                   var2  dd    2.0
      486F4200                   var3  real4  2.45e+5
      4059100000000000          var4  dq    100.25
      3F543BF727136A40          var5  real8  0.001235
      400487F34D6A161E4F76       var6  real10  33.9876

DD和real4都可以在asm中来定义单精度浮点数,4 bytes
DQ和real8都可以在asm中来定义双精度浮点数,8 bytes
DT和real10都可以在asm中来定义扩展精度浮点数,10 bytes

                     (二)浮点部件

FPU从功能上分为两个部分:控制单元和运算单元,控制单元主要面向CPU,而算数单元负责具体算数运算.
FPU即浮点部件包括8个通用寄存器,5个错误指针寄存器和三个控制寄存器.

1)8个通用寄存器每个80 bit,形成一个寄存器堆栈,所有的计算结果都保存在寄存器堆栈中,其中数据全部是80位的扩展精度格式,即使是BCD,整数,单精度和双精度等在装入寄存器的时候都要被FPU自动转化为80位的扩展精度格式,注意栈顶通常表示为ST(0),然后是ST(1)...ST(i),ST(i)是相对于栈顶而言的.

和堆栈很相似,只不过宽度为80bit,映像如下:
            _______________________
            |       ST(0)       |
            |_______________________|
            |       ST(1)       |
            |_______________________|
            | ......          |
            | ......          |
            |       ST(i)       |
            |_______________________|

2)控制寄存器,FPU有三个控制寄存器:状态寄存器,控制寄存器和标记寄存器

状态寄存器->SW
      _M_____D________10___9____8___7_________5_________________________0__
   |  B |  C3| TOP| C2 | C1 | C0 | ES | | PE | UE | OE | ZE | DE | IE |
   |____|____|____|____|____|____|____|____|____|____|____|____|____|____|

B: 浮点部件正忙
C0-C3  指示浮点运算的结果,不同指令有不同含义
TOP 指示栈顶,通常是0
ES 以下任何位置位 (pe, ue, oe, ze, de, or ie) 则置位
PE 精度故障
UE 数字太小无法表示溢出
OE 现有精度无法表示,数字太大溢出
ZE 除0错
DE 指示至少有一个操作数未规格化
IE 无效错误,指示堆栈上溢或下溢,无效操作数等

控制寄存器:
      _15____________10___9____8___7_________5______________________0__
   |             |IC | RC | PC  | | PM | UM | OM | ZM | DM | IM |
   |____|____|____|___|__|_|__|__|____|____|____|____|____|____|____|

IC 无穷大控制,对486,已经无效
RC 舍入控制
      00 = 朝最接近或者偶数舍入
      01 = 朝负无穷大方向舍入
      10 = 朝正无穷大方向舍入
      11 = 超0方向截断
PC 精度控制
      00 = 单精度
      01 = 保留
      10 = 双精度
      11 = 扩展精度
PM~IM 屏蔽状态寄存器低5位指示的错误.为1则屏蔽.

标记寄存器:
      每2 bit表示一个对应堆栈寄存器的状态,具体含义如下:
   15________________________________________3_____0
   |Tag7 |...................................|tag1|
   |_____|___________________________________|____|

含义:
      00 = 有效
      01 = 零
      10 = 无效或无穷大
      11 = 为空

(三)浮点指令系统及MASM下浮点程序设计

事实上最重要和比较难于找到资料在(一)和(二)部分中已经介绍,下面是为了完整性的考虑,如果你是第一次接触浮点指令,看看下面的摘要也无妨.另外本文未涉及到的一个方面是关于浮点处理异常的情况,因为涉及到保护模式和中断、任务切换以及SEH等较多内容,我相信介绍之后只会令人更加迷惑,况且我现在似乎也无法把这几个问题完全说清除,一般我们几乎不需要知道这些.让我们先来看主要内容.

关于浮点程序设计是一个大的话题,我只是提纲挈领地简述Masm32V7(/V6)中的设计方法,因为486以上的CPU内建了浮点部件所以可以在程序里直接使用浮点指令.下面是一个小例子:

__MASMSTD  equ 1
.386p
.model flat, stdcall
option casemap :none  ; case sensitive
include c:hdhd.h
include c:hdmac.h

;;--------------
.DATA
num1 dq    12345
num2 dq    98765
res dd    0
      .DATA?
buf db 200 dup(?)

;;-----------------------------------------
.CODE
__Start:
      finit                ;初始化浮点部件
      fild num1          ;装入num1
      fild num2          ;装入num2
      fmul                   ;执行乘法
      fist res          ;存储
      invoke wsprintf,addr buf,CTEXT("the result is: %ld"),res
      invoke StdOut,addr buf ;显示,注意是控制台显示,编译用/SUBSYSTEM:CONSOLE

invoke StdIn,addr buf,20
      invoke ExitProcess,0
END __Start

具体你要怎样运用指令,那就得看你自己所要进行的操作和要执行的算法了.注意在fpu内部寄存器总是以扩展精度数来表示数值的,因此进行整数运算最后要用fist来存储,这样才能得到正确的结果,这些转换是由fpu自动完成的.

浮点指令系统分为五类:数据传送类、算术运算类、超越函数类、比较类、环境及系统控制类.
我并不想列出所有函数的参数以及用法,因为这会是劳动力的浪费.我打字用拼音的!:D)具体参考资料见文章最后,别的我就帮不上你了.

1)数据传送类,主要包括
这类指令主要是从内存装入浮点寄存器堆数据,一般目的地址总是栈顶ST(0),用调试器你可以清除的看到这一点.注意带P结尾的操作,是在前面操作完成之后出栈,也就是原来ST(1)的内容现在成了ST(0)的内容,注意到这一点,你可以方便地设计出灵活多变的程序.
装入:
      FLD Push real onto stack
      FILD Convert two's complement integer to real and push
      FBLD Convert BCD to real and push to stack
存储:
      FST Store floating-point number from stack
      FSTP Convert top of stack to integer
      FIST
      FISTP Convert top of stack to integer
      FBSTP Store BCD to integer and pop stack
交换:
      FXCH Exchange top two stack elements
常数装载:
      FLD1 装入常数1.0
      FLDZ 装入常数0.0
      FLDPI 装入常数pi (=3.1415926....精度足够,放心使用)
      FLDL2E 装入常数log(2)e
      FLDL2T 装入常数log(2)10
      FLDLG2 装入常数log(10)2
      FLDLN2 装入常数Log(e)2

我逼并不想列出所有的浮点指令的详细格式,因为没有必要!很多资料都有这些指令格式的介绍,浮点指令均以F开头,LD表示Load,ILD表示整数的Load,BLD是二十进制数的Load,这样记起来就很容易了,很多指令功能都可以根据指令一眼看出来.

2)算术运算类
加法:
      FADD/FADDP Add/add and pop
      FIADD Integer add
减法:
      FSUB/FSUBP Subtract/subtract and pop
      FSUBR/FSUBRP Subtract/subtract and pop with reversed operands
      FISUB Integer subtract
      FISUBR Integer subtract/subtract with reversed operands
乘法:
      FMUL/FMULP Multiply/multiply and pop
      FIMUL Integer multiply
除法:
      FDIV/FDIVP Divide/divide and pop
      FIDIV Integer divide
      FDIVR/FDIVRP Divide/divide and pop with reversed operands
      FIDIVR integer divide with reversed operands
其他:
      FABS Calculate absolute value
      FCHS Change sign
      FRNDINT Round to integer
      FSQRT Calculate square root
      FSCALE Scale top of stack by power of 2
      FXTRACT Separate exponent and mantissa
      FPREM Calculate partial remainder
      FPREM1 Calculate partial remainder in IEEE format

如果指令后面未带操作数,其默认的操作数为ST(0)和ST(1),关于带R后缀的指令是正常操作数的顺序变反,比如fsub执行的是x-y,fsubr执行的就是y-x.

作者: caodick 时间: 2008-11-16 16:51
标题: GO ON
3)超越函数类
三角函数
      FSIN Calculate sine
      FCOS Calculate cosine
      FSINCOS Calculate quick sine and cosine
      FPTAN Calculate partial tangent
      FPATAN Calculate partial arctangent
Log类
      FYL2X Calculate y times log base 2 of x
      FYL2XP1 Calculate y times log base 2 of (x+1)
      F2XM1 Calculate (2^x)-1

4)比较类
      FCOM Compare
      FCOMP Compare and pop
      FICOM Integer compare
      FTST Integer compare and pop
      FUCOM Unordered compare
      FUCOMP Unordered compare and pop
      FXAM Set condition code bits for value at top of stack
      FSTSW Store status word

会根据结果设置,C0~C3,在上面并未就C0~C3进行具体介绍,C1是用来判断上溢或者下溢的,C0相当于EFLAGS里面的CF,作用也基本一致,C2相当于PF,C3相当于ZF,你可能会看到如下指令
      FSTSW  ax
      SAHF
      JZ    label
为什么如此呢,因为用如上指令将状态字存入EFLAGS,C0正好置于CF位,C3正好置于ZF位.

5)环境及系统控制类
      FLDCW Load control word
      FSTCW Store control word
      FSTSW Store status word
      FLDENV Load environment block
      FSTENV Store environment block
      FSAVE Save coprocessor state
      FRSTOR Restore coprocessor state

      FINIT Initialize coprocessor
      FCLEX Clear exception flags
      FINCSTP Increment stack pointer
      FDECSTP Decrement stack pointer
      FFREE Mark element as free
      FNOP No operation
      FWAIT Wait until floating-point instruction complete

作者: caodick 时间: 2008-11-16 16:59
标题: GO ON
2．全新的整数与浮点单元

　　从P6到NetBurst架构，整数与浮点单元的变化还是相当明显，不过如今Core架构的变化也同样不小，只是部分关键技术又改回P6架构时代的设计。Core具备了3个64bit的整数执行单元，每一个都可以单独完成的64位整数运算操作。这样一来Core就有了一套64bit的复杂整数单元（这一点和P6核心的CIU相同），以及两个简单整数单元用来处理基本的操作和运算任务。但是非常特别是的是，3个64bit的整数执行单元中的一个简单整数单元和分支执行单元将会共享端口。该端口处的简单整数单元将和分支单元共同完成此处的宏指令结合的任务。

　　如果说Core架构就是P6架构，那无疑是不公平的。能够独立完成64bit整数运算对Intel x86处理器来说还是头一回，这也让Core得以走在了竞争对手的前列。此外，64bit的整数单元使用彼此独立的数据端口，因此Core能够在一个周期内同时完成3组64bit的整数运算。极强的整数运算单元使得Core在包括游戏、服务器项目、移动等方面都能够发挥广泛而强大的作用。

　　在以往的NetBurst架构中，浮点单元的性能很一般，这也是为什么AMD处理器总是在3D游戏中有更好表现的原因之一。不过Core构架进行了不小的改进。Core构架拥有2个浮点执行单元同时处理向量和标量的浮点运算，其中一个浮点单元执行负责加减等简单的处理，而另一个浮点单元则执行负责乘除等运算。尽管不能说Core构架令浮点性能有很大幅度的提升，但是其改进效果还是显而易见的。在多项测试中，Conroe台式机处理器已经能够打败AMD高端的FX62。

作者: azure911 时间: 2008-11-16 22:00
提示: 作者被禁止或删除内容自动屏蔽

作者: Megatron 时间: 2008-11-17 04:32

原帖由 weiliu86 于 2008-11-16 23:16 发表

超到冒烟也不行。
CORE I7不知在以后好超的主板上能不能达到。

希望没找错，当年如此巨大的家伙!今天小小的一块就基本代替了……汗啊！{sweat:]

[ 本帖最后由 Megatron 于 2008-11-17 04:47 编辑 ]

作者: mgsolid 时间: 2008-11-17 11:41
提示: 作者被禁止或删除内容自动屏蔽

作者: bd7x 时间: 2008-11-17 13:18
大家继续有水准{victory:] {victory:]

作者: maomaodown 时间: 2008-11-17 13:28
{excl:] {excl:] {excl:] {shy:] ms 和程序无关主要是看cpu怎么处理~~~
浮点数定点数指的cpu 处理方式 ~~~~
许多 cpu 无浮点运算照样处理小数~~~
许多cpu 无定点运算单元照样处理整数
定点数不一定是整数
浮点数不一定是小数

不知道就成了小数还是整数的问题~~{shocked:] {shocked:] {shocked:]

作者: MuGuYu 时间: 2008-11-17 16:31
看来还是两者都有学习了

此帖加精吧大家都有专研精神啊

作者: gerryho 时间: 2008-11-17 18:01
强帖留名！！这个帖子可以细细咀嚼~~~

作者: maomaodown 时间: 2008-11-17 18:36
:huh: :huh:

原帖由 caodick 于 2008-11-16 16:59 发表
2．全新的整数与浮点单元

　　从P6到NetBurst架构，整数与浮点单元的变化还是相当明显，不过如今Core架构的变化也同样不小，只是部分关键技术又改回P6架构时代的设计。Core具备了3个64bit的整数执行单元，每一个都 ...

极强的整数运算单元使得Core在包括游戏、服务器项目、移动等方面都能够发挥广泛而强大的作用。

　　在以往的NetBurst架构中，浮点单元的性能很一般，这也是为什么AMD处理器总是在3D游戏中有更好表现的原因之一

这2 句话看起来咋个是矛盾的，写文章的人。。第三句话意思就是amd 浮点好所以游戏强
第一句话就是整数强所以游戏也强·！:huh: :huh: :huh:

作者: bessel 时间: 2008-11-18 00:30
这里面有4个cpu，93年能跑到500Mhz,不是今天的cmos工艺的。
而且一个cpu也是由很多块晶片组成的。

原帖由 Megatron 于 2008-11-17 04:32 发表

希望没找错，当年如此巨大的家伙!今天小小的一块就基本代替了……汗啊！{sweat:]

作者: bessel 时间: 2008-11-18 00:34
这样对比是不公平的，日立那台机器是矢量机，每个处理器里有8个或者16个矢量单元。
如果nehalem可以同时用上4个核心应该比这个快的。

原帖由 azure911 于 2008-11-16 22:00 发表
6.Pentium 66MHz计算104万位需要 1小时13分22秒
HITAC S-3800/480计算104万位大约只需要5秒!
===========================
95年的机器啊，现在的民用cpu能有这个5秒吗？

欢迎光临 POPPUR爱换 (https://we.poppur.com/)