定点运算及最优三角函数算法（不使用浮点计算）精度18位二进制小数

最新推荐文章于 2023-04-05 22:34:58 发布
最新推荐文章于 2023-04-05 22:34:58 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 算法 C/C++ 文章标签： 定点运算 sin cos
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_25675517/article/details/103101225
版权

内嵌汇编代码：

#include "r_math.h"

/**
 * 以下所有函数都是对定点型的运算，该定点型的值乘以10000再以整型来存储。
 */

/**
 * 将real转化为int，得到其整数部分。
 */
__declspec(naked) int __fastcall r_int(real i)
{
    _asm{
        mov edx,ecx;
        sar edx,31;
        and edx,9999;
        add ecx,edx;
        mov eax,1759218605;
        imul ecx;
        sar edx,12;
        mov eax,edx;
        ret;
    }
}

/**
 * 将real向下舍入到int，得到最接近且不大于的数。
 */
__declspec(naked) int __fastcall r_INT(real i)
{
    _asm{
        mov eax,1759218605;
        imul ecx;
        sar edx,12;
        mov eax,edx;
        ret;
    }
}

/**
 * 将ureal转化为unsigned int，得到其整数部分。
 */
__declspec(naked) unsigned int __fastcall r_int(ureal i)
{
    _asm{
        mov eax,3518437209;
        mul ecx;
        shr edx,13;
        mov eax,edx;
        ret;
    }
}

/**
 * 得到real的尾数，与r_int(real)配合使用。
 */
__declspec(naked) int __fastcall r_pot(real i)
{
    _asm{
        mov edx,ecx;
        sar edx,31;
        and edx,9999;
        add edx,ecx;
        mov eax,1759218605;
        imul edx;
        sar edx,12;
        imul edx,-10000;
        lea eax,[ecx+edx];
        ret;
    }
}

/**
 * 得到real的尾数的绝对值，值为abs(r_pot(real))。
 */
__declspec(naked) int __fastcall abs_pot(real i)
{
    _asm{
        mov edx,ecx;
        sar edx,31;
        and edx,9999;
        add edx,ecx;
        mov eax,1759218605;
        imul edx;
        sar edx,12;
        imul edx,-10000;
        lea eax,[ecx+edx];
        cdq;
        xor eax,edx;
        sub eax,edx;
        ret;
    }
}

/**
 * 得到real的尾数，与r_INT(real)配合使用，结果必非负。
 */
__declspec(naked) int __fastcall r_POT(real i)
{
    _asm{
        mov eax,1759218605;
        imul ecx;
        sar edx,12;
        imul edx,-10000;
        lea eax,[ecx+edx];
        ret;
    }
}

/**
 * 得到ureal的尾数，与r_int(ureal)配合使用。
 */
__declspec(naked) unsigned int __fastcall r_pot(ureal i)
{
    _asm{
        mov eax,3518437209;
        mul ecx;
        shr edx,13;
        imul edx,-10000;
        lea eax,[ecx+edx];
        ret;
    }
}

/**
 * 分离real的整数部分和尾数部分，返回值r_int(real)，尾数放在EDX上。
 */
__declspec(naked) int __fastcall r_spt(real i)
{
    _asm{
        mov edx,ecx;
        sar edx,31;
        and edx,9999;
        add edx,ecx;
        mov eax,1759218605;
        imul edx;
        sar edx,12;
        mov eax,edx;
        imul edx,-10000;
        add edx,ecx;
        ret;
    }
}

/**
 * 分离real的整数部分和尾数部分，返回值r_INT(real)，尾数放在EDX上。
 */
__declspec(naked) int __fastcall r_SPT(real i)
{
    _asm{
        mov eax,1759218605;
        imul ecx;
        sar edx,12;
        mov eax,edx;
        imul edx,-10000;
        add edx,ecx;
        ret;
    }
}

/**
 * 分离ureal的整数部分和尾数部分，返回值r_int(ureal)，尾数放在EDX上。
 */
__declspec(naked) unsigned int __fastcall r_spt(ureal i)
{
    _asm{
        mov eax,3518437209;
        mul ecx;
        shr edx,13;
        mov eax,edx;
        imul edx,-10000;
        add edx,ecx;
        ret;
    }
}

