maths.c

快速傅立叶变化的fft算法的C语言实现。

#include "include.h"

/**********************************************
函数名:  unsigned int Sqrt(unsigned long M)     

输入参数：
	unsigned long M--被开方数，长整型

输出参数:	无

返回值:
	unsigned int--开方结果，整形

功能说明:	长整形数开方处理
**********************************************/ 
unsigned int Sqrt(unsigned long M)
{ 
    unsigned int N, i; 
    unsigned long tmp, ttp;   /*   结果、循环计数	  */
	unsigned char flag = 0; 
    if (M == 0)               /* 被开方数，开方结果也为0  */
        return 0; 

	if (M>0x3FF001)
	{

	    M >>= 2;
		flag = 1;
	}

    N = 0; 

    tmp = (M >> 30);          /* 获取最高位：B[m-1] */
    M <<= 2; 
    if (tmp > 1)              /*  最高位为1 */
    { 
        N ++;                 /* 结果当前位为1，否则为默认的0 */
        tmp -= N; 
    } 

    for (i=15; i>0; i--)      /* 求剩余的15位 */
    { 
        N <<= 1;              /* 左移一位 */

        tmp <<= 2; 
        tmp += (M >> 30);     /* 假设 */

        ttp = N; 
        ttp = (ttp<<1)+1; 

        M <<= 2; 
        if (tmp >= ttp)       /* 假设成立 */
        { 
            tmp -= ttp; 
            N ++; 
        } 

    } 

	if (flag)
        N <<= 1;

    return N; 
}

/*长整型开方，返回浮点值*/
double lSqrt(unsigned long M )
{
	unsigned int scale;

	scale = 1;

	if ( M == 0)
		return 0;

	if ( M < 0xffff )
	{
		M *= 0x10000;
		scale = 0x100;
	}

	while ( M < 0x3fffffff )
	{
		M <<= 2;
		scale <<=1;
	}
	
	return ( ( double )Sqrt( (unsigned long) M ) / scale );
}

/*浮点数的开方运算*/
double fSqrt(double M)
{
	unsigned long scale;

	scale = 1;
	if ( M < 0.000001 )
		return 0;

	if ( M < 0xff )
	{
		M *= 0x1000000;
		scale *= 0x1000;
	}
	
	if ( M < 0xffff )
	{
		M *= 0x10000;
		scale *= 0x100;
	}

	while ( M < 0x3fffffff )
	{
		M *= 4 ;
		scale *= 2 ;
	}
	
	return ( ( double )Sqrt( (unsigned long) M ) / scale );
}



/*************************************************************
函数名: 	long lround()                         

输入参数:
	long div--被除数，长整形
	long by--除数，长整形

输出参数:	无

返回值:
	long--计算结果

功能说明:求div/by的四舍五入的结果

*************************************************************/
long lRound(long div,long by)
{
	long int temp;

	if (by)
	{
		temp = div/by;
		if (( (lAbs(div) % by) << 1) >= by)
			if (div >= 0)
				temp++;
			else
				temp--;
	}
	else
		temp=div;

	return(temp); /* 返回四舍五入的结果 */

} /* end lRound() */


/*********************************************************
函数名:long lAbs(long num)	int Abs( int num ) double fAbs( double num )

输入参数:
	long(int,double) num--待求绝对值的变量

输出参数:	无

返回值:		
	long(int,double)--返回变量num的绝对值

功能说明:求输入变量的绝对值。
*********************************************************/
long lAbs(long num)
{
	return ( num >= 0 ? num : -num );
}

int Abs( int num )
{
	 return ( num >= 0 ? num : -num );
}

double fAbs( double num )
{
	 return ( num >= 0 ? num : -num );
}



/**************************************************************
函数名:		long lSign(long num)

输入参数:
	long num--待求符号数,长整形

输出参数:	无

返回值:		num的正负符号1:>=0;-1<0

功能说明:求输入数的正负符号。
**************************************************************/
long lSign(long num)
{
	 return( num >= 0L ? 1l:-1l);
}



/****************************************************************************
 函数名:unsigned char BCDToHex(unsigned char bcd_data)
		     unsigned char HexToBCD(unsigned char hex_data)								

输入参数:
	unsigned char bcd_data(hex_data)--待转换的8位BCD数或16进制数

输出参数:	无					

返回值:		无

功能说明:把BCD数转换为16进制数或把16进制数转换为BCD数
****************************************************************************/
unsigned char BCDToHex(unsigned char bcd_data)
{
	unsigned char hex;
	hex=(bcd_data/16)*10+bcd_data%16;
	return(hex);
}

unsigned char HexToBCD(unsigned char hex_data)
{
	unsigned char bcd;
	bcd=(hex_data/10)*16+hex_data%10;
	return(bcd);
}



/**************************************************************
函数名:	void Bin2Bcd32( long  x, char* buffer)

输入参数:
	long x--
	char* buffer--

输出参数:
	char* buffer--

返回值:	无

功能说明:	长整形数的bcd码
**************************************************************/
void Bin2Bcd32( long  x, char* buffer)
{
	x=lAbs(x);/*2005.11.17*/
	buffer[9] = x/1000000000;
	x = x%1000000000;
	buffer[8] = x/100000000;
	x = x%100000000;
	buffer[7] = x/10000000;
	x = x%10000000;
	buffer[6] = x/1000000;
	x = x%1000000;
	buffer[5] = x/100000;
	x = x%100000;
	buffer[4] = x/10000;
	x = x%10000;
	buffer[3] = x/1000;
	x = x%1000;
	buffer[2] = x/100;
	x = x%100;
	buffer[1] = x/10;
	buffer[0] = x%10;
}