HugeCalc

HugeCalc V8.0.0.0

HugeCalc 是一款超大整数的高精度（或称多精度）算法库（同时支持 MBCS + UNICODE 版），适合于大规模科学计算，尤其适用于数论、密码学等领域研究。具有功能全面、占用资源少、效率高、使用便捷、易二次开发、可移植性强、可扩展性好等特点。

HugeCalc V5.x 首次采用了十进制/二进制“双进制内核系统”，且内部可高效相互转换，使输入/输出及内部计算均得以高效进行。

HugeCalc V6.x 则实现了在同一个动态链接库 HugeCalc.dll 中同时导出了 C++ 函数接口、ANSI C 函数接口、以及标准的 TLB 接口，且可自适应于 MBCS 或 UNICODE 版本，使适用性和易用性得以完美体现。

HugeCalc V7.x 则实现了自动识别用户 CPU 类型，并自动调整算法及相关参数，以使效率最佳化；并实现了用 SSE2 指令集加速、多核并行处理等新技术，以充分发挥现代及未来 CPU 的性能。

HugeCalc V8.x 则实现了全整型指令算法（无须任何浮点指令集支持），比之先前有浮点指令参与时可提速 30% 左右。

HugeCalc 现已提供了如下功能：
  1. 高精度快速加法
  2. 高精度快速减法
  3. 高精度快速乘法
  4. 高精度快速除法
  5. 高精度快速同余
  6. 高精度快速位运算
  7. 高精度快速乘方
  8. 高精度快速开方
  9. 超大整数快速取对数
  10. 高精度快速求排列
  11. 高精度快速求组合
  12. 高精度快速 n!、n!!、n#、素数阶乘
  13. 高精度快速计算 Fibonacci、Lucas 数列
  14. 高精度快速乘积取模
  15. 高精度快速模逆运算
  16. 高精度快速乘方取模（支持负指数）
  17. 高精度快速求最大公约数（支持群组运算）
  18. 高精度快速计算扩展最大公约数
  19. 高精度快速求最小公倍数（支持群组运算）
  20. 高精度快速“等幂和”（支持群组运算）
  21. 高精度快速任意进制转换
  22. 超大整数素性快速检测
  23. 生成随机超大（素）整数、快速生成最邻近素数
  24. 自由指定有效位运算
  25. 强大而灵活的输出
  26. 高精度计时器（有暂停、累计、复位等功能）

    27. 哇，都排到“Z”了！:) 还没说完呢！...

HugeCalc 是一款持续发展的软件，其快速算法由作者郭先强历经十余年心血苦心研制而成！它具有如下特点：
  • 功能全面：关键文件 HugeCalc.dll 虽然很小，却提供了公共函数接口 709 个（标准C++接口 473 个；标准C接口 236 个）。重载了多种版本的构造函数，以及重载了许多基本的运算符，并具备灵活的输出方式，使用方便一切得心应手
  • 占用资源少：作者在开发过程中非常注重资源的有效利用，确保内存的耗用尽可能地低，远低于其它高精度算法库（HugeCalc V5.1.0.1 曾在一台工作站上精确计算出5千万的阶乘，耗时654.3秒，内存耗费峰值1105MB；普通程序一般都会因寻址空间不足等原因而中途崩溃）
  • 自动调整算法：HugeCalc 在启动时可自动侦测用户 CPU 的型号，并据此自动调整算法及相应参数，使在兼顾老式机器的前提下，可充分发挥现代及未来 CPU 的功效（如采用 SSE2 指令集、多核并行等）
  • 效率高：这是算法库的根基。HugeCalc 采用了许多先进的算法，部分是作者在该领域多年的积累，许多算法甚至已优于一些大型专业数学工具软件
  • 使用便捷：灵活的调用方式，可通用于各种编程环境
  • 易二次开发：丰富的数据接口，为再开发提供了便利
  • 可移植性强：算法库本身基于整数处理，完全不调用任何浮点指令，可适应于各种软硬件平台
  • 可扩展性好：对开发者来说，良好的数据结构，数以千计的高效内核，改进算法或新增功能都极为容易；对于用户来说，由于采用了合理的标准导出模式，从 V6.x 起，HugeCalc 将保证后续版本完全兼容先前版本；当有新版发布时，先前的程序无须重新编译即可调用升级后的DLL

查看网上最新版本


相关信息
  • 硬件环境：无特殊要求，386 以上 CPU 即可；最新的 64 位 CPU 亦可[*]

  • 操作系统：Windows 98/ME/2K/NT/XP/2003/Vista(32位/64位)

  • 子系统：Console/GUI 通用

  • 适用编程语言：C++、C、VB 等，并已做好相关导入准备

Remarks

运行 RegDll.exe 将自动生成 HugeCalc.ini，该文件记录了对程序运行至关重要的 CPU 的相关参数[*]：

NumOfCores
CPU 的核数，如果有超线程（hyperthreading）技术，则指处理器的总线程数。如果用户设定：
NumOfCores = 0，什么？没有CPU？！那么将关闭高级算法（会慢很多的。。。）
NumOfCores = 1，将采用单线程
NumOfCores > 1，将采用多线程
SSE2Support
0 - SSE2 指令集不支持；1 - SSE2 指令集支持
CacheL1size
CPU L1 cache size （单位：KB）
CacheL2size
CPU L2 cache size （单位：KB）
CacheL3size
CPU L3 cache size （单位：KB）
Cacheburst
CPU cache line size （单位：字节）

See Also

HugeCalc API、算法库调用手册、注册流程图解


算法库调用手册（函数索引）
函数名 函数功能描述 HugeCalc CHugeInt CHugeIntX CRadixConverter HC HI HX RC

Classes and Data Structures：

选择进制内核提示：
本系统为十进制和二进制双系统。如果需要进行大量的位运算（如用在密码学领域）或需要十六进制输出，建议用 CHugeIntX（或HX_xxx）；否则建议选用 CHugeInt（或HI_xxx）。

See Also

HugeCalc API


常量/结构定义

// ================ typedef ================

#ifndef _SINT32
#define _SINT32
typedef INT32 SINT32;
#endif // !defined(_SINT32)

#ifndef _SINT64
#define _SINT64
typedef INT64 SINT64;
#endif // !defined(_SINT64)

// ================ enum ================

typedef enum tagHCLicenseLevel
{
HC_LICENSE_NONE = 0x00, /* 很容易转换成 HC_LICENSE_DEMO */
HC_LICENSE_DEMO = 0x01, /* 使用上略有限制 */
HC_LICENSE_ALL = 0x02, /* 注册 HugeCalc后获得单机所有权限 */
HC_LICENSE_CUSTOM = 0xFF, /* 客户定制，欢迎联系洽谈 */
}HCLicenseLevel;

typedef enum tagHCErrCode
{
HCERR_NONE = 0,
HCERR_NO_LICENSE = 1,
HCERR_USER_STOP = 2,
HCERR_NO_ENOUGH_MEMORY = 3,
HCERR_INVALID_POINTER = 4,
HCERR_DIV_ZERO = 5,
HCERR_BASE2SMALL = 6,
HCERR_RADIX2SMALL = 7,
//...
HCERR_UNKNOWN = 0xFF,
}HCErrCode;

typedef enum tagSIGN
{
SIGN_NEG = -1, // Negative
SIGN_ZERO = 0, // Zero
SIGN_POS = 1, // Positive
}SIGN;

typedef enum tagTimerUnit
{
TIMER_UNIT_ms = 0, // millisecond
TIMER_UNIT_us = 1, // microsecond
TIMER_UNIT_ns = 2, // millimicrosecond
}TimerUnit;

typedef enum tagFormatTime
{
FT_HHMMSS_ms = 0, // "00:00:12.345"
FT_DOT06SEC = 1, // "12.345678"
FT_DOT06SECs = 2, // "12.345678s"
FT_DOT06SEC_s = 3, // "12.345678 s"
}FormatTime;

typedef enum tagPrimality
{
COMPOSITE = 0,
PROBABLY_PRIME = 1,
PRIME = 2,
}PRIMALITY;

// ================ CONST ================

CONST BYTE FS_NORMAL = 0x00; // normal format
CONST BYTE FS_BAND = 0x01; // ' ' or ',' at pre 3[or 4] digits from right
CONST BYTE FS_BAND_SPACE = 0x02; // must setting "| FS_BAND"
CONST BYTE FS_SIGN = 0x04; // even if "+"
CONST BYTE FS_SIGN_SPACE = 0x08; // between sign and number
CONST BYTE FS_CHAR_LOWER = 0x10; // will use [0-9a-z]; otherwise, use [0-9A-Z]
CONST BYTE FS_DEFAULT = FS_BAND | FS_BAND_SPACE | FS_SIGN_SPACE; // default format

// ================ struct ================

typedef struct tagCVECTOR_UINT32
{
CONST UINT32 * p_start;
UINT32 u32Size;

#ifdef __cplusplus
tagCVECTOR_UINT32( CONST UINT32 * CONST _p_start, CONST UINT32 _u32Size )
: p_start( _p_start ), u32Size( _u32Size )
{
};
#endif
}CVECTOR_UINT32, FAR *PCVECTOR_UINT32;
typedef CONST CVECTOR_UINT32 FAR *LPCVECTOR_UINT32;

typedef struct tagCVECTOR_HHUGEINT
{
CONST CHugeInt ** p_start;
UINT32 u32Size;

#ifdef __cplusplus
tagCVECTOR_HHUGEINT( CONST CHugeInt ** CONST _p_start, CONST UINT32 _u32Size )
: p_start( _p_start ), u32Size( _u32Size )
{
};
#endif
}CVECTOR_HHUGEINT, FAR *PCVECTOR_HHUGEINT;
typedef CONST CVECTOR_HHUGEINT FAR *LPCVECTOR_HHUGEINT;

typedef struct tagCVECTOR_HHUGEINTX
{
CONST CHugeIntX ** p_start;
UINT32 u32Size;

#ifdef __cplusplus
tagCVECTOR_HHUGEINTX( CONST CHugeIntX ** CONST _p_start, CONST UINT32 _u32Size )
: p_start( _p_start ), u32Size( _u32Size )
{
};
#endif
}CVECTOR_HHUGEINTX, FAR *PCVECTOR_HHUGEINTX;
typedef CONST CVECTOR_HHUGEINTX FAR *LPCVECTOR_HHUGEINTX;

See Also

全局函数


全局函数
  • 查看版本信息：
    CONST LPCTSTR HugeCalc::GetVer( VOID );

  • 查看导出函数数目：
    CONST UINT32 HugeCalc::GetExportFunNums( CONST UINT32 u32Mask );

  • 获取 SN 字串：
    CONST LPCTSTR HugeCalc::GetSN( VOID );

  • 查看 License 级别：
    CONST HCLicenseLevel HugeCalc::GetLicenseLevel( VOID );

  • 查看出错代码：
    CONST HCErrCode HugeCalc::GetLastError( VOID );

  • 设定 HugeCalc 终止状态与否：
    VOID HugeCalc::SetTerminate( CONST BOOL bTerminate = TRUE );

  • 判断 HugeCalc 是否被终止：
    CONST BOOL HugeCalc::IsTerminated( VOID );

  • 读取当前运行实例数目：
    static CONST UINT32 CHugeInt::GetCount( VOID );
    static CONST UINT32 CHugeIntX::GetCount( VOID );
    static CONST UINT32 CRadixConverter::GetCount( VOID );
Remarks
  1. 如果 HugeCalc::GetLicenseLevel() 为 HC_LICENSE_NONE 时，则本算法库将自动拒绝服务；为 HC_LICENSE_DEMO 时，仅输出字串和进制转换时有随机干扰；注册后将为 HC_LICENSE_ALL，不受任何功能限制，具体请参见：未注册用户的限制；如果您需要在您的群组或客户机器上，无须再单机注册即可正常调用 HugeCalc 提供的强大功能，请您与作者联系洽谈客户定制专版，此时将获得 HC_LICENSE_CUSTOM 权限
  2. 调用 HugeCalc::SetTerminate( TRUE ) 将迅速从线程中退出
  3. 如果 HugeCalc::IsTerminated() 为 TRUE，必须先调用 HugeCalc::SetTerminate( FALSE ) 后才能再运算
  4. 如想获得出错代码，请调用 HugeCalc::GetLastError()，且务必在 HugeCalc::SetTerminate( FASLE )之前调用（因为该命令将同时清除 LastErr）
See Also

常量/结构定义、高精度计时器


基数变换器
  • explicit CRadixConverter::CRadixConverter( CONST UINT32 u32Radix, CONST SIGN enumSign = SIGN_POS, CONST LPCVECTOR_UINT32 pVector = NULL );
  • explicit CRadixConverter::CRadixConverter( CONST UINT32 u32Radix, CONST CHugeInt& right );
  • explicit CRadixConverter::CRadixConverter( CONST UINT32 u32Radix, CONST CHugeIntX& right );
  • explicit CRadixConverter::CRadixConverter( CONST UINT32 u32Radix, CONST LPCTSTR lpszNum );
  • explicit CRadixConverter::CRadixConverter( CONST CRadixConverter& right );

  • CRadixConverter::~CRadixConverter( );

  • static CONST UINT32 CRadixConverter::GetCount( VOID );

  • CRadixConverter * CONST CRadixConverter::operator ->( VOID );

  • CRadixConverter& CRadixConverter::Convert2Radix( CONST UINT32 u32NewRadix );

  • CRadixConverter& CRadixConverter::operator =( CONST CRadixConverter& right );
  • CRadixConverter& CRadixConverter::operator =( CONST CHugeInt& right );
  • CRadixConverter& CRadixConverter::operator =( CONST CHugeIntX& right );

  • CRadixConverter& CRadixConverter::operator =( CONST SINT32& s32Num );
  • CRadixConverter& CRadixConverter::operator =( CONST SINT64& s64Num );
  • CRadixConverter& CRadixConverter::operator =( CONST UINT32& u32Num );
  • CRadixConverter& CRadixConverter::operator =( CONST UINT64& u64Num );

  • CRadixConverter::operator CONST SINT32( VOID ) CONST;
  • CRadixConverter::operator CONST SINT64( VOID ) CONST;
  • CRadixConverter::operator CONST UINT32( VOID ) CONST;
  • CRadixConverter::operator CONST UINT64( VOID ) CONST;

  • VOID CRadixConverter::ResetRadix( CONST UINT32 u32Radix );
  • VOID CRadixConverter::ResetSign( CONST SIGN enumSign );
  • VOID CRadixConverter::ResetVector( CONST CVECTOR_UINT32& vU32Num );
  • VOID CRadixConverter::ClearVector( VOID );

  • CONST UINT32 CRadixConverter::GetRadix( VOID ) CONST;
  • CONST SIGN CRadixConverter::GetSign( VOID ) CONST;
  • CONST CVECTOR_UINT32& CRadixConverter::GetVector( CVECTOR_UINT32& vU32Num ) CONST;
  • CONST UINT64 CRadixConverter::SumOfDigits( VOID ) CONST;