/**
 * 返回a乘以b的值。
 */
__declspec(naked) real __fastcall r_mul(real a,real b)
{//四舍五入
    _asm{
        push esi;
        push edi;
        mov eax,edx;
        xor edx,ecx;
        sar edx,31;
        mov edi,edx;
        xor eax,edx;
        sub eax,edx;
        imul ecx;
        //add eax,5000;
        //adc edx,0;
        mov ecx,eax;
        mov eax,3518437209;
        mov esi,edx;
        mul edx;
        shr edx,13;
        imul edx,-10000;
        add esi,edx;
        push esi;
        imul esi,7296;
        add ecx,esi;
        sbb esi,esi;
        mov eax,3518437209;
        and esi,eax;
        mul ecx;
        pop eax;
        imul eax,429496;
        add edx,esi;
        shr edx,13;//不必考虑CF
        adc eax,edx;
        xor eax,edi;
        sub eax,edi;
        pop edi;
        pop esi;
        ret;
    }
    /*_asm{
        push ebx;
        push esi;
        push edi;
        mov eax,edx;
        cdq;
        xor eax,edx;
        sub eax,edx;
        mov ebx,ecx;
        sar ecx,31;
        xor ebx,ecx;
        sub ebx,ecx;
        xor ecx,edx;
        mul ebx;
        add eax,5000;
        adc edx,0;
        mov ebx,eax;
        mov eax,3518437209;
        mov esi,edx;
        mul edx;
        shr edx,13;
        imul edx,-10000;
        add esi,edx;
        imul edi,esi,429496;
        imul esi,7296;
        add ebx,esi;
        sbb esi,esi;
        and esi,3518437209;
        mov eax,3518437209;
        mul ebx;
        add edx,esi;
        shr edx,13;//不必考虑CF
        lea eax,[edi+edx];
        xor eax,ecx;
        sub eax,ecx;
        pop edi;
        pop esi;
        pop ebx;
        ret;
    }*/
}

/**
 * 返回a乘以b的值。
 */
__declspec(naked) ureal __fastcall r_mul(ureal a,ureal b)
{//四舍五入
    _asm{
        push ebx;
        mov eax,edx;
        mul ecx;
        mov ecx,eax;
        mov eax,3518437209;
        mov ebx,edx;
        mul edx;
        shr edx,13;
        imul edx,-10000;
        add ebx,edx;
        push ebx;
        imul ebx,7296;
        add ecx,ebx;
        sbb ebx,ebx;
        mov eax,3518437209;
        and ebx,eax;
        mul ecx;
        pop eax;
        imul eax,429496;
        add edx,ebx;
        shr edx,13;//不必考虑CF
        adc eax,edx;
        pop ebx;
        ret;
    }
    /*_asm{
        push ebx;
        mov eax,edx;
        mul ecx;
        add eax,5000;
        adc edx,0;
        mov ecx,eax;
        mov eax,3518437209;
        mov ebx,edx;
        mul edx;
        shr edx,13;
        imul edx,-10000;
        add ebx,edx;
        push ebx;
        imul ebx,7296;
        add ecx,ebx;
        sbb ebx,ebx;
        mov eax,3518437209;
        and ebx,eax;
        mul ecx;
        add edx,ebx;
        shr edx,13;//不必考虑CF
        pop eax;
        imul eax,429496;
        add eax,edx;
        pop ebx;
        ret;
    }*/
}

/**
 * 返回a除以b的值。
 */
__declspec(naked) real __fastcall r_div(real a,real b)
{
    _asm{
        xchg ecx,edx;
        mov eax,20000;
        imul edx;
        idiv ecx;
        sar eax,1;
        adc eax,0;
    }
    /*_asm{
        push ebx;
        xchg ecx,edx;
        mov eax,10000;
        imul edx;
        idiv ecx;
        lea ebx,[edx+edx];
        sar edx,31;
        xor ebx,edx;
        sub ebx,edx;
        mov edx,ecx;
        sar edx,31;
        xor ecx,edx;
        #if 1 //四舍五入
        lea ebx,[ebx+edx+1];
        #else //过五则入
        sub ecx,edx;
        #endif
        sub ecx,ebx;
        shr ecx,31;
        cdq;
        xor ecx,edx;
        sub ecx,edx;
        add eax,ecx;
        pop ebx;
        ret;
    }*/
}

