largenum.c

深圳市微逻辑电子有限公司 巨果&#8226 Kingmos&reg 系统核心

/******************************************************
Copyright(c) 版权所有，1998-2003微逻辑。保留所有权利。
******************************************************/

/*****************************************************
文件说明：大数操作 + - * /
版本号：1.0.0
开发时期：1999
作者：ln
修改记录：
******************************************************/

#include <ewindows.h>
#include "largenum.h"

UINT32
LargeNumSignedFormat(
    PLARGENUM   pNum
    );

// **************************************************
// 声明：PLARGENUM LargeNumSet( 
//					PLARGENUM pNum,
//					int n
//					)
// 参数：
// 	IN pNum - LARGENUM 结构指针，大数对象
//	IN n - 需要设置的数
// 返回值：
//	返回初始化好的 PLARGENUM 指针
// 功能描述：
//	初始化大数对象
// 引用: 
//	
// ************************************************

PLARGENUM LargeNumSet( 
					PLARGENUM pNum,
					int n
					)
{
    int i;

    if(n < 0){
        pNum->u.s32.u[0] = -n;
        pNum->fNegative = 1;
    } else{
        pNum->u.s32.u[0] = n;
        pNum->fNegative=0;
    }
    for(i=1; i<SIZE_OF_LARGENUM; i++){
        pNum->u.s32.u[i] = 0;
    }
    return pNum;
}

// **************************************************
// 声明：BOOL IsLargeNumNotZero( PLARGENUM   pNum )
// 参数：
// 	IN pNum - LARGENUM 结构指针，大数对象
// 返回值：
//	假如是非0值,返回TRUE；否则，返回FALSE
// 功能描述：
//	判断大数是否为非0值
// 引用: 
//	
// ************************************************

BOOL IsLargeNumNotZero(
					PLARGENUM   pNum
					)
{
    int i;

    for(i=0; i<SIZE_OF_LARGENUM; i++){
        if(pNum->u.s32.u[i]){
            return TRUE;
        }
    }
    return FALSE;
}

// **************************************************
// 声明：BOOL IsLargeNumNegative( PLARGENUM pNum )
// 参数：
// 	IN pNum - LARGENUM 结构指针，大数对象
// 返回值：
//	假如是负值,返回TRUE；否则，返回FALSE
// 功能描述：
//	判断大数是否为负值
// 引用: 
//	
// ************************************************

BOOL IsLargeNumNegative( PLARGENUM pNum )
{
    return (pNum->fNegative ? TRUE : FALSE);
}

// **************************************************
// 声明：BOOL IsLargeNumMagGreaterThan(
//							PLARGENUM   pNum1,
//							PLARGENUM   pNum2
// 参数：
// 	IN pNum1 - LARGENUM 结构指针，大数对象
// 	IN pNum2 - LARGENUM 结构指针，大数对象
// 返回值：
//	假如pNum1 > pNum2 ,返回TRUE；否则，返回FALSE
// 功能描述：
//	判断大数 pNum1 是否大于 pNum2（无符号比较）
// 引用: 
//	
// ************************************************

BOOL IsLargeNumMagGreaterThan(
							PLARGENUM   pNum1,
							PLARGENUM   pNum2
    )
{
    int i;

    for(i=SIZE_OF_LARGENUM-1; i>=0; i--){
        if(pNum1->u.s32.u[i] > pNum2->u.s32.u[i]){
            return TRUE;
        } else if(pNum1->u.s32.u[i] < pNum2->u.s32.u[i]){
            return FALSE;
        }
    }
    return FALSE;
}

// **************************************************
// 声明：BOOL IsLargeNumMagLessThan(
//						PLARGENUM   pNum1,
//						PLARGENUM   pNum2
//						)
// 参数：
// 	IN pNum1 - LARGENUM 结构指针，大数对象
// 	IN pNum2 - LARGENUM 结构指针，大数对象
// 返回值：
//	假如pNum1 < pNum2 ,返回TRUE；否则，返回FALSE
// 功能描述：
//	判断大数 pNum1 是否小于 pNum2（无符号比较）
// 引用: 
//	
// ************************************************

BOOL IsLargeNumMagLessThan(
						PLARGENUM   pNum1,
						PLARGENUM   pNum2
						)
{
    int i;

    for(i=SIZE_OF_LARGENUM-1; i>=0; i--){
        if(pNum1->u.s32.u[i] < pNum2->u.s32.u[i]){
            return TRUE;
        } else if(pNum1->u.s32.u[i] > pNum2->u.s32.u[i]){
            return FALSE;
        }
    }
    return FALSE;
}