Parameters
u32Radix、u32NewRadix
[in] 基数（进制数）
enumSign
[in] 基数变换器符号
pVector
[in] 进制转换向量指针
right
[in] 已知的超大整数/基数变换器
lpszNum
[in] 以 NULL 结尾的字符串
s32Num
[in] 32bit-有符号整数
s64Num
[in] 64bit-有符号整数
u32Num
[in] 32bit-无符号整数
u64Num
[in] 64bit-无符号整数
vU32Num
[in] 拷贝的向量
Remarks
  1. HugeCalc 约定如下：CRadixConverter 中对位的存储规则为，下标从小到大依次对应存储（进制转换前后）数值的低位到高位
  2. 当 u32Radix = 0 时，内部将以 232 为基数（进制数）看待
  3. 该类可快速实现任意超大整数转化为指定的任意非“1”的32bits整数下的进制计数方式
  4. “explicit CRadixConverter::CRadixConverter( CONST UINT32 u32Radix, CONST LPCTSTR lpszNum );”可通过字符串直接初始化，规则如下：
    • 当 u32Radix = 0 时，内部将以 232 为基数（进制数）看待
    • 当 1 < u32Radix ≤ 10 时，忽略所有非数字字符
    • 当 10 < u32Radix ≤ 36 时，忽略字母的大小写区别
    • 当 36 < u32Radix ≤ 62 时，A-Z 依次代表 10-35；a-z 依次代表 36-61
    • 当字符转换出的数字大于等于设定基数（进制数）时，自动忽略
    • lpszNum 中“-”号（负号）可被承认的前提是：其前无任何字符；或其前仅有空格符、Tab符、回车符、换行符或它们的组合
  5. 该类也可作为入参直接对超大整数进行初始化或赋值
  6. 不同基数的两个变量赋值时，自动进行基数变换（即其表达的“数值”是完全等同的）
  7. 技巧提示：通过该类，可以方便地将超大整数的值以用户的进制“导出”出来，转换的效率从高到低的顺序为：u32Radix = 2r型、10r型、…(其它进制)；但如果超大整数的值在 [ - 9 223 372 036 854 775 808, 9 223 372 036 854 775 807 ] 时，调用 operator CONST SINT64() 应为更明智的选择
  8. 当 HugeCalc 未注册时，转换时将有延时或随机干扰，具体请参见：未注册用户的限制
See Also

常量/结构定义、初始化超大整数、高精度赋值、高精度快速任意进制转换


初始化超大整数
  • explicit CHugeInt::CHugeInt( VOID );
  • explicit CHugeInt::CHugeInt( CONST UINT32& u32Num );
  • explicit CHugeInt::CHugeInt( CONST SINT32& s32Num );
  • explicit CHugeInt::CHugeInt( CONST UINT64& u64Num );
  • explicit CHugeInt::CHugeInt( CONST SINT64& s64Num );
  • explicit CHugeInt::CHugeInt( CONST LPCTSTR lpszNum );
  • explicit CHugeInt::CHugeInt( CONST CRadixConverter& RadixConverter );
  • explicit CHugeInt::CHugeInt( CONST CHugeInt& right );
  • explicit CHugeInt::CHugeInt( CONST CHugeIntX& right );

  • explicit CHugeIntX::CHugeIntX( VOID );
  • explicit CHugeIntX::CHugeIntX( CONST UINT32& u32Num );
  • explicit CHugeIntX::CHugeIntX( CONST SINT32& s32Num );
  • explicit CHugeIntX::CHugeIntX( CONST UINT64& u64Num );
  • explicit CHugeIntX::CHugeIntX( CONST SINT64& s64Num );
  • explicit CHugeIntX::CHugeIntX( CONST LPCTSTR lpszNum );
  • explicit CHugeIntX::CHugeIntX( CONST CRadixConverter& RadixConverter );
  • explicit CHugeIntX::CHugeIntX( CONST CHugeInt& right );
  • explicit CHugeIntX::CHugeIntX( CONST CHugeIntX& right );
Parameters
u32Num
[in] 32bit-无符号整数
s32Num
[in] 32bit-有符号整数
u64Num
[in] 64bit-无符号整数
s64Num
[in] 64bit-有符号整数
lpszNum
[in] 以 NULL 结尾的字符串
RadixConverter
[in] 进制转换数据结构
right
[in] 超大整数
Remarks
  1. CHugeInt()、CHugeIntX() 将默认一个值为“0”的超大整数
  2. CHugeInt( lpszNum )、CHugeIntX( lpszNum ) 可自动过滤非（十六进制）数字字符
  3. lpszNum 中“-”号（负号）可被承认的前提是：其前无任何字符；或其前仅有空格符、Tab符、回车符、换行符或它们的组合
  4. lpszNum 被当作十六进制字符串的前提是：存在“0x”或“0X”子串，且之前未发现非零十进制数字字符
  5. CHugeInt( RadixConverter )、CHugeIntX( RadixConverter ) 可将任何其它进制的数转换成通常的超大整数
See Also

基数变换器、高精度赋值、高精度快速任意进制转换


