代码优化－之－优化浮点数取整

最新推荐文章于 2021-11-11 13:24:02 发布
最新推荐文章于 2021-11-11 13:24:02 发布
阅读量1.3w 收藏 12
点赞数 1
分类专栏： 代码优化 文章标签： 优化 float 测试 编译器 delphi 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/housisong/article/details/1616026
版权

                           代码优化－之－优化浮点数取整
                        HouSisong@GMail.com  2007.05.19

tag: 浮点数转换为整数,fpu,sse,sse2,读缓冲区优化,代码优化,ftol,取整,f2l,ftoi,f2i,floattoint 
摘要: 本文首先给出一个浮点数取整的需求，并使用默认的取整方式，然后通过尝试各种方法来优化它的速度；
  最终的浮点数取整实现速度甚至达到了初始代码的5倍(是vc6代码的18倍)！

(注意: 文章中的测试结果在不同的CPU和系统环境下可能有不同的结果,数据仅作参考)

(2007.06.08更新： 补充SSE3新增的FPU取整指令fisttp的说明)
(2007.06.04更新： 一些修正、补充double取整、补充FPU的RC场说明)


正文:
  为了便于讨论，这里代码使用C++，涉及到汇编优化的时候假定为x86平台;使用的编译器为vc2005;
  测试使用的CPU为AMD64x2 4200+,测试时使用的单线程执行;
  为了代码的可读性,没有加入异常处理代码;


A: 需要优化的原始代码(使用了大量的浮点数到整数的转换)

#include <stdio.h>
#include  <stdlib.h>
#include  <time.h>

volatile long testResult; //使用一个全局域的volatile变量以避免编译器把需要测试的代码优化掉
const long    testDataCount=10000000 ;
const long    testCount=20 ;
float          fSrc[testDataCount];
#define asm __asm

void  ftol_test_0()
{
    long tmp=0 ;
    for (long i = 0; i < testDataCount; ++ i) 
        tmp +=(long)fSrc[i];  //需要优化的浮点数取整
    testResult= tmp;
}

int  main()
{
    //inti
    for (long i=0;i<testDataCount;++ i)
        fSrc[i]=(float)(rand()*(1.0/RAND_MAX)*(rand()-(RAND_MAX>>1))*rand()*(1.0/ RAND_MAX));

    //test
    double start0=(double )clock();    
    for (long c=0;c<testCount;++ c)
        ftol_test_0();
    start0=((double)clock()-start0)*(1.0/ CLOCKS_PER_SEC);

    //out
    printf ("  Result = %ud   Seconds = %8.5f " ,testResult,start0);

    return 0 ;
}


//速度测试:        
//==============================================================================
// ftol_test_0                        1.047 秒  (VC6编译 3.64 秒):        
//          (使用vc2005的SSE编译选项  “/arch:SSE” 0.437 秒)

   一般编译器生成的浮点数转换为整数的指令序列都比预想的速度慢很多,它的性能代价很容易被人忽略；
在VC6编译器下上面的代码需要运行3.64秒，代码先修改FPU的取整模式(RC场)，完成取整后在恢复RC场；
VC2006生成的代码在CPU支持SSE的时候会调用使用cvttsd2si指令实现的版本，从而加快了取整的速度,
达到了1.047秒，快了很多！
让我们来尝试继续优化这个含有大量取整操作的函数ftol_test_0；

B: 最容易想到的就是用浮点协处理器(FPU)(也可以称作x87)来优化取整
将设置FPU取整方式和恢复FPU的取整方式的代码放到循环体外面从而加快了速度