/**
 * 返回a除以b的值。
 */
__declspec(naked) ureal __fastcall r_div(ureal a,ureal b)
{
    _asm{
        xchg ecx,edx;
        mov eax,20000;
        mul edx;
        div ecx;
        shr eax,1;
        adc eax,0;
    }
    /*_asm{
        xchg ecx,edx;
        mov eax,10000;
        mul edx;
        div ecx;
        shl edx,1;
        #if 1 //四舍五入
        sub edx,ecx;
        shl edx,1;
        sbb eax,-1;
        #else //过五则入
        sub ecx,edx;
        shr ecx,31;
        add eax,ecx;
        #endif
        ret;
    }*/
}

real strtor(char *numstr,char **errpos)
{
    int ch;
    int i,b;
    i=strtol(numstr,&numstr,10);
    if(*numstr!='.')
    {
        if(errpos!=NULL)*errpos=numstr;
        return i*10000;
    }
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)
    {
        if(errpos!=NULL)*errpos=numstr;
        return i*10000;
    }
    b=ch*1000;
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)goto STRTOREAL_END;
    b+=ch*100;
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)goto STRTOREAL_END;
    b+=ch*10;
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)goto STRTOREAL_END;
    b+=ch;
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)goto STRTOREAL_END;
    b-=(4-ch)>>31;
STRTOREAL_END:
    if(errpos!=NULL)*errpos=numstr;
    ch=i>>31;
    b^=ch;
    b-=ch;
    return i*10000+b;
}

ureal strtour(char *numstr,char **errpos)
{
    int ch;
    unsigned int i,b;
    i=strtoul(numstr,&numstr,10);
    if(*numstr!='.')
    {
        if(errpos!=NULL)*errpos=numstr;
        return i*10000;
    }
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)
    {
        if(errpos!=NULL)*errpos=numstr;
        return i*10000;
    }
    b=ch*1000;
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)goto STRTOREAL_END;
    b+=ch*100;
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)goto STRTOREAL_END;
    b+=ch*10;
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)goto STRTOREAL_END;
    b+=ch;
    numstr++;
    ch=*numstr;
    ch-='0';
    if((ch^(ch-10))>0)goto STRTOREAL_END;
    b-=(4-ch)>>31;
STRTOREAL_END:
    if(errpos!=NULL)*errpos=numstr;
    return i*10000+b;
}

real sine_rn(real a,int rn,double t)
{//t=121.4375,rn=18最佳
    long long a2=a;
    a2*=a;
    a2=((a2+(1<<(rn-1)))>>rn);
    long long a3=a2;
    a3*=a;
    long long a5=((a3+(1<<(rn-1)))>>rn);
    if(a<0)a3-=3LL<<rn;
    else a3+=3LL<<rn;
    long long b4=6LL<<rn;
    b4=a3/b4;
    a5*=a2;
    if(a<0)a5-=(long long)((1<<(rn-1))*t);
    else a5+=(long long)((1<<(rn-1))*t);
    long long b6=(long long)((1<<rn)*t);
    b6=a5/b6;
    return a-(int)b4+(int)b6;
}
/*
__declspec(naked) real __fastcall sine(real a)
{//计算sin的值，采用二进制18位小数的定点数，参数a<=205888/(2^18).
    _asm{
        push ebx;
        mov eax,ecx;
        sar ecx,31;
        xor eax,ecx;
        sub eax,ecx;
        push ecx;
        mov ebx,eax;//abs(a)
        mul ebx;
        shl edx,14;
        shr eax,18;
        adc eax,edx;//a*a>>18
        mov DWORD PTR [esp-4],eax;//a2
        mul ebx;
        shl edx,14;
        shr eax,18;
        adc edx,eax;//a*(a*a>>18)>>18
        mov ecx,edx;//a3
        mov eax,0x2AAAAAAB;
        mul edx;
        mov eax,ecx;
        mov ecx,edx;//b4
        mul DWORD PTR [esp-4];
        shl edx,29;
        shr eax,3;
        adc eax,edx;
        mov edx,0x86F3D980;//未确定此值及范围0x86FCAECA
        mul edx;
        shr edx,21;//b6
        lea eax,[ebx+edx];
        sub eax,ecx;
        pop ecx;
        xor eax,ecx;
        sub eax,ecx;
        pop ebx;
        ret;
    }
}
*/
__declspec(naked) real __stdcall sine(real a)
{//已优化为最优算法，计算sin的值，采用二进制18位小数的定点数，参数a<=205888/(2^18).
    _asm{
        mov eax,DWORD PTR [esp+4];
        imul eax;
        shl edx,28;
        shr eax,4;
        adc eax,edx;//a*a>>4
        mov ecx,eax;
        mul ecx;//edx=(a*a>>4)*(a*a>>4)>>32
        mov eax,0x86E0D052;//？此值未确定
        mul edx;//edx=a*a*a*a*0x86F3D980>>72
        xchg ecx,edx;//(ecx>>20)<<(30-18),b6
        mov eax,0xAAAAAAAB;
        mul edx;//edx=(a*a>>4)*2/3=(a*a>>3)/3,(edx>>16)<<(30-18),b4
        shr ecx,4;
        sbb edx,ecx;
        mov eax,1<<30;
        shr edx,4;
        sbb eax,edx;
        imul DWORD PTR [esp+4];
        shl edx,2;
        shr eax,30;
        adc eax,edx;
        ret 4;
    }
}