// **************************************************
// 声明：PLARGENUM LargeNumMagInc( PLARGENUM pNum )
// 参数：
// 	IN pNum - LARGENUM 结构指针，大数对象
// 返回值
//	返回 PLARGENUM 对象指针
// 功能描述：
//	大数加一（无符号增加）
// 引用: 
//	
// ************************************************

PLARGENUM LargeNumMagInc( PLARGENUM pNum )
{
    UINT32  c;
    int     i;

    c = 1;
    for(i=0; i<SIZE_OF_LARGENUM; i++){
        pNum->u.s32.u[i] += c;
        if(pNum->u.s32.u[i]){
            c = 0;
        }
    }
    return pNum;
}

// **************************************************
// 声明：PLARGENUM LargeNumMagAdd(
//					PLARGENUM   pNum1,
//					PLARGENUM   pNum2,
//					PLARGENUM   pResult
//					)
// 参数：
// 	IN pNum1 - LARGENUM 结构指针，大数对象
// 	IN pNum2 - LARGENUM 结构指针，大数对象
// 	OUT pResult - LARGENUM 结构指针，大数对象
// 返回值：
//	返回 PLARGENUM 结果对象指针
// 功能描述：
//	实现 无符号 pResult = pNum1 + pNum2 的功能
// 引用: 
//	
// ************************************************

PLARGENUM LargeNumMagAdd(
					PLARGENUM   pNum1,
					PLARGENUM   pNum2,
					PLARGENUM   pResult
					)
{
    UINT32      c;
    UINT32      i;
    UINT32      a;
    UINT32      b;

    c = 0;	//进位
    for(i=0; i<SIZE_OF_LARGENUM; i++){
        a = pNum1->u.s32.u[i];
        b = pNum2->u.s32.u[i];
        pResult->u.s32.u[i] = a + b + c;
		//低位有进位吗 ？
        if(c){
			//低位有进位
			// [c=1][u[i]=5] = 9[a] + 6[b] + [c]
            if(pResult->u.s32.u[i] <= a){
                c = 1;	//溢出，需要向高位进位
            } else {
                c = 0;
            }
        } else {
            if(pResult->u.s32.u[i] < a){
                c = 1;	//溢出，需要向高位进位
            } else {
                c = 0;
            }
        }
    }
    return pResult;
}

// **************************************************
// 声明：PLARGENUM LargeNumMagSub(
//					PLARGENUM   pNum1,
//					PLARGENUM   pNum2,
//					PLARGENUM   pResult
//					)
// 参数：
// 	IN pNum1 - LARGENUM 结构指针，大数对象
// 	IN pNum2 - LARGENUM 结构指针，大数对象
// 	OUT pResult - LARGENUM 结构指针，大数对象
// 返回值：
//	返回 PLARGENUM 结果对象指针
// 功能描述：
//	实现 无符号 pResult = pNum1 - pNum2 的功能
// 引用: 
//	
// ************************************************

PLARGENUM LargeNumMagSub(
					PLARGENUM   pNum1,
					PLARGENUM   pNum2,
					PLARGENUM   pResult
					)
{
    UINT32      c;
    UINT32      i;
    UINT32      a;
    UINT32      b;

    c = 1;
    for(i=0; i<SIZE_OF_LARGENUM; i++){
        a = pNum1->u.s32.u[i];
        b = ~(pNum2->u.s32.u[i]);   // = -b
        pResult->u.s32.u[i] = a + b + c;
		//低位有进位吗 ？
        if(c){
			//低位有进位
			// [c=1][u[i]=5] = 9[a] + 6[b] + [c]
            if(pResult->u.s32.u[i] <= a){
                c = 1;	//溢出，需要向高位进位
            } else {
                c = 0;
            }

        } else {
            if(pResult->u.s32.u[i] < a){
                c = 1;	//溢出，需要向高位进位
            } else {
                c = 0;
            }

        }
    }
    return pResult;
}