void  ftol_test_fpu()
{
    unsigned short  RC_Old;
    unsigned short  RC_Edit;
    long  isrc;
    asm
    {
        //设置FPU的取整方式  为了直接使用fistp浮点指令
        FNSTCW  RC_Old             // 保存协处理器控制字,用来恢复
        FNSTCW  RC_Edit            // 保存协处理器控制字,用来修改
        FWAIT
        OR      RC_Edit, 0x0F00    // 改为 RC=11  使FPU向零取整
        FLDCW   RC_Edit            // 载入协处理器控制字,RC场已经修改

        mov     ecx,testDataCount
        xor     eax,eax
        test    ecx,ecx
        jle     EndLoop

        lea     edx,[fSrc +ecx*4 ]
        neg     ecx
      StartLoop:
            fld     dword ptr [edx+ecx*4 ]
            fistp   isrc
            add     eax,isrc

          inc     ecx
          jnz     StartLoop

      EndLoop:
        
        mov  testResult,eax;
    
        //恢复FPU的取整方式
        FWAIT
        FLDCW   RC_Old 
    }
} 
 
   //RC场占用第11、10bit位 用于控制舍入方向
   // RC=00 向最近(或偶数)舍入   RC=01 向下(负无穷大)舍入          
   // RC=10 向上(正无穷大)舍入   RC=11 向零舍入      
   //提示:一般的编程语言环境中,RC场都会设置为一个默认值(一般为RC=00),
   //  语言就可能利用这一点做快速的取整(比如Delphi中的round函数)，但某些引入的
   //  第三方库或代码可能会修改该默认值，从而造成以前运行正确的程序出现异常情况


//速度测试:        
//==============================================================================
// ftol_test_fpu                      0.407 秒

SSE3增加了一条FPU取整指令fisttp,和fistp指令功能几乎相同(我的电脑上经过测试速度也相同)，但默认向0取整，和RC场设置无关，所以使用fisttp的代码就可以不管RC场了，有利于简化代码和优化性能； 

C:利用浮点数的编码格式来“手工”处理浮点数到整数的转换(利用了IEEE浮点编码格式)

    inline long _ftol_ieee(float  f)
    { 
        long a         = *(long*)(& f);
        unsigned long mantissa  = (a&((1<<23)-1))|(1<<23); //不支持非规格化浮点数
        long exponent  = ((a&0x7fffffff)>>23 );
        long r         = (mantissa<<8) >> (31+127- exponent);
        long sign      = (a>>31 ); 
        return ((r ^ (sign)) - sign ) &~ ((exponent-127)>>31 );
    }

void  ftol_test_ieee()
{
    long tmp=0 ;
    for (long i = 0; i < testDataCount; ++ i) 
        tmp += _ftol_ieee(fSrc[i]);  
    testResult= tmp;
}


//速度测试:        
//==============================================================================
// ftol_test_ieee                     0.828 秒

 
手工实现居然超过了VC2005的SSE实现(主要是VC2005的实现函数调用开销太大)；

如果能够允许存在误差的话，还有一个快速的取整算法(注意，该函数的结果和标准不完全相同)：// ftol_test_ieee_M                   0.438 秒

inline long ftol_ieee_M(float  x) 
{ 
    static const float magic_f = (3<<21 );
    static const long magic_i = 0x4ac00000 ;
    float ftmp=x+ magic_f;
    return  (*((long*)&ftmp)-magic_i) >> 1 ; 
}

 


D:对于Double到整数的转换有一个超强的算法 (利用了IEEE浮点编码格式)

    inline long _ftol_ieee_MagicNumber(double  x)  
    { 
        static const double magic = 6755399441055744.0; // (1<<51) | (1<<52)
        double tmp =  x;
        tmp += (x > 0) ? -0.499999999999 : +0.499999999999; //如果需要4舍5入取整就去掉这一行
        tmp +=  magic;
        return *(long*)& tmp;
    }
void  ftol_test_ieee_MagicNumber()
{
    long tmp=0 ;
    for (long i = 0; i < testDataCount; ++ i) 
        tmp += _ftol_ieee_MagicNumber(fSrc[i]);  
    testResult= tmp;
}

(警告:该算法要求FPU的计算精度为高精度模式，某些程序可能为了速度而将FPU改成了低精度模式，
比如在D3D中会默认调整该设置)


//速度测试:        
//==============================================================================
// ftol_test_ieee_MagicNumber         1.813 秒

如果需要4舍5入取整，速度就能快出很多，降低到0.407秒