__declspec(naked) real __stdcall test_sine(real a,unsigned int t)
{//测试参数t并计算其sin的值，采用二进制18位小数的定点数，参数a<=205888/(2^18).
    _asm{
        mov eax,DWORD PTR [esp+4];
        imul eax;
        shl edx,28;
        shr eax,4;
        adc eax,edx;//a*a>>4
        mov ecx,eax;
        mul ecx;//edx=(a*a>>4)*(a*a>>4)>>32
        mov eax,DWORD PTR [esp+8];//？此值未确定
        mul edx;//edx=a*a*a*a*0x86F3D980>>72
        xchg ecx,edx;//(ecx>>20)<<(30-18),b6
        mov eax,0xAAAAAAAB;
        mul edx;//edx=(a*a>>4)*2/3=(a*a>>3)/3,(edx>>16)<<(30-18),b4
        shr ecx,4;
        sbb edx,ecx;
        mov eax,1<<30;
        shr edx,4;
        sbb eax,edx;
        imul DWORD PTR [esp+4];
        shl edx,2;
        shr eax,30;
        adc eax,edx;
        ret 8;
    }
}

real cose_rn(real a,int rn,double t)
{//t=724.5,rn=18最佳
    unsigned long long a2,b2,a4,b4,a6,b6;
    a2=(long long)a*(long long)a;
    b2=(a2+(1<<rn))/(1<<(rn+1));
    a2=((a2+(1<<(rn-1)))>>rn);
    a4=a2*a2;
    b4=24*(1<<rn);
    b4=(a4+12*(1<<rn))/b4;
    a4=((a4+(1<<(rn-1)))>>rn);
    a6=a4*a2;
    a6+=(unsigned long long)((1<<(rn-1))*t);
    b6=(unsigned long long)((1<<rn)*t);
    b6=a6/b6;
    return (1<<rn)-(int)b2+(int)b4-(int)b6;
}
/*
__declspec(naked) real __fastcall cose(real a)
{//计算cos的值，采用二进制18位小数的定点数，参数a<=205888/(2^18).
    _asm{
        push ebx;
        mov eax,ecx;
        imul ecx;
        shl edx,13;
        lea ecx,[edx+edx];
        shr eax,18;
        adc ecx,eax;//a2=a*a>>18
        shr eax,1;
        adc edx,eax;//b2=a*a>>19
        mov DWORD PTR [esp-4],edx;//b2
        mov eax,ecx;
        mul ecx;
        shl edx,14;
        shr eax,18;
        lea ebx,[eax+edx];//a4=(a*a>>18)*(a*a>>18)>>18
        mov eax,0x0AAAAAAB;
        mul ebx;
        xchg edx,ecx;//a2
        mov eax,ebx;
        mul edx;
        shl edx,30;
        shr eax,2;
        adc eax,edx;
        mov edx,0xB4689F20;//取值范围[0XB44F31AD,0XB44F3512]
        mul edx;
        shr edx,25;
        sub ecx,edx;
        lea eax,[ecx+(1<<18)];
        sub eax,DWORD PTR [esp-4];
        pop ebx;
        ret;
    }
}
*/
__declspec(naked) real __fastcall cose(real a)
{//已优化为最优算法，计算cos的值，采用二进制18位小数的定点数，参数a<=205888/(2^18).
    _asm{
        mov eax,ecx;
        imul ecx;
        shl edx,28;
        shr eax,4;
        adc eax,edx;//a2=a*a>>4
        //push eax;//b2=eax>>15
        mov DWORD PTR [esp-4],eax;
        mov ecx,eax;
        mul ecx;
        mov eax,edx;//a4=(a*a>>4)*(a*a>>4)>>32
        xchg ecx,edx;
        mul edx;
        mov eax,0xB46A73F7;//取值范围[0XB44F31AD,0XB44F3512]
        mul edx;
        xchg ecx,edx;
        mov eax,0xAAAAAAAB;
        mul edx;
        //ecx=30bit,edx=31bit,eax=32bit
        //pop eax;
        //shr eax,15;
        //shr edx,18;
        //shr ecx,23;
        shr ecx,5;
        sbb edx,ecx;
        shr edx,3;
        //不舍入以减少指令
        sub edx,DWORD PTR [esp-4];
        shr edx,15;
        adc edx,1<<17;
        mov eax,edx;
        /*
        mov ecx,DWORD PTR [esp-4];
        sbb ecx,edx;
        shr ecx,15;
        mov eax,1<<18;
        sbb eax,ecx;
        */
        ret;
    }
}