// **************************************************
// 声明：PLARGENUM LargeNumAdd(
//					PLARGENUM   pNum1,
//					PLARGENUM   pNum2,
//					PLARGENUM   pResult
//					)
// 参数：
// 	IN pNum1 - LARGENUM 结构指针，大数对象
// 	IN pNum2 - LARGENUM 结构指针，大数对象
// 	OUT pResult - LARGENUM 结构指针，大数对象
// 返回值：
//	返回 PLARGENUM 结果对象指针
// 功能描述：
//	实现 pResult = pNum1 + pNum2 的功能
// 引用: 
//	
// ************************************************

PLARGENUM LargeNumAdd(
					PLARGENUM   pNum1,
					PLARGENUM   pNum2,
					PLARGENUM   pResult
					)
{
    BOOL    fNegative1;
    BOOL    fNegative2;
	//判断正负
    fNegative1 = IsLargeNumNegative(pNum1);
    fNegative2 = IsLargeNumNegative(pNum2);

    if(fNegative1 != fNegative2){
		//不同符号
        if(IsLargeNumMagGreaterThan(pNum1, pNum2)){
			//绝对值 abs(pNum1) > abs(pNum2)
            LargeNumMagSub(pNum1, pNum2, pResult);
        } else {
			//绝对值 abs(pNum1) < abs(pNum2)
            LargeNumMagSub(pNum2, pNum1, pResult);
			//符号反向
            fNegative1 = !fNegative1;
        }
    } else {
		//同符号
        LargeNumMagAdd(pNum1, pNum2, pResult);
    }
	//确定结果的符号
	//判断结果是否为0
    if(!IsLargeNumNotZero(pResult)){
        pResult->fNegative = FALSE;			//为0
    } else {
        pResult->fNegative = fNegative1;	//非0
    }
    return pResult;
}

// **************************************************
// 声明：PLARGENUM LargeNumSub(
//					PLARGENUM   pNum1,
//					PLARGENUM   pNum2,
//					PLARGENUM   pResult
//					)
// 参数：
// 	IN pNum1 - LARGENUM 结构指针，大数对象
// 	IN pNum2 - LARGENUM 结构指针，大数对象
// 	OUT pResult - LARGENUM 结构指针，大数对象
// 返回值：
//	返回 PLARGENUM 结果对象指针
// 功能描述：
//	实现 pResult = pNum1 - pNum2 的功能
// 引用: 
//	
// ************************************************

PLARGENUM LargeNumSub(
					PLARGENUM   pNum1,
					PLARGENUM   pNum2,
					PLARGENUM   pResult
					)
{
    BOOL    fNegative1;
    BOOL    fNegative2;
	
	//判断正负
    fNegative1 = IsLargeNumNegative(pNum1);
    fNegative2 = IsLargeNumNegative(pNum2);

    if(fNegative1 == fNegative2){
		//相同符号
        if(IsLargeNumMagGreaterThan(pNum1, pNum2)){
			//绝对值 abs(pNum1) > abs(pNum2)
            LargeNumMagSub(pNum1, pNum2, pResult);
        } else {
			//绝对值 abs(pNum1) < abs(pNum2)
            LargeNumMagSub(pNum2, pNum1, pResult);
            fNegative1 = !fNegative1;//符号反向
        }
    } else {
		//不同符号，like a - (-b) or -a - b
        LargeNumMagAdd(pNum1, pNum2, pResult);
    }
	//确定结果的符号
    if(!IsLargeNumNotZero(pResult)){
		//结果为0
        pResult->fNegative = FALSE;
    } else {
        pResult->fNegative = fNegative1;
    }
    return pResult;
}

#if SIZE_OF_LARGENUM < 2
#error  SIZE_OF_LARGENUM must be at least 2
#endif

// **************************************************
// 声明：PLARGENUM LargeNumMulUint32(
//						UINT32      a,
//						UINT32      b,
//						PLARGENUM   pResult
//						)
// 参数：
// 	IN a - 值1
// 	IN b - 值2
// 	OUT pResult - LARGENUM 结构指针，大数对象
// 返回值：
//	返回 PLARGENUM 结果对象指针
// 功能描述：
//	实现 pResult = a * b; 无符号乘
// 引用: 
//	
// ************************************************

PLARGENUM LargeNumMulUint32(
						UINT32      a,
						UINT32      b,
						PLARGENUM   pResult
						)
{
    UINT32  a1, a0;
    UINT32  b1, b0;
    UINT32  r0;
    UINT32  r1;
    UINT32  r2;
    UINT32  c;
    int     i;

    a1 = a >> 16;		//a的高16位