高精度赋值
  • CHugeInt& CHugeInt::operator =( CONST SINT32& s32Num );
  • CHugeInt& CHugeInt::operator =( CONST SINT64& s64Num );
  • CHugeInt& CHugeInt::operator =( CONST UINT32& u32Num );
  • CHugeInt& CHugeInt::operator =( CONST UINT64& u64Num );
  • CHugeInt& CHugeInt::operator =( CONST LPCTSTR lpszNum );
  • CHugeInt& CHugeInt::operator =( CONST CRadixConverter& RadixConverter );
  • CHugeInt& CHugeInt::operator =( CONST CHugeInt& right );
  • CHugeInt& CHugeInt::operator =( CONST CHugeIntX& right );

  • CHugeIntX& CHugeIntX::operator =( CONST SINT32& s32Num );
  • CHugeIntX& CHugeIntX::operator =( CONST SINT64& s64Num );
  • CHugeIntX& CHugeIntX::operator =( CONST UINT32& u32Num );
  • CHugeIntX& CHugeIntX::operator =( CONST UINT64& u64Num );
  • CHugeIntX& CHugeIntX::operator =( CONST LPCTSTR lpszNum );
  • CHugeIntX& CHugeIntX::operator =( CONST CRadixConverter& RadixConverter );
  • CHugeIntX& CHugeIntX::operator =( CONST CHugeInt& right );
  • CHugeIntX& CHugeIntX::operator =( CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::SetHexStr( CONST LPCTSTR lpszHexNum );

  • CHugeIntX& CHugeIntX::SetHexStr( CONST LPCTSTR lpszHexNum );

  • CHugeIntX& CHugeIntX::SetText( CONST LPCTSTR lpszText );

  • CRadixConverter& CRadixConverter::operator =( CONST CRadixConverter& right );
  • CRadixConverter& CRadixConverter::operator =( CONST CHugeInt& right );
  • CRadixConverter& CRadixConverter::operator =( CONST CHugeIntX& right );
Parameters
s32Num
[in] 32bit-有符号整数
s64Num
[in] 64bit-有符号整数
u32Num
[in] 32bit-无符号整数
u64Num
[in] 64bit-无符号整数
lpszNum
[in] 以 NULL 结尾的字符串
lpszHexNum
[in] 以 NULL 结尾的字符串，总是被当作十六进制字符串（首部无须出现“0x”或“0X”标记）
lpszText
[in] 以 NULL 结尾的字符串，其字串内码从被当作超大整数进行赋值
RadixConverter
[in] 基数变换器
right
[in] 超大整数
Return Values

赋值后的超大整数

Remarks
  1. operator =( lpszNum ) 可自动过滤非（十六进制）数字字符
  2. lpszNum 中“-”号（负号）可被承认的前提是：其前无任何字符；或其前仅有空格符、Tab符、回车符、换行符或它们的组合
  3. lpszNum 被当作十六进制字符串的前提是：存在“0x”或“0X”子串，且之前未发现非零十进制数字字符
  4. lpszHexNum 首部无须出现“0x”或“0X”标记，总是被当作十六进制字符串
  5. SetText(..) 可将任意字串以内码形式转化为超大整数，以便进行加解密运算
  6. operator =( RadixConverter ) 函数可将任何其它进制的数转换成通常的超大整数
See Also

初始化超大整数、基数变换器、高精度快速任意进制转换、加解密字串处理


快速比较大小
  • CONST SINT32 Compare( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST SINT32 Compare( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST SINT32 Compare( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST SINT32 Compare( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST SINT32 Compare( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST SINT32 Compare( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST SINT32 Compare( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST SINT32 Compare( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST SINT32 Compare( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST SINT32 Compare( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CONST SINT32 CompareAbs( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST SINT32 CompareAbs( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST SINT32 CompareAbs( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST SINT32 CompareAbs( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST SINT32 CompareAbs( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST SINT32 CompareAbs( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST SINT32 CompareAbs( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST SINT32 CompareAbs( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST SINT32 CompareAbs( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST SINT32 CompareAbs( CONST CHugeIntX& left, CONST CHugeIntX& right );
Parameters
u32Num
[in] 32bit-无符号整数
s32Num
[in] 32bit-有符号整数
left、right
[in] 超大整数
Return Values

小于返回 -1，等于返回 0，大于返回 1。

Remarks
  1. Compare(..) 比较值的大小；CompareAbs(..) 比较绝对值大小
  2. 重载与普通数的运算是为了有针对性的提高效率
See Also

大小关系运算


大小关系运算
  • CONST BOOL operator ==( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST BOOL operator ==( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST BOOL operator ==( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST BOOL operator ==( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST BOOL operator ==( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST BOOL operator ==( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST BOOL operator ==( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST BOOL operator ==( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST BOOL operator ==( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST BOOL operator ==( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CONST BOOL operator !=( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST BOOL operator !=( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST BOOL operator !=( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST BOOL operator !=( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST BOOL operator !=( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST BOOL operator !=( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST BOOL operator !=( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST BOOL operator !=( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST BOOL operator !=( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST BOOL operator !=( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CONST BOOL operator <( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST BOOL operator <( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST BOOL operator <( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST BOOL operator <( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST BOOL operator <( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST BOOL operator <( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST BOOL operator <( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST BOOL operator <( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST BOOL operator <( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST BOOL operator <( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CONST BOOL operator <=( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST BOOL operator <=( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST BOOL operator <=( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST BOOL operator <=( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST BOOL operator <=( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST BOOL operator <=( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST BOOL operator <=( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST BOOL operator <=( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST BOOL operator <=( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST BOOL operator <=( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CONST BOOL operator >( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST BOOL operator >( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST BOOL operator >( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST BOOL operator >( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST BOOL operator >( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST BOOL operator >( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST BOOL operator >( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST BOOL operator >( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST BOOL operator >( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST BOOL operator >( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CONST BOOL operator >=( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST BOOL operator >=( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST BOOL operator >=( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST BOOL operator >=( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST BOOL operator >=( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST BOOL operator >=( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST BOOL operator >=( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST BOOL operator >=( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST BOOL operator >=( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST BOOL operator >=( CONST CHugeIntX& left, CONST CHugeIntX& right );
Parameters
u32Num
[in] 32bit-无符号整数
s32Num
[in] 32bit-有符号整数
left、right
[in] 超大整数
Return Values

TRUE or FALSE

Remarks

重载与普通数的运算是为了有针对性的提高效率

See Also

快速比较大小


高精度快速加法
  • CONST CHugeInt operator +( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST CHugeInt operator +( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST CHugeInt operator +( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST CHugeInt operator +( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST CHugeInt operator +( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST CHugeIntX operator +( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST CHugeIntX operator +( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST CHugeIntX operator +( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST CHugeIntX operator +( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST CHugeIntX operator +( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::operator +=( CONST UINT32 u32Num );
  • CHugeInt& CHugeInt::operator +=( CONST SINT32 s32Num );

  • CHugeInt& CHugeInt::operator +=( CONST CHugeInt& right );

  • CHugeIntX& CHugeIntX::operator +=( CONST UINT32 u32Num );
  • CHugeIntX& CHugeIntX::operator +=( CONST SINT32 s32Num );

  • CHugeIntX& CHugeIntX::operator +=( CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::operator ++( VOID );

  • CONST CHugeInt CHugeInt::operator ++( CONST INT );

  • CHugeIntX& CHugeIntX::operator ++( VOID );

  • CONST CHugeIntX CHugeIntX::operator ++( CONST INT );
Parameters
u32Num
[in] 32bit-无符号整数
s32Num
[in] 32bit-有符号整数
left、right
[in] 超大整数
Return Values

和

Remarks

operator ++() 是前自增运算；operator ++( INT ) 是后自增运算；前者效率高于后者

See Also

高精度快速减法


高精度快速减法
  • CONST CHugeInt operator -( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST CHugeInt operator -( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST CHugeInt operator -( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST CHugeInt operator -( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST CHugeInt operator -( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST CHugeIntX operator -( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST CHugeIntX operator -( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST CHugeIntX operator -( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST CHugeIntX operator -( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST CHugeIntX operator -( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::operator -=( CONST UINT32 u32Num );
  • CHugeInt& CHugeInt::operator -=( CONST SINT32 s32Num );

  • CHugeInt& CHugeInt::operator -=( CONST CHugeInt& right );

  • CHugeIntX& CHugeIntX::operator -=( CONST UINT32 u32Num );
  • CHugeIntX& CHugeIntX::operator -=( CONST SINT32 s32Num );

  • CHugeIntX& CHugeIntX::operator -=( CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::operator --( VOID );

  • CONST CHugeInt CHugeInt::operator --( CONST INT );

  • CHugeIntX& CHugeIntX::operator --( VOID );

  • CONST CHugeIntX CHugeIntX::operator --( CONST INT );
Parameters
u32Num
[in] 32bit-无符号整数
s32Num
[in] 32bit-有符号整数
left、right
[in] 超大整数
Return Values

差

Remarks

operator --() 是前自减运算；operator --( INT ) 是后自减运算；前者效率高于后者

See Also

高精度快速加法


高精度快速乘法
  • CHugeInt& CHugeInt::Mul( CONST UINT32 u32Multiplicand, CONST CHugeInt& hugeMultiplier );
  • CHugeInt& CHugeInt::Mul( CONST SINT32 s32Multiplicand, CONST CHugeInt& hugeMultiplier );

  • CHugeInt& CHugeInt::Mul( CONST CHugeInt& hugeMultiplicand, CONST UINT32 u32multiplier );
  • CHugeInt& CHugeInt::Mul( CONST CHugeInt& hugeMultiplicand, CONST SINT32 s32multiplier );

  • CHugeInt& CHugeInt::Mul( CONST CHugeInt& hugeMultiplicand, CONST CHugeInt& hugeMultiplier );

  • CHugeIntX& CHugeIntX::Mul( CONST UINT32 u32Multiplicand, CONST CHugeIntX& hugeMultiplier );
  • CHugeIntX& CHugeIntX::Mul( CONST SINT32 s32Multiplicand, CONST CHugeIntX& hugeMultiplier );

  • CHugeIntX& CHugeIntX::Mul( CONST CHugeIntX& hugeMultiplicand, CONST UINT32 u32multiplier );
  • CHugeIntX& CHugeIntX::Mul( CONST CHugeIntX& hugeMultiplicand, CONST SINT32 s32multiplier );

  • CHugeIntX& CHugeIntX::Mul( CONST CHugeIntX& hugeMultiplicand, CONST CHugeIntX& hugeMultiplier );

  • CONST CHugeInt operator *( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST CHugeInt operator *( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST CHugeInt operator *( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST CHugeInt operator *( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST CHugeInt operator *( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST CHugeIntX operator *( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST CHugeIntX operator *( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST CHugeIntX operator *( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST CHugeIntX operator *( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST CHugeIntX operator *( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::operator *=( CONST UINT32 u32Num );
  • CHugeInt& CHugeInt::operator *=( CONST SINT32 s32Num );

  • CHugeInt& CHugeInt::operator *=( CONST CHugeInt& right );

  • CHugeIntX& CHugeIntX::operator *=( CONST UINT32 u32Num );
  • CHugeIntX& CHugeIntX::operator *=( CONST SINT32 s32Num );

  • CHugeIntX& CHugeIntX::operator *=( CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::Product( CONST CVECTOR_UINT32& vU32Num );
  • CHugeInt& CHugeInt::Product( CONST CVECTOR_HHUGEINT& vLpHugeInt );

  • CHugeIntX& CHugeIntX::Product( CONST CVECTOR_UINT32& vU32Num );
  • CHugeIntX& CHugeIntX::Product( CONST CVECTOR_HHUGEINTX& vLpHugeIntX );

  • CHugeInt& CHugeInt::DecLShift( CONST UINT32 u32DecLShift );
Parameters
s32Num
[in] 32bit-有符号整数
u32Num
[in] 32bit-无符号整数
left, right
[in] 超大整数
u32multiplicand、s32multiplicand
[in] 32bit-被乘数
hugeMultiplicand
[in] 被乘数；超大整数
u32multiplier、s32multiplier
[in] 32bit-乘数
hugeMultiplier
[in] 乘数；超大整数
vU32Num
[in] 32bit-无符号整数数组
vLpHugeInt、vLpHugeIntX
[in] 超大整数指针数组
u32DecLShift
[in] 以 10 为基底左移的位数（右端用“0”补齐）
Return Values

积

Remarks
  1. 用“operator *=”运算符比用“operator *”效率高
  2. Product(..)函数经过特别优化，速度非常快
  3. DecLShift(..)函数表示十进制超大整数以 10 为基底进行左移（右端用“0”补齐 ）
See Also

高精度快速除法（商、余）


高精度快速除法（商、余）
  • CONST SINT64 Div( CONST UINT32 u32Dividend, CONST CHugeInt& hugeDivisor, UINT32 * CONST pRemainder = NULL );
  • CONST SINT32 Div( CONST SINT32 s32Dividend, CONST CHugeInt& hugeDivisor, SINT32 * CONST pRemainder = NULL );

  • CHugeInt& CHugeInt::Div( CONST CHugeInt& hugeDividend, UINT32 u32Divisor, SINT64 * CONST pRemainder = NULL );
  • CHugeInt& CHugeInt::Div( CONST CHugeInt& hugeDividend, SINT32 s32Divisor, SINT32 * CONST pRemainder = NULL );

  • CHugeInt& CHugeInt::Div( CONST CHugeInt& hugeDividend, CONST CHugeInt& hugeDivisor, CHugeInt& CONST pRemainder = NULL );

  • CONST SINT64 Div( CONST UINT32 u32Dividend, CONST CHugeIntX& hugeDivisor, UINT32 * CONST pRemainder = NULL );
  • CONST SINT32 Div( CONST SINT32 s32Dividend, CONST CHugeIntX& hugeDivisor, SINT32 * CONST pRemainder = NULL );

  • CHugeIntX& CHugeIntX::Div( CONST CHugeIntX& hugeDividend, UINT32 u32Divisor, SINT64 * CONST pRemainder = NULL );
  • CHugeIntX& CHugeIntX::Div( CONST CHugeIntX& hugeDividend, SINT32 s32Divisor, SINT32 * CONST pRemainder = NULL );

  • CHugeIntX& CHugeIntX::Div( CONST CHugeIntX& hugeDividend, CONST CHugeIntX& hugeDivisor, CHugeIntX& CONST pRemainder = NULL );

  • CONST SINT64 operator /( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST SINT32 operator /( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST CHugeInt operator /( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST CHugeInt operator /( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST CHugeInt operator /( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST SINT64 operator /( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST SINT32 operator /( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST CHugeIntX operator /( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST CHugeIntX operator /( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST CHugeIntX operator /( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CONST UINT32 operator %( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CONST SINT32 operator %( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CONST SINT64 operator %( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CONST SINT32 operator %( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CONST CHugeInt operator %( CONST CHugeInt& left, CONST CHugeInt& right );

  • CONST UINT32 operator %( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CONST SINT32 operator %( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CONST SINT64 operator %( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CONST SINT32 operator %( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CONST CHugeIntX operator %( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::operator /=( CONST UINT32 u32Num );
  • CHugeInt& CHugeInt::operator /=( CONST SINT32 s32Num );

  • CHugeInt& CHugeInt::operator /=( CONST CHugeInt& right );

  • CHugeIntX& CHugeIntX::operator /=( CONST UINT32 u32Num );
  • CHugeIntX& CHugeIntX::operator /=( CONST SINT32 s32Num );

  • CHugeIntX& CHugeIntX::operator /=( CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::operator %=( CONST UINT32 u32Num );
  • CHugeInt& CHugeInt::operator %=( CONST SINT32 s32Num );

  • CHugeInt& CHugeInt::operator %=( CONST CHugeInt& right );

  • CHugeIntX& CHugeIntX::operator %=( CONST UINT32 u32Num );
  • CHugeIntX& CHugeIntX::operator %=( CONST SINT32 s32Num );

  • CHugeIntX& CHugeIntX::operator %=( CONST CHugeIntX& right );

  • CHugeInt& CHugeInt::DecRShift( CONST UINT32 u32DecRShift );
Parameters
s32Num
[in] 32bit-有符号整数
u32Num
[in] 32bit-无符号整数
left, right
[in] 超大整数
s32Dividend
[in] 被除数；32bit-有符号整数
u32Dividend
[in] 被除数；32bit-无符号整数
hugeDividend
[in] 被除数；超大整数
hugeDivisor
[in] 除数；超大整数
s32Divisor
[in] 除数；32bit-有符号整数
u32Divisor
[in] 除数；32bit-无符号整数
pRemainder
[out] 余数的指针
u32DecRShift
[in] 以 10 为基底右移的位数
Return Values

商 和|或 余数

Remarks
  1. HugeCalc 约定如下：余数的符号与被除数的相同，其绝对值小于除数的绝对值
  2. 直接调用 Div(..) 函数效率比较高，但需注意输入对象不可与输出的对象之一为同一个对象（输入的被除数与除数可以为同一个对象）
  3. DecRShift(..)函数表示十进制超大整数以 10 为基底进行右移
See Also

高精度快速乘法、高精度快速乘方取模


高精度快速位运算
  • CHugeInt& CHugeInt::operator <<=( CONST UINT32 u32BitLShift );
  • CHugeInt& CHugeInt::operator >>=( CONST UINT32 u32BitRShift );

  • CONST CHugeInt CHugeInt::operator <<( CONST UINT32 u32BitLShift ) CONST;
  • CONST CHugeInt CHugeInt::operator >>( CONST UINT32 u32BitRShift ) CONST;

  • CHugeIntX& CHugeIntX::operator <<=( CONST UINT32 u32BitLShift );
  • CHugeIntX& CHugeIntX::operator >>=( CONST UINT32 u32BitRShift );

  • CONST CHugeIntX CHugeIntX::operator <<( CONST UINT32 u32BitLShift ) CONST;
  • CONST CHugeIntX CHugeIntX::operator >>( CONST UINT32 u32BitRShift ) CONST;

  • CHugeInt& CHugeInt::operator &=( CONST CHugeInt& right );
  • CHugeInt& CHugeInt::operator ^=( CONST CHugeInt& right );
  • CHugeInt& CHugeInt::operator |=( CONST CHugeInt& right );

  • CONST CHugeInt CHugeInt::operator &( CONST CHugeInt& right ) CONST;
  • CONST CHugeInt CHugeInt::operator ^( CONST CHugeInt& right ) CONST;
  • CONST CHugeInt CHugeInt::operator |( CONST CHugeInt& right ) CONST;

  • CHugeIntX& CHugeIntX::operator &=( CONST CHugeIntX& right );
  • CHugeIntX& CHugeIntX::operator ^=( CONST CHugeIntX& right );
  • CHugeIntX& CHugeIntX::operator |=( CONST CHugeIntX& right );

  • CONST CHugeIntX CHugeIntX::operator &( CONST CHugeIntX& right ) CONST;
  • CONST CHugeIntX CHugeIntX::operator ^( CONST CHugeIntX& right ) CONST;
  • CONST CHugeIntX CHugeIntX::operator |( CONST CHugeIntX& right ) CONST;

  • 读取超大整数bit数：
    CONST UINT32 CHugeInt::GetBits( VOID ) CONST;
    CONST UINT32 CHugeIntX::GetBits( VOID ) CONST;

  • 读取16进制超大整数bit值：
    CONST BOOL CHugeIntX::IsBitOne( CONST UINT32 u32BitIndex ) CONST;

  • 十进制超大整数“位移”运算：
    CHugeInt& CHugeInt::DecLShift( CONST UINT32 u32DecLShift );
    CHugeInt& CHugeInt::DecRShift( CONST UINT32 u32DecRShift );
Parameters
u32BitLShift
[in] 左移位数
u32BitRShift
[in] 右移位数
right
[in] 超大整数
u32BitIndex
[in] 位索引数
u32DecLShift
[in] 以 10 为基底左移的位数，右端用“0”补齐
u32DecRShift
[in] 以 10 为基底右移的位数
Remarks
  1. HugeCalc 对位运算中符号的规定：将负号视同“1”，否则视作“0”；符号位与符号位进行位运算（举例说明：若一正一负两数进行位运算，“与”运算得正；“或”运算得负；“异或”运算将得到负数）
  2. HugeCalc 虽然不直接提供“~ (Bitwise NOT)”运算，但可以通过如下类似代码获得：“*this ^= ( --( CHugeIntX( (UINT32)1 ) <<= u32NotBits ) ); ” 即可将一个超大整数最后 u32NotBits 位取反
  3. CHugeInt 位运算没有 CHugeIntX 的效率高，因后者具有先天的位运算优势（但前者具有先天的十进制输出优势）
See Also

高精度快速乘法、高精度快速除法（商、余）


高精度快速乘方
  • CHugeInt& Pow( CONST UINT32 u32Exp );
  • CHugeInt& Pow( CONST CHugeInt& hugeBase, CONST UINT32 u32Exp );

  • CHugeIntX& Pow( CONST UINT32 u32Exp );
  • CHugeIntX& Pow( CONST CHugeIntX& hugeBase, CONST UINT32 u32Exp );
Parameters
u32Exp
[in] 指数
hugeBase
[in] 底数
Return Values

幂 = 底数指数

Remarks
  1. 已经过特殊优化，比连乘效率高
  2. HugeCalc 约定如下：00 = 0
  3. HugeCalc 如果预估出幂的输出位数不小于 232 - 1( = 4294967295 )，此时将以“内存不足”为由直接终止计算，即调用 HugeCalc::SetTerminate( TRUE )
  4. 函数 Pow( u32Exp ) 表示对超大整数本身进行乘方运算
See Also

高精度快速乘方取模、高精度快速开方、超大整数快速取对数


高精度快速开方
  • CHugeInt& CHugeInt::Root( CONST CHugeInt& hugeRadicand, CONST UINT32 u32Exp, CHugeInt * CONST pRemainder = NULL, BOOL * CONST pIsReal = NULL );

  • CHugeIntX& CHugeIntX::Root( CONST CHugeIntX& hugeRadicand, CONST UINT32 u32Exp, CHugeIntX * CONST pRemainder = NULL, BOOL * CONST pIsReal = NULL );
Parameters
hugeRadicand
[in] 被开方数
u32Exp
[in] 开方次数
pRemainder
[out] 余数
pIsReal
[out] 根是否为实数
Return Values

hugeRadicand 开 u32Exp 次方的根

Remarks
  1. 当 u32Exp≤1 时，返回 *this = hugeRadicand, *pRemainder = 0
  2. 当且仅当 u32Exp 为奇数且 hugeRadicand < 0 时，*pIsReal = FALSE，否则 *pIsReal = TRUE
  3. 当 *pIsReal = TRUE 时，hugeRadicand = (*this)u32Exp + (*pRemainder)，否则 hugeRadicand = - (*this)u32Exp + (*pRemainder)
See Also

高精度快速乘方、超大整数快速取对数


超大整数快速取对数
  • CONST UINT32 CHugeInt::Log( CONST UINT32 u32Base, BOOL * CONST pIsExact = NULL ) CONST;
  • CONST UINT32 CHugeInt::Log( CONST CHugeInt& hugeBase, BOOL * CONST pIsExact = NULL ) CONST;

  • CONST UINT32 CHugeIntX::Log( CONST UINT32 u32Base, BOOL * CONST pIsExact = NULL ) CONST;
  • CONST UINT32 CHugeIntX::Log( CONST CHugeIntX& hugeBase, BOOL * CONST pIsExact = NULL ) CONST;
Parameters
u32Base、hugeBase
[in] 底（忽略符号）
pIsExact
[out] 是否精确
Return Values

[log|底||*this|]（向下取整）

Remarks
  1. 均以绝对值参与运算
  2. 当 u32Base = 0 时，内部将以 232 为底看待
  3. 如果 |底| < 2，则会终止运行，得到 HCERR_BASE2SMALL 出错代码
  4. 如果 |*this| < |底| 时，则返回 0
  5. 除上述情况，则返回 [log|底||*this|]（向下取整）
See Also

高精度快速乘方、高精度快速开方


高精度快速排列
  • CHugeInt& CHugeInt::Permutation( CONST UINT32 n, CONST UINT32 r );

  • CHugeIntX& CHugeIntX::Permutation( CONST UINT32 n, CONST UINT32 r );
Parameters
n
[in] 集合元素个数
r
[in] 排列元素个数
Return Values

n 元集的 r-排列数

Remarks
  1. n < r 时返回 0
  2. 定义：Permutation( n, r ) = Factorial( n ) / Factorial( n - r )
  3. 将覆盖原有的数据
See Also

高精度快速组合、高精度快速 n!、n!!、n#、素数阶乘


高精度快速组合
  • CHugeInt& CHugeInt::Combination( CONST UINT32 n, CONST UINT32 r );

  • CHugeIntX& CHugeIntX::Combination( CONST UINT32 n, CONST UINT32 r );
Parameters
n
[in] 集合元素个数
r
[in] 组合元素个数
Return Values

n 元集的 r-组合数

Remarks
  1. 定义：Combination( n, r ) = Permutation( n, r ) / Factorial( r )
  2. 将覆盖原有的数据
See Also

高精度快速排列、高精度快速 n!、n!!、n#、素数阶乘


高精度快速 n!、n!!、n#、素数阶乘
  • 高精度快速阶乘（n!）：
    CHugeInt& CHugeInt::Factorial( CONST UINT32 n );
    CHugeIntX& CHugeIntX::Factorial( CONST UINT32 n );

  • 高精度快速双阶乘（n!!）：
    CHugeInt& CHugeInt::Factorial2( CONST UINT32 n );
    CHugeIntX& CHugeIntX::Factorial2( CONST UINT32 n );

  • 高精度快速计算指定自然数内所有素数之积（n#）：
    CHugeInt& CHugeInt::Primorial( CONST UINT32 n );
    CHugeIntX& CHugeIntX::Primorial( CONST UINT32 n );

  • 高精度快速素数阶乘：
    CHugeInt& CHugeInt::PrimeFactorial( CONST UINT32 n );
    CHugeIntX& CHugeIntX::PrimeFactorial( CONST UINT32 n );

Parameters
n
[in] 阶乘数
Return Values

阶乘值

Remarks
  1. Factorial( 0 ) = Factorial2( 0 ) = PrimeFactorial( 0 ) = Primorial( 0 ) = Primorial( 1 ) = 1
  2. Factorial( n ) = n × ( n - 1 ) × ( n - 2 ) × … × 1
  3. Factorial2( n ) = n × ( n - 2 ) × ( n - 4 ) × … × ( 2 or 1 )
  4. PrimeFactorial( n ) = p1 × p2 × … × pn，其中 p1 = 2，p2 = 3，…，pn 为前 n 个素数
  5. Primorial( n ) = PrimeFactorial( HugeCalc::GetPrimePi( n ))，其中 HugeCalc::GetPrimePi( n ) 表示“统计不大于 n 的（正）素数数目”
  6. 显然：当 n > 2 时，PrimeFactorial( n ) > Factorial( n ) > Factorial2( n )；当 n > 7 时，Factorial2( n ) > Primorial( n )
  7. 将覆盖原有的数据
  8. 本类函数经过特别优化，速度非常快
  9. 由 Stirling's Series 可估算出，Factorial( 518678057 )、Factorial2( 1002691940 ) 的十进制位数将约为 232 - 1( = 4294967295 )。如果要计算的值比它们还大，势必会耗用极大的资源，所以此时 HugeCalc 将以“内存不足”为由直接终止计算，即调用 HugeCalc::SetTerminate( TRUE )
See Also

高精度快速排列、高精度快速组合


高精度快速计算 Fibonacci 数列
  • CHugeInt& CHugeInt::Fibonacci( CONST SINT32 n );

  • CHugeIntX& CHugeIntX::Fibonacci( CONST SINT32 n );
Parameters
n
[in] Fibonacci 数列项号
Return Values

第 n 项 Fibonacci

Remarks
  1. Fibonacci( 1 ) = 1, Fibonacci( 2 ) = 1
  2. Fibonacci( n ) = Fibonacci( n - 1 ) + Fibonacci( n - 2 )（n 为任意整数）
  3. Fibonacci( -n ) = (-1)n+1 * Fibonacci( n )（n 为任意整数）
  4. 将覆盖原有的数据
  5. 本函数经过特别优化，速度非常快
See Also

算法库调用手册、高精度快速计算 Lucas 数列


高精度快速计算 Lucas 数列
  • CHugeInt& CHugeInt::Lucas( CONST SINT32 n );

  • CHugeIntX& CHugeIntX::Lucas( CONST SINT32 n );
Parameters
n
[in] Lucas 数列项号
Return Values

第 n 项 Lucas

Remarks
  1. Lucas( 1 ) = 1, Lucas( 2 ) = 3
  2. Lucas( n ) = Lucas( n - 1 ) + Lucas( n - 2 )（n 为任意整数）
  3. Lucas( -n ) = (-1)n * Lucas( n )（n 为任意整数）
  4. 将覆盖原有的数据
  5. 本函数经过特别优化，速度非常快
See Also

算法库调用手册、高精度快速计算 Fibonacci 数列


高精度快速乘积取模
  • CHugeInt& CHugeInt::MulMod( CONST CHugeInt& hugeMultiplicand, CONST CHugeInt& hugeMultiplier, CONST CHugeInt& hugeMod );
  • CHugeInt& CHugeInt::MulMod( CONST CHugeInt& hugeMultiplier, CONST CHugeInt& hugeMod );

  • CHugeIntX& CHugeIntX::MulMod( CONST CHugeIntX& hugeMultiplicand, CONST CHugeIntX& hugeMultiplier, CONST CHugeIntX& hugeMod );
  • CHugeIntX& CHugeIntX::MulMod( CONST CHugeIntX& hugeMultiplier, CONST CHugeIntX& hugeMod );
Parameters
hugeMultiplicand
[in] 被乘数
hugeMultiplier
[in] 乘数
hugeMod
[in] 模
Return Values

被乘数×乘数 mod 模

Remarks
  1. 当“模”== 0 时，将报告 HCERR_DIV_ZERO 出错信息
  2. 函数 MulMod( hugeMultiplier, hugeMod ) 表示对超大整数本身作为一个入参（类似 hugeMultiplicand）进行快速乘积取模计算
See Also

高精度快速乘法、高精度快速除法（商、余）


高精度快速模逆运算
  • CONST UINT32 HugeCalc::InvertMod( CONST UINT32 u32InvertBase, CONST UINT32 u32Mod );

  • CHugeInt& CHugeInt::InvertMod( CONST UINT32 u32InvertBase, CONST CHugeInt& hugeMod );
  • CHugeInt& CHugeInt::InvertMod( CONST CHugeInt& hugeInvertBase, CONST CHugeInt& hugeMod );
  • CHugeInt& CHugeInt::InvertMod( CONST CHugeInt& hugeMod );

  • CHugeIntX& CHugeIntX::InvertMod( CONST UINT32 u32InvertBase, CONST CHugeIntX& hugeMod );
  • CHugeIntX& CHugeIntX::InvertMod( CONST CHugeIntX& hugeInvertBase, CONST CHugeIntX& hugeMod );
  • CHugeIntX& CHugeIntX::InvertMod( CONST CHugeIntX& hugeMod );
Parameters
u32InvertBase
[in] 模逆底数：32bit-无符号整数
u32Mod
[in] 模：32bit-无符号整数
hugeMod
[in] 模：超大整数
hugeInvertBase
[in] 模逆底数：超大整数
Return Values

  • 当 b 与 m 互素时，“InvertMod( b, m )”返回使“( b * x ) mod m = 1”成立的、且与 b 同号的绝对值最小的整数
  • 否则，返回“0”（此时“底数”与“模”不互素，不存在“模逆”）

Remarks
  1. 当“模”== 0 时，将报告 HCERR_DIV_ZERO 出错信息
  2. 注意：当“返回值”== 0 时，表明结果无意义（此时“底数”与“模”不互素，不存在“模逆”）
  3. 函数 InvertMod( hugeMod ) 表示对超大整数本身进行倒数取模运算
See Also

高精度快速乘方、高精度快速除法（商、余）


高精度快速乘方取模（支持负指数）
  • CONST UINT32 HugeCalc::PowMod( CONST UINT32 u32Base, CONST UINT32 u32Exp, CONST UINT32 u32Mod );
  • CONST UINT32 HugeCalc::PowMod( CONST UINT32 u32Base, CONST SINT32 s32Exp, CONST UINT32 u32Mod );

  • CONST UINT32 PowMod( CONST UINT32 u32Base, CONST CHugeIntX& hugeExp, CONST UINT32 u32Mod );
  • CONST SINT64 PowMod( CONST CHugeIntX& hugeBase, CONST UINT32 u32Exp, CONST UINT32 u32Mod );
  • CONST SINT64 PowMod( CONST CHugeIntX& hugeBase, CONST SINT32 s32Exp, CONST UINT32 u32Mod );
  • CONST SINT64 PowMod( CONST CHugeIntX& hugeBase, CONST CHugeIntX& hugeExp, CONST UINT32 u32Mod );

  • CHugeInt& CHugeInt::PowMod( CONST UINT32 u32Base, CONST UINT32 u32Exp, CONST CHugeInt& hugeMod );
  • CHugeInt& CHugeInt::PowMod( CONST SINT32 s32Base, CONST UINT32 u32Exp, CONST CHugeInt& hugeMod );
  • CHugeInt& CHugeInt::PowMod( CONST UINT32 u32Base, CONST CHugeInt& hugeExp, CONST CHugeInt& hugeMod );
  • CHugeInt& CHugeInt::PowMod( CONST CHugeInt& hugeBase, CONST UINT32 u32Exp, CONST CHugeInt& hugeMod );
  • CHugeInt& CHugeInt::PowMod( CONST CHugeInt& hugeBase, CONST SINT32 s32Exp, CONST CHugeInt& hugeMod );
  • CHugeInt& CHugeInt::PowMod( CONST CHugeInt& hugeBase, CONST CHugeInt& hugeExp, CONST CHugeInt& hugeMod );

  • CONST UINT32 PowMod( CONST UINT32 u32Base, CONST CHugeIntX& hugeExp, CONST UINT32 u32Mod );
  • CONST SINT64 PowMod( CONST CHugeIntX& hugeBase, CONST UINT32 u32Exp, CONST UINT32 u32Mod );
  • CONST SINT64 PowMod( CONST CHugeIntX& hugeBase, CONST SINT32 s32Exp, CONST UINT32 u32Mod );
  • CONST SINT64 PowMod( CONST CHugeIntX& hugeBase, CONST CHugeIntX& hugeExp, CONST UINT32 u32Mod );

  • CHugeIntX& CHugeIntX::PowMod( CONST UINT32 u32Base, CONST UINT32 u32Exp, CONST CHugeIntX& hugeMod );
  • CHugeIntX& CHugeIntX::PowMod( CONST SINT32 s32Base, CONST UINT32 u32Exp, CONST CHugeIntX& hugeMod );
  • CHugeIntX& CHugeIntX::PowMod( CONST UINT32 u32Base, CONST CHugeIntX& hugeExp, CONST CHugeIntX& hugeMod );
  • CHugeIntX& CHugeIntX::PowMod( CONST CHugeIntX& hugeBase, CONST UINT32 u32Exp, CONST CHugeIntX& hugeMod );
  • CHugeIntX& CHugeIntX::PowMod( CONST CHugeIntX& hugeBase, CONST SINT32 s32Exp, CONST CHugeIntX& hugeMod );
  • CHugeIntX& CHugeIntX::PowMod( CONST CHugeIntX& hugeBase, CONST CHugeIntX& hugeExp, CONST CHugeIntX& hugeMod );

  • CHugeInt& CHugeInt::ModPowTen( CONST UINT32 u32Exp );

  • CHugeInt& CHugeIntX::ModPowTwo( CONST UINT32 u32Exp );
Parameters
u32Base、s32Base
[in] 底数：32bit-整数
hugeBase
[in] 底数：超大整数
u32Exp、s32Exp
[in] 指数：32bit-整数
hugeExp
[in] 指数：超大整数
u32Mod
[in] 模：32bit-无符号整数
hugeMod
[in] 模：超大整数
u32Exp
[in] 模幂(10 or 2)的指数
Return Values

底数指数 mod 模

Remarks
  1. 当“模”== 0 时，将报告 HCERR_DIV_ZERO 出错信息
  2. 关于该类函数，有如下通用规则：
    • br mod (-m) = br mod m
    • b0 mod m = 1；(-1)r mod m = 1（r为偶数时）；(-1)r mod m = -1（r为奇数时）
    • ( b1r mod m ) * ( b2r mod m ) ≡ ( b1 * b2 )r mod m
    • ( br1 mod m ) * ( br2 mod m ) ≡ b( r1 + r2 ) mod m
    • ( br1 mod m )r2 mod m = ( br2 mod m )r1 mod m = b( r1 * r2 ) mod m
  3. 关于各参数符号的处理，有如下规则（可从上述通用规则中推导出）：
    • “模”取相反数，值保持不变
    • 结果为负的必要条件为：“底数”为负数且“指数”为奇数
    • 同底同模但指数互为相反数，则其结果互为关于该模的数论倒数
  4. 当“指数”< 0 时，内部将调用InvertMod(..)函数
  5. 注意：当“指数”< 0，且“返回值”== 0 时，表明结果无意义（此时“底数”与“模”不互素，不存在“模逆”）
See Also

高精度快速乘方、高精度快速除法（商、余）、高精度快速模逆运算


高精度快速求最大公约数（支持群组运算）
  • CONST UINT32 HugeCalc::Gcd( CONST UINT32 u32Num1, CONST UINT32 u32Num2 );
  • CONST UINT32 HugeCalc::Gcd( CONST SINT32 s32Num, CONST UINT32 u32Num );
  • CONST UINT32 HugeCalc::Gcd( CONST UINT32 u32Num, CONST SINT32 s32Num );
  • CONST UINT32 HugeCalc::Gcd( CONST SINT32 s32Num1, CONST SINT32 s32Num2 );

  • CONST UINT32 HugeCalc::Gcd( CONST CVECTOR_UINT32& vU32Num );

  • CHugeInt& CHugeInt::Gcd( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CHugeInt& CHugeInt::Gcd( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CHugeInt& CHugeInt::Gcd( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CHugeInt& CHugeInt::Gcd( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CHugeInt& CHugeInt::Gcd( CONST CHugeInt& left, CONST CHugeInt& right );

  • CHugeInt& CHugeInt::Gcd( CONST CVECTOR_HHUGEINT& vLpHugeInt );

  • CHugeIntX& CHugeIntX::Gcd( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CHugeIntX& CHugeIntX::Gcd( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CHugeIntX& CHugeIntX::Gcd( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CHugeIntX& CHugeIntX::Gcd( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CHugeIntX& CHugeIntX::Gcd( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CHugeIntX& CHugeIntX::Gcd( CONST CVECTOR_HHUGEINTX& vLpHugeIntX );
Parameters
u32-
[in] 32bit-无符号整数
s32-
[in] 32bit-有符号整数
left、right
[in] 超大整数
vU32Num
[in] 32bit-无符号整数数组
vLpHugeInt、vLpHugeIntX
[in] 超大整数指针数组
Return Values

最大公约数

Remarks
  1. HugeCalc 约定如下：
    • “0”参与无效约定：数列中去掉任意个“0”后求 Gcd，值保持不变
    • 返回值非负约定：0 ≤ 任意数列的 Gcd() ≤ 该数列非零元素绝对值的最小值；特别地，空数列的 Gcd() = 0
  2. 如果返回超大整数，注意不要与输入对象之一相同（否则不作任何运算）
  3. 将覆盖原有的数据
See Also

常量/结构定义、高精度快速计算扩展最大公约数、高精度快速求最小公倍数（支持群组运算）


高精度快速计算扩展最大公约数
  • CONST UINT32 HugeCalc::GcdEx( SINT32& x, SINT32& y, CONST SINT32 u, CONST SINT32 v );

  • CHugeInt& CHugeInt::GcdEx( CHugeInt& x, CHugeInt& y, CONST CHugeInt& u, CONST CHugeInt& v );

  • CHugeIntX& CHugeIntX::GcdEx( CHugeIntX& x, CHugeIntX& y, CONST CHugeIntX& u, CONST CHugeIntX& v );
Parameters
x、y
[out] 输出的系数
u、v
[in] 输入的整数
Return Values

u、v 的最大公约数

Remarks
  1. GcdEx: g = GcdEx( x, y, u, v ) = u * x + v * y. 其中 g 永远非负，无论 u、v 中有一个或全部为负数
  2. 如果返回超大整数，注意不要与输入对象之一相同（否则不作任何运算）
  3. 将覆盖原有的数据
See Also

高精度快速求最大公约数（支持群组运算）


高精度快速求最小公倍数（支持群组运算）
  • CONST UINT64 HugeCalc::Lcm( CONST UINT32 u32Num1, CONST UINT32 u32Num2 );
  • CONST UINT64 HugeCalc::Lcm( CONST SINT32 s32Num, CONST UINT32 u32Num );
  • CONST UINT64 HugeCalc::Lcm( CONST UINT32 u32Num, CONST SINT32 s32Num );
  • CONST UINT64 HugeCalc::Lcm( CONST SINT32 s32Num1, CONST SINT32 s32Num2 );

  • CHugeInt& CHugeInt::Lcm( CONST CVECTOR_UINT32& vU32Num );

  • CHugeInt& CHugeInt::Lcm( CONST UINT32 u32Num, CONST CHugeInt& right );
  • CHugeInt& CHugeInt::Lcm( CONST SINT32 s32Num, CONST CHugeInt& right );

  • CHugeInt& CHugeInt::Lcm( CONST CHugeInt& left, CONST UINT32 u32Num );
  • CHugeInt& CHugeInt::Lcm( CONST CHugeInt& left, CONST SINT32 s32Num );

  • CHugeInt& CHugeInt::Lcm( CONST CHugeInt& left, CONST CHugeInt& right );

  • CHugeInt& CHugeInt::Lcm( CONST CVECTOR_HHUGEINT& vLpHugeInt );

  • CHugeIntX& CHugeIntX::Lcm( CONST CVECTOR_UINT32& vU32Num );

  • CHugeIntX& CHugeIntX::Lcm( CONST UINT32 u32Num, CONST CHugeIntX& right );
  • CHugeIntX& CHugeIntX::Lcm( CONST SINT32 s32Num, CONST CHugeIntX& right );

  • CHugeIntX& CHugeIntX::Lcm( CONST CHugeIntX& left, CONST UINT32 u32Num );
  • CHugeIntX& CHugeIntX::Lcm( CONST CHugeIntX& left, CONST SINT32 s32Num );

  • CHugeIntX& CHugeIntX::Lcm( CONST CHugeIntX& left, CONST CHugeIntX& right );

  • CHugeIntX& CHugeIntX::Lcm( CONST CVECTOR_HHUGEINTX& vLpHugeIntX );
Parameters
u32-
[in] 32bit-无符号整数
s32-
[in] 32bit-有符号整数
left、right
[in] 超大整数
vU32Num
[in] 32bit-无符号整数数组
vLpHugeInt、vLpHugeIntX
[in] 超大整数指针数组
Return Values

最小公倍数

Remarks
  1. HugeCalc 约定如下：
    • “0”参与无效约定：数列中去掉任意个“0”后求 Lcm，值保持不变
    • 返回值非负约定：任意数列的 Lcm() ≥ 该数列各元素绝对值的最大值；特别地，空数列的 Lcm() = 0
  2. 如果返回超大整数，注意不要与输入对象之一相同（否则不作任何运算）
  3. 将覆盖原有的数据
See Also

常量/结构定义、高精度快速求最大公约数（支持群组运算）


高精度快速“等幂和”（支持群组运算）
  • CHugeInt& SumsOfLikePowers( CONST CVECTOR_UINT32& vU32Num, CONST UINT32 u32Exp = 1 );
  • CHugeInt& SumsOfLikePowers( CONST CVECTOR_HHUGEINT& vLpHugeInt, CONST UINT32 u32Exp = 1 );

  • CHugeIntX& SumsOfLikePowers( CONST CVECTOR_UINT32& vU32Num, CONST UINT32 u32Exp = 1 );
  • CHugeIntX& SumsOfLikePowers( CONST CVECTOR_HHUGEINTX& vLpHugeIntX, CONST UINT32 u32Exp = 1 );
Parameters
vU32Num
[in] 32bit-无符号整数数组
vLpHugeInt、vLpHugeIntX
[in] 超大整数指针数组
u32Exp
[in] 设定幂次
Return Values

等幂和

Remarks
  1. 当 u32Exp == 0 时，计算积（内部直接调用：Product(..)）
  2. 如果返回超大整数，注意不要与输入对象之一相同（否则不作任何运算）
  3. 将覆盖原有的数据
See Also

常量/结构定义、高精度快速乘方、高精度快速加法


高精度快速任意进制转换
  • explicit CHugeInt::CHugeInt( CONST CHugeIntX& right );
  • explicit CHugeIntX::CHugeIntX( CONST CHugeInt& right );

  • explicit CHugeInt::CHugeInt( CONST CRadixConverter& RadixConverter );
  • explicit CHugeIntX::CHugeIntX( CONST CRadixConverter& RadixConverter );

  • CHugeInt& CHugeInt::operator =( CONST CHugeIntX& right );
  • CHugeIntX& CHugeIntX::operator =( CONST CHugeInt& right );

  • CHugeInt& CHugeInt::operator =( CONST CRadixConverter& RadixConverter );
  • CHugeIntX& CHugeIntX::operator =( CONST CRadixConverter& RadixConverter );

  • CONST LPCTSTR CHugeInt::GetStrRadix( CONST UINT32 u32Radix = 16, UINT32 * CONST pDigits = NULL, CONST BYTE byFormat = FS_DEFAULT, CONST UINT32 u32BandLength = 4, UINT32 * CONST pStrLen = NULL ) CONST;

  • CONST LPCTSTR CHugeIntX::GetStrRadix( CONST UINT32 u32Radix = 10, UINT32 * CONST pDigits = NULL, CONST BYTE byFormat = FS_DEFAULT, CONST UINT32 u32BandLength = 3, UINT32 * CONST pStrLen = NULL ) CONST;
Parameters
right
[in] 超大整数
RadixConverter
[in|out] 进制转换数据结构
u32Radix
[in] 转换成进制数
pDigits
[out] 进制转换后的位数
byFormat
[in] 输出格式设定
u32BandLength
[in] 分节的节长
pStrLen
[out] 输出字串长度
Return Values

分别为超大整数、超大整数、进制转换输出字串指针。

Remarks
  1. 借助上述函数，及专门的基数变换器CRadixConverter可快速方便地将数在任意进制下相互转换
  2. 当 u32Radix = 0 时，内部将以 232 为基数（进制数）看待
  3. “GetStrRadix(..)”可将任意超大整数转化成其它基数（进制数），规则如下：
    • 当 u32Radix = 0 时，内部将以 232 为基数（进制数）看待
    • 当 1 < u32Radix ≤ 10 时，忽略所有非数字字符
    • 当 10 < u32Radix ≤ 36 时，依 byFormat 的大小写标志位设定而用“A-Z”或“a-z”依次代表 10-35
    • 当 36 < u32Radix ≤ 62 时，A-Z 依次代表 10-35；a-z 依次代表 36-61
    • 当 u32Radix > 62 时，将用类似 “[001] [002]”等字样精确输出转换后的字串
  4. 当 u32BandLength == 0 时，忽略分段显示标志
  5. FreeStrBuffer(..) 可及时回收输出字串空间；析构函数亦会自动调用
See Also

常量/结构定义、基数变换器、初始化超大整数、高精度赋值、强大而灵活的输出


超大整数素性快速检测
  • CONST PRIMALITY CHugeInt::TestPrimality( CONST UINT32 u32Repeat = 5 ) CONST;
  • CONST PRIMALITY CHugeIntX::TestPrimality( CONST UINT32 u32Repeat = 5 ) CONST;
  • CONST BOOL HugeCalc::IsPrime( CONST UINT32 u32Num );
  • CONST BOOL CHugeInt::IsPrime( VOID ) CONST;
  • CONST BOOL CHugeIntX::IsPrime( VOID ) CONST;
Parameters
u32Num
[in] 待判定整数
u32Repeat
[in] 检测次数（默认值：5）
Return Values

是否为素数：TRUE-素数；FALSE-非素数
超大整数绝对值的素性：COMPOSITE—确定为合数；PROBABLY_PRIME—极可能为素数；PRIME—肯定为素数

Remarks
  1. 整数的素性检测与符号无关
  2. HugeCalc 内部采用的素性检测算法有：
    • 形如 2^p-1 的梅森数（Mersenne number）用 Lucas-Lehmer Test
    • 1016 以内的数进行严格判定
    • 1024 以内小素数因子排除法
    • Rabin-Miller Strong Pseudoprime Test
    • Extra Strong Lucas Pseudoprime Test
  3. TestPrimality(..) 用到了上述除Extra Strong Lucas Pseudoprime Test外的所有算法；其中Rabin-Miller Strong Pseudoprime Test的测试次数由用户设定的 u32Repeat（默认值 = 5）决定，且采用的 2～n-2 的随机数为测试基；如果该值 u32Repeat = 0，（将）进行高强度严格测试
  4. TestPrimality(..) 的返回值约定如下：
    • 当超大整数值为“0”时，返回：COMPOSITE
    • 当超大整数值为“±1”时，返回：PROBABLY_PRIME
    • 返回“PRIME”的前提条件为满足下列条款之一：
      • 该值绝对值≤1016
      • 形如 2^p-1 的梅森素数（即 Mersenne Prime；为节省用户时间，程序中对已确知的 44 个梅森素数免于判定）
      • 入参 u32Repeat 为 0 时
  5. TestPrimality(..) 的结果是非稳定的（因为它采用随机数为基进行测试）：即当某次测试为PROBABLY_PRIME的合数，可能再次测试就是COMPOSITE。也就是说，当返回值为PROBABLY_PRIME时若多次调用可以增加可信度；而一旦被判为COMPOSITE则可以肯定是合数了
  6. IsPrime() 依序用到了上述全部算法；其中Rabin-Miller Strong Pseudoprime Test采用了以 2（、3）为基底的测试
  7. IsPrime() 的结果是稳定的；它进行了极高强度的素性检测，但仍可能将合数误判为“素数”；但这种概率极低，迄今尚未发现反例（如果您有幸发现了一例，那么恭喜您，这比买彩票中特等奖还要不易；请记得通知软件开发者与您分享这份喜悦！）
See Also

常量/结构定义、生成随机超大（素）整数、快速生成最邻近素数


生成随机超大（素）整数
  • 设定随机发生器种子：
    VOID HugeCalc::SeedRandom( CONST UINT32 u32Seed = 0 );

  • 生成随机超大整数：
    CHugeInt& CHugeInt::Random( CONST UINT32 u32DecDigits );
    CHugeIntX& CHugeIntX::Random( CONST UINT32 u32Bits );

  • 生成随机超大素数：
    CHugeInt& CHugeInt::GeneratePrime( CONST UINT32 u32DecDigits );
    CHugeIntX& CHugeIntX::GeneratePrime( CONST UINT32 u32Bits );

Parameters
u32Seed
[in] 设定随机发生器种子数
u32DecDigits
[in] 十进制下的位数
u32Bits
[in] 二进制下的位数
Return Values

随机性的超大（素）整数

Remarks
  1. GeneratePrime(..) 内部调用的函数是 IsPrime() 检测（检测强度比 Mathematica 5.2 所用更大）
  2. 该组函数为数论和加解密研究提供了极大便利，如 RSA 加密算法
See Also

超大整数素性快速检测、快速生成最邻近素数


快速生成最邻近素数
  • 得到更小的最邻近素数：
    CONST SINT32 HugeCalc::PreviousPrime( CONST SINT32 s32Benchmark );

    CHugeInt& CHugeInt::PreviousPrime( CONST CHugeInt& hBenchmark );
    CHugeIntX& CHugeIntX::PreviousPrime( CONST CHugeIntX& hBenchmark );

  • 得到更大的最邻近素数：
    CONST SINT32 HugeCalc::NextPrime( CONST SINT32 s32Benchmark );

    CHugeInt& CHugeInt::NextPrime( CONST CHugeInt& hBenchmark );
    CHugeIntX& CHugeIntX::NextPrime( CONST CHugeIntX& hBenchmark );
Parameters
s32Benchmark
[in] 基准32bit有符号整数
hBenchmark
[in] 基准超大整数
Return Values

更小的/更大的 最邻近素数

Remarks
  1. 注意：基准数的符号参与运算，并决定返回值的绝对值是偏大还是偏小，举例如下：
    。。。
    PreviousPrime( n ) = -5，当 -5 < n ≤ -3 时，
    PreviousPrime( n ) = -3，当 n = -2 时，
    PreviousPrime( n ) = -2，当 -2 < n ≤ 2 时，
    PreviousPrime( n ) = 2，当 n = 3 时，
    PreviousPrime( n ) = 3，当 3 < n ≤ 5 时，
    。。。
    NextPrime( n ) = -3，当 -5 ≤ n < -3 时，
    NextPrime( n ) = -2，当 n = -3 时，
    NextPrime( n ) = 2，当 -2 ≤ n < 2 时，
    NextPrime( n ) = 3，当 n = 2 时，
    NextPrime( n ) = 5，当 3 ≤ n < 5 时，
    。。。
  2. 注意到“SINT32”可表达的范围是有限的（[ -2147483648, 2147483647 ]）。对于“溢出”情况，HugeCalc 约定如下：
    • 当发生“正溢出”时，返回“+1”：即当 s32Benchmark = 2147483647 时，HugeCalc::NextPrime( s32Benchmark ) = +1
    • 当发生“负溢出”时，返回“-1”：即当 s32Benchmark = -2147483648 or -2147483647 时，HugeCalc::PreviousPrime( s32Benchmark ) = -1
  3. 返回数据的“素性检测” 调用的函数是 IsPrime() 检测（检测强度比 Mathematica 5.2 所用更大）
  4. 这里的入参均声明成“CONST”，但与HugeCalc其它函数不同的是：“A.NextPrime( B )”的意义是生成比“B”更大的素数“A”，对入参的CONST限定仅表明对入参进行保护，程序内部特意没有做“A非B”的检查，以便用户可以通过反复调用“A.NextPrime( A )”而得到一个类似超大素数发生器的工具；对于函数“PreviousPrime(..)”亦类似
See Also

超大整数素性快速检测、生成随机超大（素）整数


快速获取素数数列
  • 判定 u32Num 是否为素数：
    CONST BOOL HugeCalc::IsPrime( CONST UINT32 u32Num );

  • 统计不大于 u32Num 的（正）素数数目：
    CONST UINT32 HugeCalc::GetPrimePi( CONST UINT32 u32Num );

  • 获取第 u32Index 个（正）素数
    CONST UINT32 HugeCalc::GetPrime( CONST UINT32 u32Index );

  • 统计 [u32LBound, u32UBound] 内素数数目：
    CONST UINT32 HugeCalc::GetPrimeCount( CONST UINT32 u32LBound, CONST UINT32 u32UBound );

  • 获取 [u32LBound, u32UBound] 内素数清单：
    CONST UINT32 HugeCalc::GetPrimeList( UINT32 * CONST lpPrimeBuffer, CONST UINT32 u32LBound, CONST UINT32 u32UBound );
Parameters
u32Num
[in] 设定统计素数的上限
u32Index
[in] 设定素数序号
u32LBound
[in] 设定范围下限
u32UBound
[in] 设定范围上限
lpPrimeBuffer
[out] 存储素数缓冲区地址
u32BufferSize
[in] 素数缓冲区长度
Return Values

素数与否 / π(u32Num) / 第 u32Index 个（正）素数 / [ u32LBound, u32UBound ] 范围内素数数目 / 实际获取素数列表元素数目

Remarks
  1. 注意到“UINT32”可表达的范围是有限的（[ 0, 4294967295 ]）。HugeCalc 约定如下：
    • GetPrimePi( 0 or 1 ) = 0；GetPrimePi( 2 ) = 1；...；GetPrimePi( 4294967295 ) = 203280221
    • GetPrime( 0 ) = 1；GetPrime( 1 ) = 2；...；GetPrime( 203280221 ) = 4294967291；当 u32Index > 203280221 时，GetPrime( u32Index ) = +1（表示“溢出”）
  2. 调用 GetPrimeList(..) 时，请先开辟一个适当大小的缓冲区（大小可由函数 GetPrimeCount(..) 迅速精确获得）
  3. 当实际素数列表元素小于或等于 u32BufferSize 时，将素数列表复制到缓冲区前端，多余部分保持不变
  4. 当实际素数列表元素大于 u32BufferSize 时，将素数列表前端 u32BufferSize 个元素复制到缓冲区中，并返回 u32BufferSize
  5. 该组函数经过高度优化，速度非常快，可从作者另开发的 PrimeNumber.exe 独立版本中进行体验（同时该软件现已可通过动态调用 HugeCalc.dll 产生大素数）
  6. 该组功能使用权限完全开放，即便是对未注册用户
See Also

快速生成最邻近素数、生成随机超大（素）整数


超大整数属性读取
  • 读取超大整数符号：
    CONST SIGN CHugeInt::GetSign( VOID ) CONST;
    CONST SIGN CHugeIntX::GetSign( VOID ) CONST;
    CONST SIGN CRadixConverter::GetSign( VOID ) CONST;

  • 判断超大整数是否为零：
    CONST BOOL CHugeInt::operator !( VOID ) CONST;
    CONST BOOL CHugeIntX::operator !( VOID ) CONST;

  • 判断超大整数是否为±1：
    CONST BOOL CHugeInt::IsAbsOne( VOID ) CONST;
    CONST BOOL CHugeIntX::IsAbsOne( VOID ) CONST;

  • 判断超大整数是否为奇数：
    CONST BOOL CHugeInt::IsOdd( VOID ) CONST;
    CONST BOOL CHugeIntX::IsOdd( VOID ) CONST;

  • 判断超大整数是否为偶数：
    CONST BOOL CHugeInt::IsEven( VOID ) CONST;
    CONST BOOL CHugeIntX::IsEven( VOID ) CONST;

  • 判断超大整数可否并转化为32bit有符号整数（如超出范围则返回“0”）：
    CHugeInt::operator CONST SINT32( VOID ) CONST;
    CHugeIntX::operator CONST SINT32( VOID ) CONST;

  • 判断超大整数可否并转化为64bit有符号整数（如超出范围则返回“0”）：
    CHugeInt::operator CONST SINT64( VOID ) CONST;
    CHugeIntX::operator CONST SINT64( VOID ) CONST;

  • 判断超大整数可否并转化为32bit无符号整数（如超出范围则返回“0”）：
    CHugeInt::operator CONST UINT32( VOID ) CONST;
    CHugeIntX::operator CONST UINT32( VOID ) CONST;

  • 判断超大整数可否并转化为64bit无符号整数（如超出范围则返回“0”）：
    CHugeInt::operator CONST UINT64( VOID ) CONST;
    CHugeIntX::operator CONST UINT64( VOID ) CONST;

  • 读取超大整数位数：
    CONST UINT32 CHugeInt::GetDigits( VOID ) CONST;
    CONST UINT32 CHugeIntX::GetDigits( VOID ) CONST;

  • 读取超大整数bit数：
    CONST UINT32 CHugeInt::GetBits( VOID ) CONST;
    CONST UINT32 CHugeIntX::GetBits( VOID ) CONST;

  • 读取超大整数尾部连续“0”的数目：
    CONST UINT32 CHugeInt::GetTailDecZeros( VOID ) CONST;
    CONST UINT32 CHugeIntX::GetTailBitZeros( VOID ) CONST;

  • 读取16进制超大整数bit值：
    CONST BOOL CHugeIntX::IsBitOne( CONST UINT32 u32BitIndex ) CONST;
See Also

常量/结构定义


自由指定有效位运算
  • CHugeInt& CHugeInt::Ceil( CONST UINT32 u32DecPrecision );
  • CHugeInt& CHugeInt::Truncate( CONST UINT32 u32DecPrecision );
  • CHugeInt& CHugeInt::Floor( CONST UINT32 u32DecPrecision );

  • CHugeIntX& CHugeIntX::Ceil( CONST UINT32 u32BinPrecision );
  • CHugeIntX& CHugeIntX::Truncate( CONST UINT32 u32BinPrecision );
  • CHugeIntX& CHugeIntX::Floor( CONST UINT32 u32BinPrecision );
Parameters
u32DecPrecision
[in] 指定的十进制有效位数
u32BinPrecision
[in] 指定的二进制有效位数
Return Values

原超大整数按指定的有效位数后的数据

Remarks
  1. HugeCalc 约定如下：u32DecPrecision == 0 或 u32BinPrecision == 0 时，表明用无限精度（即：完全精度），将直接返回原超大整数
  2. 注意：u32DecPrecision、u32BinPrecision 均从高位第一个非零数位算起，向右数到指定的位数。该“位数” 对 CHugeInt 来说是指十进制的“Digits”；对 CHugeIntX 来说是指二进制的“Bits”；如实际位数小于指定位数直接返回原超大整数
  3. 三个函数的意义如下：
    • Ceil(..) 将得到原数按指定的有效位数后，且不小于原数的超大整数
    • Truncate(..) 将得到原数按指定的有效位数后，且绝对值不大于原数的超大整数（符号保持不变）
    • Floor(..) 将得到原数按指定的有效位数后，且不大于原数的超大整数
  4. 该类公共函数的导出，可方便进行一些多精度运算，以便进一步扩展
See Also

高精度快速乘方取模、高精度快速开方、超大整数快速取对数


强大而灵活的输出
  • CONST LPCTSTR CHugeInt::GetStr( CONST BYTE byFormat = FS_DEFAULT, UINT32 * CONST pStrLen = NULL ) CONST;

  • CONST LPCTSTR CHugeIntX::GetStr( CONST BYTE byFormat = FS_DEFAULT, UINT32 * CONST pStrLen = NULL ) CONST;

  • CONST LPCTSTR CHugeInt::GetHexStr( CONST BYTE byFormat = FS_DEFAULT, UINT32 * CONST pStrLen = NULL ) CONST;

  • CONST LPCTSTR CHugeIntX::GetHexStr( CONST BYTE byFormat = FS_DEFAULT, UINT32 * CONST pStrLen = NULL ) CONST;

  • CONST LPCTSTR CHugeInt::GetStrRadix( CONST UINT32 u32Radix = 16, UINT32 * CONST pDigits = NULL, CONST BYTE byFormat = FS_DEFAULT, CONST UINT32 u32BandLength = 4, UINT32 * CONST pStrLen = NULL ) CONST;

  • CONST LPCTSTR CHugeIntX::GetStrRadix( CONST UINT32 u32Radix = 10, UINT32 * CONST pDigits = NULL, CONST BYTE byFormat = FS_DEFAULT, CONST UINT32 u32BandLength = 3, UINT32 * CONST pStrLen = NULL ) CONST;

  • CONST LPCTSTR CHugeIntX::GetText( VOID ) CONST;

  • CHugeInt::operator CONST LPCTSTR( VOID ) CONST;

  • CHugeIntX::operator CONST LPCTSTR( VOID ) CONST;

  • VOID CHugeInt::FreeStrBuffer( VOID ) CONST;
  • VOID CHugeIntX::FreeStrBuffer( VOID ) CONST;
Parameters
byFormat
[in] 输出格式设定
pStrLen
[out] 输出字串长度
u32Radix
[in] 转换成进制数
pDigits
[out] 进制转换后的位数
u32BandLength
[in] 分节的节长
Remarks
  1. 函数 GetStrRadix(..) 的表现行为，与 u32Radix 取值相关：
    • 当 u32Radix = 1 时，将会得到 HCERR_RADIX2SMALL 的出错代码
    • 当 1 < u32Radix ≤ 10 时，输出不含字母
    • 当 10 < u32Radix ≤ 36 时，用字符集 [0-9A-Z] 或 [0-9a-z]（由 byFormat 相关位决定大小写）精确输出转换后的字串
    • 当 36 < u32Radix ≤ 62 时，A-Z 依次代表 10-35；a-z 依次代表 36-61
    • 其它（当 u32Radix = 0 时，内部将以 232 看待）：则将用类似 “[001] [002]”等字样精确输出转换后的字串
  2. 当 u32BandLength == 0 时，忽略分段显示标志
  3. 函数 GetHexStr(..) 将以十六进制输出，但不含“0x”或“0X”标记
  4. 如果一个超大整数变量 hugeNum 为 CHugeInt 类型，则“(LPCTSTR)hugeNum”等同于“hugeNum.GetStr( FS_NORMAL, NULL )”
  5. 如果一个超大整数变量 hugeNum 为 CHugeIntX 类型，则“(LPCTSTR)hugeNum”等同于“hugeNum.GetHexStr( FS_NORMAL, NULL )”
  6. 技巧提示：将一个 dwNum 显示成用“,”号千位分隔的形式，可调用 CHugeInt( (UINT32)dwNum ).GetStr( FS_BAND )。
  7. 当 HugeCalc 未注册时，转换时将有延时或随机干扰，具体请参见：未注册用户的限制
  8. FreeStrBuffer() 可及时回收输出字串空间；析构函数亦会自动调用
  9. 为了节省资源，当超大整数变量值发生变化时，内部可能会自动调用 FreeStrBuffer() 以释放输出字串空间；所以，当得到输出字串指针后请及时使用，否则其指向的空间可能因已销毁而无效
See Also

常量/结构定义、加解密字串处理、高精度快速任意进制转换、加解密字串处理、高精度计时器


加解密字串处理
  • 将待加密字串以内码方式复制为超大整数：
    CHugeIntX& CHugeIntX::SetText( CONST LPCTSTR lpszText );

  • 将超大整数以内码方式转换为解密字串：
    CONST LPCTSTR CHugeIntX::GetText( VOID ) CONST;
Parameters
lpszText
[in] 以 NULL 结尾的待加密字串
Remarks
  1. 该组函数为数论和加解密研究提供了极大便利；它的一般调用流程是：SetText() --> 加密 --> 解密 --> GetText()
  2. 在MBCS系统中，内码以单字节切分；在UNICODE系统中，内码以双字节切分
  3. 顺序：从字串尾部由右至左对应于超大整数的低位到高位
See Also

高精度赋值、强大而灵活的输出


高精度计时器

高精度计时器（有暂停、累计、复位等功能）
  • 设定高精度计时器 On/Off：
    VOID HugeCalc::EnableTimer( CONST BOOL bEnableTimer = TRUE );

  • 高精度计时器复位：
    VOID HugeCalc::ResetTimer( CONST UINT32 u32Timer = 0, CONST TimerUnit enumTimerUnit = TIMER_UNIT_us );

  • 读取高精度计时器计数：
    CONST UINT32 HugeCalc::GetTimer( CONST TimerUnit enumTimerUnit = TIMER_UNIT_us );

  • 输出高精度计时器读数：
    CONST LPCTSTR HugeCalc::GetTimerStr( CONST FormatTime enumFormatTime = FT_DOT06SEC_s );
Parameters
bEnableTimer
[in] （同时）设置高精度计时器 On/Off
u32Timer
[in] 设置高精度计时器读数（可设定单位：毫秒/微秒/纳秒）
enumTimerUnit
[in] 设置高精度计时器读数单位（默认为：微秒）
enumFormatTime
[in] 设置高精度计时器显示格式（现提供四种模式选择）
Remarks
  1. 本高精度计时器有三种精度可设置：毫秒/微秒/纳秒，由于受数据存储能力所限，最大输出为 232 - 1( = 4294967295 )，即依次可记录的范围分别约为：49.71 天、1.19 小时、4.29 秒，否则将会溢出，请根据需要合理选择单位
  2. 函数 HugeCalc::GetTimerStr(..) 中，
    • 当参数为 FT_HHMMSS_ms 时，以“HH:MM:SS.MSEL”格式显示，最大显示能力为 “99:59:59.999”，即≤359999999ms（约 4.16 天）
    • 当参数为 FT_DOT06SEC 时，则显示一个以“秒”为单位，小数点后保留六位精度的数值（相当于精确到“微秒”级）
    • 当参数为 FT_DOT06SECs 时，则在上述数字后追加一个“s”字符
    • 当参数为 FT_DOT06SEC_s 时，则在上述数字与“s”字符中插入一个空格
  3. 如果不需要累计计时，请注意需调用 HugeCalc::ResetTimer()
  4. 建议：在运算前调用 HugeCalc::EnableTimer( TRUE ) 开始计时，计算中调用 HugeCalc::GetTimer(Str)(..) 显示计时，计算结束后调用 HugeCalc::EnableTimer( FALSE ) 停止计时
  5. 本高精度计时器的使用权限完全开放，即便是对未注册用户
See Also

常量/结构定义、全局函数


一些数论函数
  • 欧拉函数：gives the Euler totient function φ(n).
    CONST UINT32 EulerPhi( CONST UINT32 n );

  • 雅可比符号：gives the Jacobi symbol(n/m).
    CONST SINT32 JacobiSymbol( CONST UINT32 n, CONST UINT32 m );

  • 指数：gives the multiplicative order of k modulo n, defined as the smallest integer x such that kx ≡ 1 mod n.
    CONST UINT32 MultiplicativeOrder( CONST UINT32 k, CONST UINT32 n );

  • 原根：give a primitive root of n, where n is a prime power or twice a prime power.
    CONST UINT32 PrimitiveRoot( CONST UINT32 n );
See Also

算法库调用手册


特别函数
  • 超大整数互换：
    CHugeInt& CHugeInt::Swap( CHugeInt& right );
    CHugeIntX& CHugeIntX::Swap( CHugeIntX& right );

  • 将超大整数自身取反：
    CHugeInt& CHugeInt::Negate( VOID );
    CHugeIntX& CHugeIntX::Negate( VOID );

  • 取超大整数的相反数：
    CONST CHugeInt CHugeInt::operator -( VOID ) CONST;
    CONST CHugeIntX CHugeIntX::operator -( VOID ) CONST;

  • 取绝对值运算：
    CHugeInt& CHugeInt::Abs( VOID );
    CHugeIntX& CHugeIntX::Abs( VOID );

  • 重载超大整数类指针：
    CHugeInt * CONST CHugeInt::operator ->( VOID );
    CHugeIntX * CONST CHugeIntX::operator ->( VOID );

  • 析构超大整数类：
    CHugeInt::~CHugeInt( );
    CHugeIntX::~CHugeIntX( );
See Also

算法库调用手册


HugeCalc API

User Interface

HugeCalc 自网上公开发布以来，由于其强大的功能，得到许多网友的积极反馈，也经常会有朋友询问是否可以通过 VB、Delphi 等编程语言来调用它，但比较遗憾的是，V6.x 之前的版本仅仅只能为 C++ 语言服务（因其开发环境即为标准 C++）。

在 V6.x 中，该问题得到了充分解决和改善，HugeCalc 在接口通用性方面做了大量工作：
  • MBCS、UNICODE 版本合二为一：现仅须一份 HugeCalc.dll 即可
  • 修改原 STL 接口为更通用的数据接口
  • 新增 __stdcall 方式的 ANSI C 导出接口
  • 内部全程自动监控各函数出入口变量机制：从对象生成、对象鉴别直至对象销毁（并在 DLL 临结束时自动释放未销毁对象，以防止用户因未调用相关函数而造成的内存泄露）
  • 为 C 语言用户准备好了动态的、显式调用接口
  • 制作 TLB 格式文件，以方便所有支持 COM 编程的语言调用
  • 制作特别版本的 TLB 格式文件，以方便 VB 语言调用
  • 所有导出文件均在 /HugeCalc_API/.. 相应目录下
  • 在 /testDLL/src/.. 目录下有示例代码可供参考（已经过严格测试）
  • 为方便使用，请用户先执行目录 /HugeCalc_API/ 下的 update.bat，以便在任意目录下均可调用 HugeCalc.dll，或得到在线帮助 HugeCalc.chm

Classes and Data Structures：

选择进制内核提示：
本系统为十进制和二进制双系统。如果需要进行大量的位运算（如用在密码学领域）或需要十六进制输出，建议用 CHugeIntX（或HX_xxx）；否则建议选用 CHugeInt（或HI_xxx）。

See Also

算法库调用手册


C++ API

如果您是一位C++开发者，那么恭喜您：您将获得最便捷最丰富的程序接口！

调用方式：
  • 静态链接：必要的头文件在 /HugeCalc_API/CppAPI/Include/ 目录下；库文件在 /HugeCalc_API/CppAPI/Lib/ 目录下
  • 动态链接：请参考WIN32 API
  • 导出接口文件可自适应 MBCS / UNICODE 环境
  • 在 /testDLL/src/.. 目录下有示例代码可供参考
See Also

算法库调用手册、WIN32 API


WIN32 API

如果您是一位C语言的开发者，那么恭喜您：您将获得一个功能全面效率突出的算法库，且其接口符合 ANSI C 标准。

调用方式：
  • 在 /HugeCalc_API/Win32API/ 目录下，已为用户准备好了导入接口文件：hugeCalc.h 和 hugeCalc.c；您只需包含进您的工程即可。
  • 导出接口文件可自适应 MBCS / UNICODE 环境
  • 在 /testDLL/src/.. 目录下有示例代码可供参考
See Also

算法库调用手册、C++ API


Type Lib

如果您是一位C语言以外的开发者，那么恭喜您：您将凭借 HugeCalc 提供的标准接口而使您的软件获得突出的性能，而这一切是简易的。

调用方式：
  • 接口文件 *.tlb 在 /HugeCalc_API/CppAPI/Include/ 目录下
  • 可用 OLE View 工具查看 *.tlb 里的内容
  • 如果您使用的语言支持指针、无符号数据类型等（与C语言相当），那么可以使用 HugeCalc.tlb（MBCS 版）或 HugeCalcU.tlb（UNICODE 版），或 HugeCalcAll.tlb（MBCS+UNICODE 版）
  • 如果您使用的语言为VB（或与VB相当），那么可以使用特别制定的 HugeCalc4VB.tlb（MBCS 版）或 HugeCalcU4VB.tlb（UNICODE 版）
  • 在 /testDLL/src/VB/ 目录下有示例代码可供参考

可能有些朋友从未使用过 .tlb (Type Libraries) 文件，其实它很简单，也非常通用，类似于 COM 的接口。下面以 VB6 为例，详细讲解 .tlb (Type Libraries) 文件的使用方法：
  1. 打开一个VB工程

  2. 通过菜单“Project”-->:“References ...”打开一个对话框，如 图1，点“Browse...”按钮选择需要添加的 tlb 文件
    -- 图1
    此时，您已可调用该 tlb 提供的接口了

  3. 如果您需要查看该库定义了哪些数据类型、哪些数据常量，提供了哪些函数，以及需要获得在线帮助，那么可按F2（或通过菜单“View”-->:“Object Browser”），将弹出如下画面：
    -- 图2
    通过选择Library，以便进一步缩小查看范围；如果需要进一步了解帮助，按F1即可得到相应的上下文帮助

  4. 在键入 HugeCalc 相关代码时，系统会自动出现该函数的原型提示，如下图：
    -- 图3
    请注意一些变量命名规则：以“h”打头的是大整数类型；以 “u32”打头的是32bit无符号类型；以 “s32”打头的是32bit有符号类型。。。

  5. 为方便使用，请用户先执行目录 /HugeCalc_API/ 下的 update.bat，以便用户在任意目录下均可调用 HugeCalc.dll（HugeCalc.chm）

对于 VB 与 DLL 之间的字符串传递是个棘手的问题，因为它们使用不同的标准。现在这个问题也已完美解决了，在 HugeCalc4VB.tlb（MBCS 版）或 HugeCalcU4VB.tlb（UNICODE 版）中特别声明了一些字符串操作的 WINAPI，通过它们甚至可以获得最佳的性能（说实话，VB的字符串操作很低效）。为防止用户混淆，特分成了两大类：
  1. 入参为 VB 的字符串时：

    • Function lstrcat(lpString1 As String, lpString2 As String) As Long
    • Function lstrcmp(lpString1 As String, lpString2 As String) As Long
    • Function lstrcmpi(lpString1 As String, lpString2 As String) As Long
    • Function lstrcpy(lpString1 As String, lpString2 As String) As Long
    • Function lstrcpyn(lpString1 As String, lpString2 As String, u32MaxLength As Long) As Long
    • Function lstrlen(lpString As String) As Long
    • Function lwrite(hFile As Long, lpBuffer As String, uBytes As Long) As Long

    • Function GetWindowText(hWnd As Long, lpString As String, uMaxCount As Long) As Long
    • Function GetWindowTextLength(hWnd As Long) As Long
    • Function SetWindowText(hWnd As Long, lpString As String) As Long

    • Function HI_set_str(hHugeInt As Long, lpszNum As String) As Long
    • Function HX_set_str(hHugeInt As Long, lpszNum As String) As Long

  2. 入参为字符串的地址（已改声明为 Long 数据类型）时：

    • Function L_strcat(lpString1 As String, lpString2 As Long) As Long
    • Function L_strcmp(lpString1 As String, lpString2 As Long) As Long
    • Function L_strcmpi(lpString1 As String, lpString2 As Long) As Long
    • Function L_strcpy(lpString1 As String, lpString2 As Long) As Long
    • Function L_strcpyn(lpString1 As String, lpString2 As Long, u32MaxLength As Long) As Long
    • Function L_strlen(lpString As Long) As Long
    • Function L_write(hFile As Long, lpBuffer As Long, uBytes As Long) As Long

    • Function L_SetWindowText(hWnd As Long, lpString As Long) As Long

    • Function L_HI_set_str(hHugeInt As Long, lpszNum As Long) As Long
    • Function L_HX_set_str(hHugeInt As Long, lpszNum As Long) As Long
合理使用它们，可以完成不定长字符串的操作，甚至可以达到直接写屏目的，具体请参考示例代码及相关注释。

See Also

算法库调用手册、HugeCalc API


请注册 HugeCalc

欢迎您注册 HugeCalc
欢迎您注册 HugeCalc V8.0.0.0
真实姓名： （会为您保密）
机关单位： （会为您保密）
通讯地址： （请填写完整）
邮政编码： （请确认准确）
*E-Mail： （请务必有效）
* 注册序号： （请务必准确）
*捐助开发：
天空共享软件注册中心、中国共享软件注册中心
金额：
备 注： （简明扼要）
（打*项为必填项，务必准确，否则无法完成注册）

  • 如果您觉得这套算法是有价值的，或希望能进行二次开发，欢迎前来注册

  • 如果您愿意资助该套算法再开发的话，开发者在此对您表示衷心的感谢，并将优先为您服务

  • 一旦注册成功，即可获得后续版本的免费升级，并可自动完成注册功能
    （注：部分免费获赠者可能无法享受到自动升级注册功能）

  • 对于通过传统邮局汇款的用户，无论金额多少，均可成为正式版用户；但上款的“免费升级”仅适用于汇款金额不低于当前最低限额的 50% 者

  • 对于每个注册用户，每年将有三次机会免费更新序列号（可一并申请，以便同时用于数台计算机上）

  • 如果您有其它问题（如无法自动发送信息等），请直接惠赐 E-Mail: gxqcn@163.com; HugeCalc@Gmail.com

See Also

注册流程图解、郑重申明、联系作者


注册流程图解
  1. 运行RegDll.exe，程序将搜寻对应的 HugeCalc.dll，如果找不到将看到如下画面：
    -- 图1

  2. 然后程序会查询 HugeCalc.dll 版本号，如果版本号较低，将看到如下画面：
    -- 图2
    然后跳转到第 9 步；否则进行下一步

  3. 如果通过上述验证，将看到如下画面：
    -- 图3
    其中 SN 栏将自动显示成用户本机的序列号；两个编辑框均为只读状态；点击“Copy SN”按钮可将把序列号复制到剪贴板上

  4. 选中开发者反馈的 Key 字串，并复制到剪贴板上，点击“Paste Key”，将看到如下画面（图中所示的“Key”为直接点击“Copy SN”获得）：
    -- 图4
    此时粘贴字串与“*”号字串交替闪烁三次（三秒钟），以提醒用户自检

  5. 而后自动进行验证粘贴的 Key 格式是否有效：如果无效将看到如下画面（请转至第 4 步继续）：
    -- 图5

  6. 如果有效，将出现如下画面：原“Paste Key”按钮自动显示成“Register”按钮，Key 编辑栏恢复成可编辑状态：
    -- 图6

  7. 如果用户发现不是所对应的 Key 字串则可在此时人工修改（否则直接转下一步）：
    -- 图7

  8. 点击“Register”按钮：如果验证“Key”的格式无效，转回第 5 步；如果注册失败，本窗口将直接关闭；如果注册成功，将出现如下画面：
    -- 图8

  9. 当关闭时，RegDll.exe 将会自动侦测用户 CPU 的相关信息，并试着将它写入用户 WINDOWS 安装目录下的 HugeCalc.ini 文件中。
    如果该文件属性已设“只读”，将出现如下画面（如果用户按了取消键，程序将退出）：
    -- 图9
    如果用户（在取消该文件“只读”属性后）按了“重试”键，程序将会再次试着打开该文件，
    但如果连续三次都失败了，将出现如下画面（而后程序直接退出）：
    -- 图10
    如果一切正常，将显示如下画面（而后程序退出）：
    -- 图11

  10. 若再运行RegDll.exe，对于已注册成功的用户，将看到图8画面

  • RegDll.exe将通用于 HugeCalc 8.x 以上的版本，故必须将该程序与需注册的 HugeCalc.dll 放在同一目录运行（在其标题栏中将自动显示 HugeCalc 的内部版本号）

  • 请将 SN 字串提交开发者注册，以获取对应的 Key 字串，具体请参见：请注册 HugeCalc
    特别提醒：每台机器上的“SN”字串各不相同，但却不随用户的操作平台变动而变动，亦不随 HugeCalc 的版本变化而变化；但注册码“Key”不仅与“SN”号相关，亦与 HugeCalc 的版本号相关

  • 若用 Key == SN 字串（不区分大小写）试注册，HugeCalc 将会改变对未注册用户的限制方式，具体请参见：未注册用户的限制

  • 注册时，其它应用程序可同时调用 HugeCalc，但应用程序必须在关闭后重新开启再调用 HugeCalc 时注册信息才会起效

  • 注册成功后，如有新版本发布，再运行RegDll.exe即可自动对新版本进行注册
    （注：部分免费获赠者可能无法享受到自动升级注册功能）

  • 上述 RegDll.exe 自动生成的 HugeCalc.ini 仅记录对程序运行至关重要的 CPU 的相关参数，HugeCalc 系列软件将会优先读取它们，并自动调整运行参数或算法（如未发现该 HugeCalc.ini，程序将自动侦测用户 CPU 的相关信息，以使运行效率最佳化）。该 HugeCalc.ini 写有详细的注释，用户可在 [UserSetCPUID] 字段中尝试修改它（可参考 [AutoDetectCPUID] 字段），但估计很难使 HugeCalc 运行效率更快！

  • 如果您有其它不明白的问题，请直接惠赐 E-Mail: gxqcn@163.com; HugeCalc@Gmail.com
See Also

请注册 HugeCalc、未注册用户的限制、郑重申明、相关信息


未注册用户的限制
  • 对未注册的用户，将有如下限制：

    • 调用 HugeCalc 的程序必须位于 /CopyrightByGuoXianqiang/[../] 目录下（注意有大小写要求）；否则拒绝所有的高精度计算申请

    • 每次输出将会受随机干扰或随机延时：

      • 随机干扰：

        • 输出字串干扰：以 90% -> 10% 几率干扰，即用户调用 HugeCalc 后将有 90% 的几率受干扰，而后再以每 1%/min 下降直至 10%；当被干扰时，输出字串每 1024 个字符中将在随机的位置用字串“<HugeCalc>”覆盖，但首尾各 8 个字符保证不被覆盖；该干扰仅对输出字符起作用，并不影响 HugeCalc 内部数据

        • 进制转换干扰：以 10% -> 90% 几率干扰，即用户调用 HugeCalc 后将有 10% 的几率受干扰，而后再以每 1%/min 上升直至 90%；当被干扰时，进制转换每 1024 个数中将在随机的位置用随机的且小于当前进制数的数替换，但首尾各 8 个数位保证不被替换；该干扰将影响外部调用基数变换器 CRadixConverter 的真实结果

      • 随机延时：此时不再进行输出干扰，但会延时 10s 输出（在此期间计算机扬声器或音箱将发出蜂鸣提示）；延时几率法则同上，但变化率提高为 5%/min； HugeCalc 内部的高精度计时器（有暂停、累计、复位等功能）将会自动扣除延时时间

      • 两种模式，可由用户自选，以方便未注册用户对 HugeCalc 进行试用和评估（它们分别可测速度与精度）；具体切换规则是：运行RegDll.exe，如果用 Key == SN 字串（不区分大小写）去试注册，HugeCalc 将会“随机延时”输出；用 SN 及真正的 Key 外的字串去注册，HugeCalc 将会“随机干扰”输出

  • 对于注册成功的用户，使用上不作任何限制

  • 如果您需要在您的群组或客户机器上，无须再单机注册即可正常调用 HugeCalc 提供的强大功能，请您与作者联系洽谈客户定制专版

See Also

注册流程图解、郑重申明


HugeCalc 计算器

 最小化 关闭 标题栏（显示调用的 HugeCalc 版本号） 切换：输出大小写及窗口Top属性 切换进制系统（内部变量将随即切换） 得到比输出数据更小的最邻近素数 对输出数据进行素性检测 得到比输出数据更大的最邻近素数 如果选择变量为“---”，则不输出具体结果； 但结果位数等相关信息仍会以tooltip方式显示出来 显示数据 若未注册，则严禁用于任何商业目的！ 输出区 将下面输入的字串赋值给右边 将右边与左边的数互换 比较两边数值的大小 可输入任意文本，本软件会自动过滤 （直接支持“0x...”形式的十六进制赋值） 输入区 高精度加、减、乘、除（商、余）及与、或、异或位运算 高精度快速乘方 (绝对值)高精度开方；余数不为0时将余数显示到左边窗口 计算 n!、n!!、n#、素数阶乘 或 Fibonacci/Lucas 数列 最大公约数 计算对数（精确到整数位） 可转换成任意进制；当进制∈[2, 62] 时，用字符集[0-9A-Za-z]精确输出，否则用[xxx]精确输出 是否显示累计耗时 高精度加、减、乘、除（商、余）及与、或、异或位运算 [0, 4294967295] [1, 4294967295] [0, 4294967295] 计算 n!、n!!、n#、素数阶乘 或 Fibonacci/Lucas 数列 注意：当等于“0”时，代表“2^32”； 当等于“1”时，无意义 注意：当等于“0”时，代表“2^32”； 当等于“1”时，无意义 获取计算耗时（并同时切换显示格式） 开始或终止高精度计算 高精度计算控制区 图案仅供参考
HugeCalc 计算器 V8.x 简单帮助

（鼠标停留在不同区域将出现相应的提示，图案仅供参考）

注：
  • 本计算器仅为 HugeCalc 算法库的 Demo & Test，所以功能不全，界面也不算很理想；但已提供了最常用的一些功能，且非常强大

  • 本计算器分为三部分：“输入区”、“输出区”及“高精度计算控制区”；
    含有“10进制”和“16进制”两个系统；
    每个系统独立含有 A、B、C、D、E、F 六个变量可供调用

  • 若不关心（中间）计算结果的具体值，可在输出栏中将变量选择为“---”；
    此时虽不输出变量的具体数值，但结果的位数等相关信息仍会以 tooltip 方式显示出来（鼠标移至输出窗口略作停留即可观察到）

  • 本计算器启动后，“输入区”内容将在三秒后自动清空；
    当切换进制后，输入第一个有效字符（为“+- 0x,X123456789ABCDEFabcdef”之一，与输出模式相关联）时，程序会自动先将“输入区”内容清空；
    若先按一次“退格”键则可消除该替换模式

  • 当右上角的按钮显示为 切换：输出大小写及窗口Top属性 时，则该计算器保持可见，且输出用大写字母（用[0-9A-Z]字符集）；
    当点击切换为 切换：输出大小写及窗口Top属性 时,则取消“始终在上”，同时设定输出用小写字母（用[0-9a-z]字符集）

  • 三个按钮的作用分别为：中间那个将对输出数据进行快速素性检测；左右按钮分别为向前/向后寻找最相邻的素数

  • “常数”项计算中的“n#”表示“小于等于n的所有素数之积”

  • 本计算器采用了多线程技术，随时可终止当前的计算

  • 尚未注册的用户，每次输出将会受随机干扰或随机延时，为方便用户自由切换测试模式，特提供了如下对话框：
    限制模式切换
    该对话框可点击计算器左上角的系统菜单弹出（已注册用户无此子菜单）；该模式切换仅对本程序有效

  • HugeCalc.exe 是 MBCS Version，通用于 Win95 以上操作平台
    HugeCalcU.exe 是 UNICODE Version，适合于 Win2k/WinXP 以上平台
    注：
    • 它们都是调用同一份 HugeCalc.dll
    • 为方便用户测试或体验 HugeCalc 的强大，已将 HugeCalc.exe 对所有用户永久开放使用权（即：使用上不会出现任何日期的限制或是软件功能上的限制）

查看网上最新版本


意见/建议反馈

首先，非常感谢您选用 HugeCalc 算法库，愿它能给您带来方便快捷的服务！
  • 如果您发现了 bug，请您及时将 bug 描述、软硬件环境等信息反馈给作者（若同时附上相关截图则更好），以便及时修正

  • 如果您可以提供更好的算法、资料（如网上链接）等，请您与作者联系交流，以便共同进步

  • 如果您在使用过程中，发现有不合理之处、或有好的建议，也请您及时与作者讨论，以便逐步完善

对于善意的批评和建议、对于有价值的反馈，作者将会特别致谢，并免费提供注册码（或注册版）。

See Also

联系作者、致 谢


更新历史
  • V8.0.0.0 2007-12-08

    1. 启用顶级域名 www.emath.ac.cn

    2. 改进高级乘法算法（消除所有浮点指令，提速 30% 左右）

  • V7.0.1.0 2007-09-10

    1. 优化多核线程池调度算法

    2. 解决部分机型兼容性问题

  • V7.0.0.0 2007-08-19

    1. 汇编优化普通乘法算法（速度提升 10% 左右）

    2. 汇编优化高级乘法算法（速度提升 10% 左右）

    3. 用 SSE2 指令集改写高级乘法算法（速度可提升 100% 左右）

    4. 针对多核进行并行优化（速度提升程度正比于 CPU 的核数）

    5. 改写某些情形下的排列、组合算法，以使效率最佳化

    6. 新增一组数论函数；导出函数新增到 709 个（标准C++接口 473 个；标准C接口 236 个；同等功能的 MBCS / UNICODE 函数不重复统计）

  • V6.1.0.1 2007-02-11

    1. 优化内存管理

    2. 新增 Primorial(n)（即n#）导出函数

  • V6.0.0.5 2007-02-07

    1. 一些小优化

    2. 修正前一版奇数双阶乘不正确的bug

  • V6.0.0.4 2007-01-07

    1. 优化核心乘法、平方算法

    2. 改进模幂算法（并充分发挥双进制系统的潜力）

    3. 采用新的更强化素性检测算法（部分自创；比 Mathematica 5.2 所用检测强度更大）

    4. 10进制系统内部可直接快速素性检测

  • V6.0.0.3 2006-09-29

    1. 优化素数阶乘算法

    2. 强化素性检测算法

    3. 模幂算法在原自创算法基础上，引入了 Montgomery 算法；优化普通取模算法，提升进制转换效率

  • V6.0.0.2 2006-09-09

    1. 优化核心乘法算法

    2. 优化进制转换算法

    3. 优化素性检测算法

    4. 新增内部全程自动监控各函数出入口变量机制：从对象生成、对象鉴别直至对象销毁（并在 DLL 临结束时自动释放未销毁对象，以防止用户因未调用相关函数而造成的内存泄露）

    5. 导出函数新增到 697 个（标准C++接口 467 个；标准C接口 230 个；同等功能的 MBCS / UNICODE 函数不重复统计）

  • V6.0.0.1 2006-06-25

    1. 修正一个除法bug（该bug是优化时没及时“return”所致），其影响面很大

    2. 修改 Gcd 算法中的一个临界值

  • V6.0.0.0 2006-06-21

    1. 优化核心算法

    2. 一个DLL同时兼容 MBCS + UNICODE 版

    3. 修改原STL接口为更通用的数据接口

    4. 同时导出WINAPI接口，以方便标准C语言或其它语言动态调用

    5. 同时导出TLB接口，以方便所有支持COM编程的语言调用

    6. 新增快速素性检测算法

    7. 新增生成最相邻素数算法

    8. 新增随机类算法

    9. 改进大数开方、最大公约数等算法

    10. 导出函数新增到 657 个（标准C++接口 446 个；标准C接口 211 个；同等功能的 MBCS / UNICODE 函数不重复统计）

  • V5.1.0.1 2005-10-18

    1. 新增一些数论函数

    2. 新增指定精度函数

    3. 原进制转换结构更改为导出类

    4. 优化了许多核心算法

    5. 放宽对未注册用户的使用限制

    6. 提供多种模式以供未注册用户进行试用和评估

    7. 导出函数新增到 428 个

  • V5.0.0.1 2005-06-28

    1. 新增指数为超大整数的乘方取模运算

    2. 高精度计时器可设定毫秒、微秒、纳秒等不同精度

    3. 导出函数新增到 377 个

  • V5.0.0.0 2005-05-25

    1. 新增16进制算法系统（可与原10进制算法系统灵活转换）

    2. 新增超大整数取对数运算

    3. 新增AND/OR/XOR等位运算

    4. 新增出错代码报告功能

    5. 导出函数新增到 372 个

    6. 改写了部分核心算法，解掉几处小bug

    7. 同时发布 UNICODE 版

  • V4.0.0.0 2004-12-08

    1. 改进了输出算法，效率再提高 3 倍以上

    2. 修改部分函数接口

    3. 导出函数新增到 184 个

  • V3.0.2.1 2004-10-18

    1. 改进了计算 Fibonacci 数列的算法

    2. 支持十六进制字符串直接对超大整数的初始化或赋值

    3. 全面提升除法、开方及相关的最大公约数/最小公倍数/进制转换等运算效率

  • V3.0.1.2 2004-09-19

    1. 改进了开平方算法

    2. 改进了进制转换算法

  • V3.0.1.1 2004-09-10

    1. 改进了除法算法

    2. 改进了开任意次方的算法

  • V3.0.0.1 2004-08-08

    1. 大整数乘法采用了 FNT+CRT 算法，再次提速

    2. 改进了输入输出算法

  • V2.1.0.1 2004-06-01

    1. 解掉了“开平方”、“开立方”算法中的bug

    2. 解掉了“超大整数除以小整数”算法中的bug

    3. 改进素数搜索算法、并对乘法模块进行了优化

    4. 核心模块首次采用内嵌汇编优化

  • V2.0.1.1 2004-05-08

    1. 充分运用数论知识优化算法

    2. 改进了（双）阶乘、排列、组合等算法，速度提高 25% 左右

  • V1.2.0.1 2004-04-27

    1. 优化了乘法群组运算算法

    2. 改进了开任意次方的算法

    3. 改进了（双）阶乘的算法

  • V1.1.0.1 2004-04-08

    1. 导出函数新增到 169 个

    2. 改进了乘法算法

  • V1.0.1.1 2004-03-29

    1. 导出函数达到 97 个

    2. 新增配套软件 HugeCalc.exe，虽然仅使用了部分功能，但已很强大

    3. 不再提供自由的 Demo&Test 源代码

  • V1.0.0.1 2004-03-02

    1. 发布该算法库雏形

    2. 同时提供 Demo&Test 源代码（含 UNICODE 版）


郑重申明
  • 安装和使用：您可安装无限制数量的本软件产品来使用。

  • 使用权限：非注册版本仅在输出时有功能限制；注册后可获得全部功能，以及在提供的DLL接口文件基础上进行再开发的权利。对于客户定制版本，双方必须遵守签订（或约定）的一些条款。

  • 复制、分发和传播：本软件产品不能用于销售或随同旨在获益的软件产品或产品包一起分发，但本软件可包含在任何免费或非赢利性的软件产品或产品包里。您可以复制、分发和传播无限制数量的软件产品，但您必须保证每一份复制、分发和传播都必须是完整和真实的，包括所有有关本软件产品的软件、电子文档，版权和商标宣言等，并且保证未作任何修改，且不得收取任何的费用金额或转为其它商业用途。

  • 禁止反向工程、反向编译和反向汇编：您不得对本软件产品进行反向工程、反向编译和反向汇编。除非适用法律明文允许上述活动，否则您必须遵守此协议限制。

  • 未注册版本严禁用于任何商业目的（如需商业开发，欢迎进行各种合作洽谈，并可提供客户定制版本，以便二次开发的程序可自由发布给用户使用）。

  • 警告：本计算机软件受著作权法和国际公约的保护。未经作者授权，若违反上述申明一款或数款，都会导致严厉的民事和刑事惩罚，并将受到法律允许范围内的最大限度的起诉。本产品的开发者与供应商无须为用户的误用或侵权等行为承担任何责任或义务。特此声明。

  • 免责申明：作为一款共享软件，原版权人申明不对本软件产品的使用提供任何明示的和隐含的保证。不对产品的适用性、无故障性以及软件使用所遇到的任何理论上的或实际上的损失承担责任；若利用本软件进行非法破解/解密，并因此造成的任何理论上的或实际上的损失，后果均由破解/解密者自负，本软件不承担任何连带责任！

See Also

请注册 HugeCalc、联系作者


致 谢
  • 感谢我的家人，为了让我充分利用业余时间，他们付出了太多太多，
    也感谢我那上幼儿园的可爱儿子，祝福他健康茁壮地长大。。。

  • 感谢北京大学的刘楚雄老师，提供了很多算法资料，并保持经常性的算法交流

  • 感谢梁宝成、郭雄辉、姚家林等网友，我们曾在高精度计算领域中广泛交流、热烈讨论、相互促进（很是怀念当年CSDN上那段美好时光）

  • 感谢博士论坛的版主幻星的支持和鼓励

  • 感谢数与编程的站长XYY的交流

  • 感谢网友 netnice 反馈 HugeCalc4.0 的进制转换中的一处 bug

  • 感谢中国科学技术大学的 zhangjm，指出 HugeCalc4.0 中 Combination() 函数有 bug

  • 感谢中科院计算所软件研究室的沈华伟先生，指出 HugeCalc5.x 中“两个相反数相减为0”的 bug

  • 感谢兰州大学的陈光明同学，从他反馈的异常现象描述中最终发现了 V6.0.0.0 高精度除法中存在 bug，
    陈同学对本软件长期热情关注，并提供了大量参考资料，在此表示深深的感谢

  • 感谢上海某高中的王孟晖同学，指出在 V6.0.0.3 中将 1234567890123 转化成 17 进制时会崩溃

  • 感谢 CSDN 上的网友 housisong，提出针对多核优化

  • ...


请与作者联系
江苏省苏州市苏锦一村锦月新居132-202室(215031) 郭先强（收）
见主页（包含办公电话等，及时方便有效）；或留言
gxqcn@163.com; HugeCalc@Gmail.com
http://www.emath.ac.cn/
http://bbs.emath.ac.cn/

作者主要发展方向：
数论、组合数学等；

感兴趣的课题：
等幂和问题、幻方，有关整数（矩阵）的快速算法研究，组合优化，组合中的快速构造及存在性计数问题等。

如果您在使用过程中，有不满意的地方，敬请来电来函批评指正！

如果您比较满意本系统，也请您与作者联系，以资鼓励。

在数学研发论坛上，欢迎您就本人原创软件提出批评或建议，

也欢迎您就当前的数学研究和发展，及计算机在数学研究中的应用，提出您的高见！

作者还有许多数学应用程序，愿与大家共享之 … …