__declspec(naked) real __fastcall test_cose(real a,unsigned int t)
{//测试参数t并计算其cos的值，采用二进制18位小数的定点数，参数a<=205888/(2^18).
    _asm{
        mov DWORD PTR [esp-8],edx;
        mov eax,ecx;
        imul ecx;
        shl edx,28;
        shr eax,4;
        adc eax,edx;//a2=a*a>>4
        //push eax;//b2=eax>>15
        mov DWORD PTR [esp-4],eax;
        mov ecx,eax;
        mul ecx;
        mov eax,edx;//a4=(a*a>>4)*(a*a>>4)>>32
        xchg ecx,edx;
        mul edx;
        mov eax,DWORD PTR [esp-8];//取值范围[0XB44F31AD,0XB44F3512]
        mul edx;
        xchg ecx,edx;
        mov eax,0xAAAAAAAB;
        mul edx;
        //ecx=30bit,edx=31bit,eax=32bit
        //pop eax;
        //shr eax,15;
        //shr edx,18;
        //shr ecx,23;
        shr ecx,5;
        sbb edx,ecx;
        shr edx,3;
        //不舍入以减少指令
        sub edx,DWORD PTR [esp-4];
        shr edx,15;
        adc edx,1<<17;
        mov eax,edx;
        /*
        mov ecx,DWORD PTR [esp-4];
        sbb ecx,edx;
        shr ecx,15;
        mov eax,1<<18;
        sbb eax,ecx;
        */
        ret;
    }
}

头文件如下：

#include <stdlib.h>

#define r_set(a,b) ((a)*10000+(b))
#define r_add(a,b) ((a)+(b))
#define r_sub(a,b) ((a)-(b))

#define rn_set(a,b,n) (((a)<<(n))+(b))
#define rn_int(i,n) ((i)>>(n))
#define rn_pot(i,n) ((unsigned int)((i)<<(32-(n)))>>(32-(n)))
#define ri_int(i,n) (((int)(((unsigned int)((int)(i)>>31)>>(32-(n)))+(i))>>(n)))
#define iabs_pot(i,n) abs(ri_pot(i,n))
#define abs(i) (((i)^((int)(i)>>31))-((int)(i)>>31))
#define ri_pot(i,n) ((i)-((((unsigned int)((int)(i)>>31)>>(32-(n)))+(i))&((-1)<<(n))))
#define ri_pot2(i,n) (((((unsigned int)((int)(i)>>31)>>(32-(n)))+(i))&((unsigned int)(-1)>>(32-(n))))-((unsigned int)((int)(i)>>31)>>(32-(n))))