( ftol_test_ieee,ftol_test_ieee_MagicNumber的实现主要参考了:  云风的《_ftol 的优化》：

http://blog.codingnow.com/2005/12/_ftol_opt.html
     和 http://www.flipcode.com/cgi-bin/fcarticles.cgi?show=64008    这里有改动)


E:借鉴vc2005的SSE实现使用cvttss2si指令

void  ftol_test_sse()
{
    asm
    {
        mov     ecx,testDataCount
        xor     eax,eax
        test    ecx,ecx
        jle     EndLoop

        lea     edx,[fSrc+ecx*4 ]
        neg     ecx
      StartLoop:
            cvttss2si   ebx,dword ptr [edx+ecx*4 ]
            add     eax,ebx

          inc     ecx
          jnz     StartLoop

      EndLoop:
        
        mov  testResult,eax;
    }
}


//速度测试:        
//==============================================================================
// ftol_test_sse                      0.422 秒

F: cvttss2si是一个单指令单数据流的指令，我们可以使用它的单指令多数据流的版本：
cvttps2dq指令；它能同时将4个float取整！

long ftol_sse_expand16(float* psrc,long  count16) 
{
    long  result;
    asm
    {
        mov     ecx,count16
        test    ecx,ecx
        jle     EndLoop
        
        pxor    xmm0,xmm0
        pxor    xmm1,xmm1
        mov     ecx,count16
        mov     edx,psrc
        lea     edx,[edx+ecx*4]
        neg     ecx
      StartLoop:  //一次循环处理16个float
            cvttps2dq   xmm2,xmmword ptr [edx+ecx*4 ]
            cvttps2dq   xmm3,xmmword ptr [edx+ecx*4+16 ]
            cvttps2dq   xmm4,xmmword ptr [edx+ecx*4+16*2 ]
            cvttps2dq   xmm5,xmmword ptr [edx+ecx*4+16*3 ]
            paddd       xmm2,xmm3
            paddd       xmm4,xmm5
            add     ecx,16
            paddd       xmm0,xmm2
            paddd       xmm1,xmm4

          jnz     StartLoop

      EndLoop:
        paddd       xmm0,xmm1

        movaps      xmm1,xmm0 
        movhlps     xmm1,xmm0
        paddd       xmm0,xmm1
        movaps      xmm2,xmm0 
        shufps      xmm2,xmm0, 1
        paddd       xmm0,xmm2            
        
        movd       eax,xmm0
        mov        result,eax
    }
     return   result;
}
void  ftol_test_sse_expand16()
{
    long tmp=0 ;
    for (long i = 0; i < testDataCount; i+=2000 )  
    {
        tmp+=ftol_sse_expand16(&fSrc[i],2000);//2000=16*125
    }
    //todo: 因为testDataCount是2000的倍数，所以这里不用处理边界了
    testResult= tmp;
}


//速度测试:        
//==============================================================================
// ftol_test_sse_expand16             0.281 秒

 

G: 由于函数需要读取大量的数据来处理，所以可以考虑优化读缓冲区(也可以考虑使用显式预读指令)

long ftol_sse_expand16_prefetch(float* psrc,long  count16)
{
    long  result;
    asm
    {
        mov     ecx,count16
        test    ecx,ecx
        jle     EndLoop
        
        //预读
        mov     edx,psrc 
        lea     edx,[edx+ecx*4 ]
        neg     ecx
      ReadStartLoop:
            mov     eax,dword ptr [edx+ecx*4 ]
            add     ecx,16
          jnz     ReadStartLoop

        pxor    xmm0,xmm0
        pxor    xmm1,xmm1
        mov     ecx,count16
        neg     ecx
      StartLoop:
            cvttps2dq   xmm2,xmmword ptr [edx+ecx*4]
            cvttps2dq   xmm3,xmmword ptr [edx+ecx*4+16]
            cvttps2dq   xmm4,xmmword ptr [edx+ecx*4+16*2]
            cvttps2dq   xmm5,xmmword ptr [edx+ecx*4+16*3]
            paddd       xmm2,xmm3
            paddd       xmm4,xmm5
            add     ecx,16
            paddd       xmm0,xmm2
            paddd       xmm1,xmm4
          jnz     StartLoop

      EndLoop:
        paddd       xmm0,xmm1

        movaps      xmm1,xmm0 
        movhlps     xmm1,xmm0
        paddd       xmm0,xmm1
        movaps      xmm2,xmm0 
        shufps      xmm2,xmm0, 1
        paddd       xmm0,xmm2            
        
        movd       eax,xmm0
        mov        result,eax
    }
     return   result;
}
void  ftol_test_sse_expand16_prefetch()
{
    long tmp=0 ;
    for (long i = 0; i < testDataCount; i+=2000 ) 
    {
        tmp+=ftol_sse_expand16_prefetch(&fSrc[i],2000 );
    }
   testResult= tmp;
}


//速度测试:        
//==============================================================================
// ftol_test_sse_expand16_prefetch    0.219 秒

H:补充Double的取整，完整测试源代码

#include <stdio.h>
#include  <stdlib.h>
#include  <time.h>

volatile long testResult; //使用一个全局域的volatile变量以避免编译器把需要测试的代码优化掉
const long    testDataCount=10000000 ;
const long    testCount=20 ;
double          fSrc[testDataCount];
#define asm __asm

void  dftol_test_0()
{
    long tmp=0 ;
    for (long i = 0; i < testDataCount; ++ i) 
    {
        tmp +=(long)fSrc[i];  //需要优化的浮点取整
    }
    testResult= tmp;
}


void  dftol_test_fpu()
{
    unsigned short  RC_Old;
    unsigned short  RC_Edit;
    long  isrc;
    asm  //设置FPU的取整方式  为了直接使用fistp浮点指令
    {
        FNSTCW  RC_Old             // 保存协处理器控制字,用来恢复
        FNSTCW  RC_Edit            // 保存协处理器控制字,用来修改
        FWAIT
        OR      RC_Edit, 0x0F00    // 改为 RC=11  使FPU向零取整     
        FLDCW   RC_Edit            //  载入协处理器控制字,RC场已经修改
    // }
    // asm
    //{
        mov     ecx,testDataCount
        xor     eax,eax
        test    ecx,ecx
        jle     EndLoop

        lea     edx,[fSrc+ecx*8 ]
        neg     ecx
      StartLoop:
            fld     qword ptr [edx+ecx*8 ]
            fistp   isrc
            add     eax,isrc

          inc     ecx
          jnz     StartLoop

      EndLoop:
        
        mov  testResult,eax;
    // }
    //asm  // 恢复FPU的取整方式
    //{
        FWAIT
        FLDCW   RC_Old 
    }
}

inline long dftol_ieee_MagicNumber(double  x)  
{ 
    static const double magic = 6755399441055744.0; // (1<<51) | (1<<52)
    double tmp =  x;
    tmp += (x > 0) ? -0.499999999999 : +0.499999999999; //如果需要4舍5入取整就去掉这一行
    tmp +=  magic;
    return *(long*)& tmp;
}


void  dftol_test_ieee_MagicNumber()
{
    long tmp=0 ;
    for (long i = 0; i < testDataCount; ++ i) 
        tmp += dftol_ieee_MagicNumber(fSrc[i]);  
    testResult= tmp;
}



void  dftol_test_sse2()
{
    asm
    {
        mov     ecx,testDataCount
        xor     eax,eax
        test    ecx,ecx
        jle     EndLoop

        lea     edx,[fSrc+ecx*8 ]
        neg     ecx
      StartLoop:
            cvttsd2si   ebx,qword ptr [edx+ecx*8 ]
            add     eax,ebx

          inc     ecx
          jnz     StartLoop

      EndLoop:
        
        mov  testResult,eax;
    }
}

long dftol_sse2_expand8(double* psrc,long  count8)
{
    long  result;
    asm
    {
        mov     ecx,count8
        test    ecx,ecx
        jle     EndLoop
        
        pxor    xmm0,xmm0
        pxor    xmm1,xmm1
        mov     edx,psrc 
        lea     edx,[edx+ecx*8 ]
        neg     ecx
      StartLoop://一次循环处理8个double
            cvttpd2dq   xmm2,xmmword ptr [edx+ecx*8 ]
            cvttpd2dq   xmm3,xmmword ptr [edx+ecx*8+16 ]
            cvttpd2dq   xmm4,xmmword ptr [edx+ecx*8+16*2 ]
            cvttpd2dq   xmm5,xmmword ptr [edx+ecx*8+16*3 ]
            paddd       xmm2,xmm3
            paddd       xmm4,xmm5
            add     ecx,8
            paddd       xmm0,xmm2
            paddd       xmm1,xmm4

          jnz     StartLoop

      EndLoop:
        paddd       xmm0,xmm1

        movaps      xmm1,xmm0 
        shufps      xmm1,xmm0, 1
        paddd       xmm0,xmm1            

        movd       eax,xmm0
        mov        result,eax
    }
     return   result;
}
void  dftol_test_sse2_expand8()
{
    long tmp=0 ;
    for (long i = 0; i < testDataCount; i+=2000 )  
    {
        tmp+=dftol_sse2_expand8(&fSrc[i],2000);//2000=8*256
    }
    //todo: 因为testDataCount是2000的倍数，所以这里不用处理边界了
    testResult= tmp;
}


long dftol_sse2_expand8_prefetch(double* psrc,long  count8)
{
    long  result;
    asm
    {
        mov     ecx,count8
        test    ecx,ecx
        jle     EndLoop
        
        //预读
        mov     edx,psrc 
        lea     edx,[edx+ecx*8 ]
        neg     ecx
      ReadStartLoop:
            mov     eax,dword ptr [edx+ecx*8 ]
            add     ecx,8
          jnz     ReadStartLoop

        pxor    xmm0,xmm0
        pxor    xmm1,xmm1
        mov     ecx,count8
        neg     ecx
      StartLoop:
            cvttpd2dq   xmm2,xmmword ptr [edx +ecx*8 ]
            cvttpd2dq   xmm3,xmmword ptr [edx+ecx*8+16 ]
            cvttpd2dq   xmm4,xmmword ptr [edx+ecx*8+16*2 ]
            cvttpd2dq   xmm5,xmmword ptr [edx+ecx*8+16*3 ]
            paddd       xmm2,xmm3
            paddd       xmm4,xmm5
            add     ecx,8
            paddd       xmm0,xmm2
            paddd       xmm1,xmm4

          jnz     StartLoop

      EndLoop:
        paddd       xmm0,xmm1

        movaps      xmm2,xmm0 
        shufps      xmm2,xmm0, 1
        paddd       xmm0,xmm2            
        
        movd       eax,xmm0
        mov        result,eax
    }
     return   result;
}
void  dftol_test_sse2_expand8_prefetch()
{
    long tmp=0 ;
    for (long i = 0; i < testDataCount; i+=2000 ) 
    {
        tmp+=dftol_sse2_expand8_prefetch(&fSrc[i],2000 );
    }
   testResult= tmp;
}

int  main()
{
    //inti
    for (long i=0;i<testDataCount;++ i)
        fSrc[i]=(float)(rand()*(1.0/RAND_MAX)*(rand()-(RAND_MAX>>1))*rand()*(1.0/ RAND_MAX));

    //test
    double start0=(double )clock();    
    for (long c=0;c<testCount;++ c)
        // dftol_test_0();   
        // dftol_test_fpu(); 
        // dftol_test_ieee_MagicNumber();  
        // dftol_test_sse2(); 
        //dftol_test_sse2_expand8(); 
        dftol_test_sse2_expand8_prefetch(); 
    start0=((double)clock()-start0)*(1.0/ CLOCKS_PER_SEC);

    //out
    printf ("  Result = %ud   Seconds = %8.5f " ,testResult,start0);

    return 0 ;
}

H:把测试结果放在一起


//速度测试:  编译器vc2005 CPU为AMD64x2 4200+ 单线程      
//==============================================================================
// ftol_test_0                        1.047 秒  (“/arch:SSE”0.437秒、VC6编译3.64秒)
// ftol_test_fpu                      0.407 秒
// ftol_test_ieee                     0.828 秒
// ftol_test_ieee_MagicNumber         1.813 秒  (4舍5入取整0.407 秒)
// ftol_test_sse                      0.422 秒
// ftol_test_sse_expand16             0.281 秒
// ftol_test_sse_expand16_prefetch    0.219 秒
//==============================================================================秒
//补充double的取整
// dftol_test_0                       1.141 秒  (“/arch:SSE2”0.734秒、VC6编译3.675秒)
// dftol_test_fpu                     0.719 秒
// dftol_test_ieee_MagicNumber        1.688 秒  (4舍5入取整0.703 秒)
// dftol_test_sse2                    0.734 秒
// dftol_test_sse2_expand8            0.609 秒
// dftol_test_sse2_expand8_prefetch   0.516 秒

提示:为了避免浮点数到整数的转换可以考虑用定点数来表示小数，从而在需要取整的时候可
以用一个快速的移位指令来实现


 

housisong
关注
  • 1
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
汇编指令集合
m0_46442521的博客
05-12 395
做个笔记，x86常用的汇编指令 1 通用数据传送指令： MOV 传送字或字节. MOVSX 先符号扩展,再传送. MOVZX 先零扩展,再传送. PUSH 把字压入堆栈. POP 把字弹出堆栈. PUSHA 把AX,CX,DX,BX,SP,BP,SI,DI依次压入堆栈. POPA 把DI,SI,BP,SP,BX,DX,CX,AX依次弹出堆栈. PUSHAD 把EAX,ECX,EDX,EBX,ESP,EBP,ESI,EDI依次压入堆栈. POPAD 把EDI,ES
X87 FPU 指令集
weixin_42043845的博客
11-29 4380
FPU 指令集 (1) FPU 数据传输指令集 fld 将浮点值压入寄存器栈，源操作数可以是ST(i)或内存地址 fild 从内存中读取一个有符号整型操作数，将该值转换为扩展双精度值，并将此结果加载到寄存器栈中 fbld 从内存中读取压缩BCD操作数，将该值转换为一个扩展双精度值，并将结果加载到推栈 fst 拷贝ST(0)到ST(i)或内存位置 fstp 执行与...
汇编指令速查
weixin_33816611的博客
03-16 517
指令功能 AAA调整加 AAD调整除 AAM调整乘 AAS调整减 ADC进位加 ADD加 AND与 ARPL调整优先级 BOUND检查数组 BSF位右扫描 BSR位左扫描 BSWAP交换字节 BT位测试 BTC位测试求反 BTR位测试清零 BTS位测试置一 CALL过程调用 CBW转换字节 CDQ转换双字 CLC进位清零 CLD方向清零 CLI中...
FPU协处理器指令集
程序的专栏
02-28 1621
 FPU协处理器指令集 指令名称 描述 数据转移指令
优化汇编例程（17）
wuhui_gdnt的专栏
10-18 504
17. 特别话题 17.1. XMM与浮点寄存器 具有SSE指令集的处理器可以在XMM寄存器中进行单精度浮点计算。具有SSE2指令集的处理器还可以在XMM寄存器中进行双精度浮点计算。在XMM寄存器与旧式的浮点栈寄存器中，浮点计算几乎一样快。使用浮点栈寄存器ST(0) ~ ST(7)还是XMM寄存器的决定，取决于以下因素。 使用ST()寄存器的好处： 与没有SSE或SSE2的旧式处理器兼容。...
浮点运算的优化
11-26 5753
比如对于代码int x,y;...y=(x+1)+(2*x-2);那么我们很清楚，编译器可以将上面的代码优化为y=3*x-1;//实际上还会优化为y=(x可是如果换成浮点类型呢？比如double x,y;...y=(x+1)+(2*x-2);呢？这时候，标准编译选项下面，编译器不会做任何优化。这个是因为，对于浮点数做的任何优化都是不安全的。比如一个程序中可能会使用while(err+1.0!=1.
c代码-浮点数 浮点计算器
07-16
c代码-浮点数 浮点计算器
S7-200SMART实数-浮点数-批量传送-库文件+使用说明.zip
02-07
S7-200SMART实数_浮点数_批量传送_库文件+使用说明
代码优化之条件分支预测、除法、浮点数取整
11-28
如何提高代码执行速度？ 分别对常用的分支指令预测、除法和浮点取整运算进行详细演说。
Floating Point Optimization(ARM 浮点优化方案)
DriverMonkey的专栏
09-22 2773
Floating Point Optimization 目录  [隐藏]  1 Introduction2 Compiler Support3 VFP-Lite RunFast4 Single Precision Floating Point5 NFP / VFP to ARM Transfers6 NEON SIMD7 Summary
浮点运算和代码优化, 音频常识, 并行计算
antkillerfarm的专栏
06-14 5246
浮点运算和代码优化, 音频常识, 并行计算
float数据在计算机内存中的存储方法
guqsir的专栏
11-26 2178
转自： http://www.utou.net/trackback.asp?tbID=54 浮点型变量在计算机内存中占用4字节（Byte）,即32-bit。遵循IEEE-754格式标准。 一个浮点数由2部分组成：底数m 和 指数e。   ±mantissa × 2exponent （注意，公式中的mantissa 和 exponent使用二进制表示） 底数部分　使用２进制
float 与 double 的优化测试
为自己拷贝,为别人集锦
11-18 923
using System; namespace speed { class Program { static void Main(string[] args) { int i, j; float f1 = 7.125f, f2 = 7.125f; double d1 = 7.1
C++ 中的浮点代码优化
Nhsoft的专栏
11-22 5201
原 作 者：MS原 出 处：enet发 布 者：loose_went发布类型：转载C++ 优化编译器不仅能够将源代码转换为机器码，而且能够对机器指令进行适当的排列以便改善性 能和/或减小大小。遗憾的是，许多常用的优化在应用于浮点计算时未必安全。在下面的求和算法 [1] 中，可以看到这方面的一个恰当的示例：float KahanSum( const float A[], int n
C语言 使用数组索引与指针索引 在循环中对编译器优化的影响及耗时分析
星空千代
11-11 2087
C语言在访问数组时既可以使用如a[i]这样的下标方式，也可以使用*(a+i)这样的指针方式，理论上完全等价。但是在编译器对循环作优化时，对于指针方式的索引很有可能分析不彻底，因此相比数组索引耗时有所增加 数组索引耗时 #include <stdio.h> #include <stdlib.h> #include <time.h> unsigned long get_start_ms() { struct timespec ts; clock_gett.
任鸟飞逆向C++进阶篇
09-07
【课程简介】本课程为任鸟飞逆向C++进阶篇，注重基础理论的务实和简单功能的实现，学员学成后，可独立判断、分析和解决逆向问题、独立编写通用辅助。本套课程不只是一套深入学习C++的课程，更是一套深入学习汇编逆向课程、外挂与反外挂、软件安全的课程。逆向思路技术随笔，请关注我的CSDN博客：https://blog.csdn.net/qq_36553941 欢迎大家来学习交流，活动折扣等信息也在其第一时间发布。PS: 课程中工具包、源码、课件请关注第一章的第一节的随课课件，工欲望善其事，必先利其器！ 【学前预备知识】任鸟飞逆向C++系列课程是一条精心安排为掌握汇编逆向、外挂与反外挂、软件安全的学习路线，包括但不限于 基础篇、进阶篇（本篇）、高级篇、实战篇等，所以为保证您能学有所成请在学习本篇之前务必掌握基础篇！！！基础篇CSDN学院链接：https://edu.csdn.net/course/detail/30509 【学员学成收获】1、C++编程语言进阶。2、游戏逆向分析进阶。3、游戏安全对抗理论进阶。4、独立编写通用辅助。 
linux浮点数取整
最新发布
10-26
在Linux中，浮点数取整可以使用以下函数： 1. ceil(x)：返回不小于x的最小整数值，即向上取整。 2. floor(x)：返回不大于x的最大整数值，即向下取整。 3. round(x)：返回最接近x的整数值，如果x恰好在两个整数中间，则返回偶数的那个整数。 4. trunc(x)：返回x的整数部分，即去掉小数部分。 这些函数都在math.h头文件中定义。需要注意的是，这些函数的参数和返回值都是double类型。如果需要对float类型进行取整操作，需要先将其转换为double类型再进行操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值