#define rn_mul(c,a,b,n) /*至半则入（类似四舍五入）*/\
    __asm mov eax,a \
    __asm mov edx,b \
    __asm mul edx \
    __asm shl edx,32-(n) \
    __asm shr eax,n \
    __asm adc eax,edx \
    __asm mov c,eax

#define rn_imul(c,a,b,n) /*至半则入*/\
    __asm mov eax,a \
    __asm mov edx,b \
    __asm imul edx \
    __asm shl edx,32-(n) \
    __asm shr eax,n \
    __asm adc eax,edx \
    __asm mov c,eax

#define rn_div(c,a,b,n) /*至半则入*/\
    __asm mov eax,a \
    __asm mov ecx,b \
    __asm mov edx,eax \
    __asm shr edx,31-(n) \
    __asm shl eax,(n)+1 \
    __asm div ecx \
    __asm sar eax,1 \
    __asm adc eax,0 \
    __asm mov c,eax \
    //__asm mov eax,a \
    __asm mov edx,eax \
    __asm shl eax,n \
    __asm shr edx,32-(n) \
    __asm mov ecx,b \
    __asm div ecx \
    __asm shl edx,1 \
    __asm sub edx,ecx __asm shl edx,1 __asm sbb eax,-1 \
    /*__asm sub ecx,edx __asm shr ecx,31 __asm add eax,ecx \*/\
    __asm mov c,eax

#define rn_idiv(c,a,b,n) /*至半则入*/\
    __asm mov eax,a \
    __asm mov ecx,b \
    __asm mov edx,eax \
    __asm shr edx,31-(n) \
    __asm shl eax,(n)+1 \
    __asm idiv ecx \
    __asm sar eax,1 \
    __asm adc eax,0 \
    __asm mov c,eax \
    //__asm mov eax,a \
    __asm mov edx,eax \
    __asm shl eax,n \
    __asm sar edx,32-(n) \
    __asm mov ecx,b \
    __asm idiv ecx \
    __asm push eax \
    __asm lea eax,[edx+edx] \
    __asm sar edx,31 \
    __asm xor eax,edx \
    __asm sub eax,edx \
    __asm mov edx,ecx \
    __asm sar edx,31 \
    __asm xor ecx,edx \
    __asm lea eax,[eax+edx+1] \
    /*__asm sub ecx,edx */\
    __asm sub ecx,eax \
    __asm shr ecx,31 \
    __asm pop eax \
    __asm cdq \
    __asm xor ecx,edx \
    __asm sub ecx,edx \
    __asm add eax,ecx \
    __asm mov c,eax

typedef int real;
typedef unsigned int ureal;

int __fastcall r_int(real i);
int __fastcall r_INT(real i);
unsigned int __fastcall r_int(ureal i);
int __fastcall r_pot(real i);
int __fastcall abs_pot(real i);
int __fastcall r_POT(real i);
unsigned int __fastcall r_pot(ureal i);
int __fastcall r_spt(real i);
int __fastcall r_SPT(real i);
unsigned int __fastcall r_spt(ureal i);

real __fastcall r_mul(real a,real b);
ureal __fastcall r_mul(ureal a,ureal b);
real __fastcall r_div(real a,real b);
ureal __fastcall r_div(ureal a,ureal b);

real strtor(char *numstr,char **errpos);
ureal strtour(char *numstr,char **errpos);


real sine_rn(real a,int rn,double t);
real __stdcall sine(real a);
real __stdcall test_sine(real a,unsigned int t);

real cose_rn(real a,int rn,double t);
real __fastcall cose(real a);
real __fastcall test_cose(real a,unsigned int t);

 

 

 

 

 

一念之卓
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现sin函数(附完整源码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-20 1449
C语言实现sin函数(附完整源码)
查表法实现三角函数
06-06
这是一份用查表法实现三角函数的文档，欢迎下载
钱晓捷《32位汇编语言程序设计》第四章习题与代码解析
m0_46339652的博客
05-04 3593
目录4.15 EAX符号扩展到EDX4.17 输入输出0～9数字 4.15 EAX符号扩展到EDX IA-32处理器的指令CDQ将EAX符号扩展到EDX。假若没有该指令，编程实现该指令功能。 （1）按照符号扩展的含义编程，即：EAX最高为0，则EDX＝0；EAX最高为1，则EDX＝FFFFFFFFH。 程序代码： include io32.inc .data plmsg byte 'Input Number:' ,13,10,0 .code start: mov eax,offset
三角函数计算，Cordic 算法入门
SmartCar的博客
01-28 1349
三角函数的计算是个复杂的主题，有计算机之前，人们通常通过查找三角函数表来计算任意角度的三角函数的值。这种表格在人们刚刚产生三角函数的概念的时候就已经有了，它们通常是通过从已知值（比如sin(π/2)=1）开始并重复应用半角和和差公式而生成。 现在有了计算机，三角函数表便推出了历史的舞台。但是像我这样的喜欢刨根问底的人，不禁要问计算机又是如何计算三角函数值的呢。最容易想到的办法就是利用级数展开，比如泰勒级数来逼近三角函数，只要项数取得足够多就能以任意的精度来逼近函数值。除了泰勒级数逼近之外，还有其他许.
C语言正余弦函数定点查表算法原理及实现
主要分享硬件、嵌入式软件部分知识
04-24 1万+
如果用数学库中的sin和cos函数计算，可能涉及浮点、乘法、除法运算，运行速率较低。这里介绍一种正余弦查表算法。 参考代码：SMT32 FOC电机库的mc_math.c。 首先我们知道正弦和余弦的函数值差了90°，所以查表数据只需要保存正弦或者余弦的结果即可。待计算的角度范围为[0,2π]，我们只需要保存的角度，其它象限的角度通过三角函数公式变换一下即可。 （1）正余弦表格生成 第一步当然是保存范围内正余弦函数的值，保存的越多计算结果越精确，但又消耗更多的存储空间。在STM32电机库中采用int16.
C语言sin函数实现（基于泰勒公式）
豆蔻梦的博客
04-05 8713
单片机如果不调用库，只进行加减运算，亦或宽泛点来说能进行加减乘除运算，那不调用库如何进行三角函数的计算呢？由于展开式中，项数有无数个，而代码在实际运行中进行无限次计算会没有尽头，这时候我们需要设定一个常量，当。三种算数运算，便能求出它的函数值来，因此我们常用多项式来近似表达函数。项数越多，展开式就会越接近原函数，所以这个常量。也就是说，多项式下一项都可由当前项计算出来，由于用多项式表示的函数，只要对自变量进行。角度是有单位的，弧度是没有单位的，，而我们输入的为角度，故需要将。把每一项加起来，就是。
单片机与DSP中的ADSP TigerSHARC中利用查找表快速计算三角函数
12-13
摘要：DSP算法中，三角函数的计算是一种运算量比较大，占用时间比较长的运算。如果通过直接调用DSP生产商或者第三方提供的库函数进行运算，往往需要占用比较多的时钟周期。在实时性要求比较高的场合，调用库函数进行...
DSP中浮点转定点运算--定点数模拟浮点数运算及常见的策略
09-02
此外，进行浮点到定点转换时，还需关注数据类型的表示（如固定点或二进制小数点位置）、舍入模式和溢出处理等细节问题。 总结来说，定点数模拟浮点数运算需要灵活运用各种策略，包括除法到乘法的转换、查表计算、...
应用笔记LAT1357+利用Cordic计算浮点三角函数
最新发布
03-15
当前 STM32G4 系列以及 STM32H723 中虽然有专门计算三角函数的硬件 CORDIC，但目前是定点的 CORDIC 硬件，很多实际应用，比如电机控制，数字电源，客户整个软件代码是基于浮点的运算，因此有必要对如何利用 CORDIC ...
labview_32位单精度浮点数转定点小数
05-28
labview_32位单精度浮点数转定点小数，亲测可用(Own use labview to build 32-bit single precision floating point decimal turn, pro-test available)
定点原码二位乘法器的设计计算机组成原理课程设计
05-07
定点原码二位乘法器是一种数字乘法器，使用定点原码表示数字，实现二位乘法运算。它是计算机组成原理课程设计的重要组成部分，涉及数字电路、逻辑设计、计算机组织等方面的知识。 3. 设计原理 设计原理是指在设计...
C语言程序设计-sin()和COS()
qq_41961173的博客
09-06 2026
1.C 标准库 - <math.h> C 库函数double sin(double x)返回弧度角x的正弦 声明 下面是 sin() 函数的声明。 double sin(double x) 返回值 该函数返回 x 的正弦 实例 下面的实例演示了 sin() 和COS()函数的用法。 #include <stdio.h> #incl...
C语言实现sin函数的程序设计
热门推荐
m0_66345031的博客
03-26 1万+
一、问题描述 对给定的x计算出相应的的值 二、问题分析 用Taylor公式将展开，其形式如下： 设 那么，并且有如下关系： 根据上面各项的关系，可以看出，前一项的运算结果可以参与下一项的运算（条件的递归化处理），从而减少计算的次数，提高效率。由于sinx是周期函数，故可将化为来处理，即使用角度作为运算的度量。 ...
16.3求sin值的程序
njutyangxiao的专栏
09-15 1452
编写一个子程序，计算sin(x)。并在屏幕中间显示结果。源代码：assume cs:codesgcodesg segmentstart: mov al,60 call showsin mov ax,4c00h int 21hshowsin: jmp short show
python材料计算公式_python sinx计算公式
weixin_31916045的博客
01-12 1449
【问题描述】已知sinx的近似计算公式如下：sin x = x - x3/3! + x5/5! - x7/7! + ... + (-1)n-1x2n-1/(2n-1)!其中x为弧度，n为正整数。编写程序根据用户输入的x和n的值，利用上述近似计算公式计算sinx的近似值，要求输出结果小数点后保留8位。【输入形式】从控制台输入小数x(0<=x<=20)和整数n(1<=n<=50...
定点数运算（乘以10000方式）（二）
东北砍王的栖息地
01-12 366
继续上一篇的内容：传送门 1.显式/隐式转换 在项目内无缝接入定点数，就需要支持其与float、int等常用类型进行计算 如下演示： float a = 0.1f; int b = 3; float result = a * b; //如果支持转换的话，可以快速修改代码 FP a = (FP) 0.1f;//(FP) 是编辑器自动加的，写出来只是为了演示 int b = 3; FP result = a * b; 这里逻辑比较简单，但是如果是项目内复杂的逻辑，只需要把【float】替换成【FP】就好
[Math]Audio开发中定点的sin函数实现和评测
Water's Space
02-02 911
在音频开发中经常会使用到sin这个函数，例如产生一个1KHz的纯音就会用到sin(2*pi*fc*n/fs)。但是在嵌入式系统或者linux kernel开发或者DSP开发中经常会有Fixed point开发需求，这样就不呢使用系统浮点函数库，就得自己来实现fixed point sin函数了。
定点数的表示与运算
yinbanghui_2019的博客
08-13 615
文章目录1. 定点整数1.1. 补码$x_Nx_{N-1}\cdots x_0$表示的数$x$是多大？1.2. 数$x$怎么表示为补码1.3. 二补码与反码的关系2. 定点小数2.1. ref [2] p262.2. 补码$x_0.x_1x_2\cdots x_{N-1}$表示的小数$x$是多大？3. 定点数3.1. 补码$y_M\cdots y_1y_0.x_1x_2\cdots x_{N-1}$表示的定点数$x$是多大？4. 补码减法4.1. 补码加法公式4.2. 补码减法公式4.2.1. $X=-1,
verilog存小数_FPGA定点小数计算（Verilog版）第二篇——乘法运算
05-28
针对您提到的FPGA定点小数计算（Verilog版）中的乘法运算，可以使用Verilog中的乘法运算符“*”来实现。例如，如果要计算两个定点数x和y的乘积，可以使用以下代码： ```verilog reg signed [15:0] x, y; // 定义16...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值