⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 hugecalc.c

📁 这是一个应用软件,用于处理大数,里面包含一些小的实用的软件,如生成 素数 ,大数阶乘.
💻 C
📖 第 1 页 / 共 5 页
字号:
	typedef const UINT64 (WINAPI* lpfRC_get_u64)( const HRADIXCONVERTER hRadixConverter );

	typedef void (WINAPI* lpfRC_resetRadix)( HRADIXCONVERTER hRadixConverter, const UINT32 u32Radix );
	typedef void (WINAPI* lpfRC_resetSign)( HRADIXCONVERTER hRadixConverter, const SIGN enumSign );
	typedef void (WINAPI* lpfRC_resetVector)( HRADIXCONVERTER hRadixConverter, const UINT32_CVECTOR Vector );
	typedef void (WINAPI* lpfRC_clearVector)( HRADIXCONVERTER hRadixConverter );

	typedef const UINT32 (WINAPI* lpfRC_getRadix)( const HRADIXCONVERTER hRadixConverter );
	typedef const SIGN (WINAPI* lpfRC_getSign)( const HRADIXCONVERTER hRadixConverter );
	typedef void (WINAPI* lpfRC_getVector)( const HRADIXCONVERTER hRadixConverter, UINT32_CVECTOR * const pVector );
	typedef const UINT64 (WINAPI* lpfRC_sumOfDigits)( const HRADIXCONVERTER hRadixConverter );
#endif	/* #ifndef _NO_RC */



	#define	_HC_getVer                      ( *(lpfHC_getVer)                       s_pfFun[ fnHC_getVer ]                  )

	#define	_HC_getSN                       ( *(lpfHC_getSN)                        s_pfFun[ fnHC_getSN ]                   )

	#define	_HC_getExportFunNums            ( *(lpfHC_getExportFunNums)             s_pfFun[ fnHC_getExportFunNums ]        )
	#define	_HC_getLicenseLevel             ( *(lpfHC_getLicenseLevel)              s_pfFun[ fnHC_getLicenseLevel ]         )

	#define	_HC_getLastError                ( *(lpfHC_getLastError)                 s_pfFun[ fnHC_getLastError ]            )

	#define	_HC_setTerminate                ( *(lpfHC_setTerminate)                 s_pfFun[ fnHC_setTerminate ]            )
	#define	_HC_isTerminated                ( *(lpfHC_isTerminated)                 s_pfFun[ fnHC_isTerminated ]            )

	#define	_HC_seedRandom                  ( *(lpfHC_seedRandom)                   s_pfFun[ fnHC_seedRandom ]              )

	#define	_HC_resetTimer                  ( *(lpfHC_resetTimer)                   s_pfFun[ fnHC_resetTimer ]              )
	#define	_HC_enableTimer                 ( *(lpfHC_enableTimer)                  s_pfFun[ fnHC_enableTimer ]             )
	#define	_HC_getTimer                    ( *(lpfHC_getTimer)                     s_pfFun[ fnHC_getTimer ]                )
	#define	_HC_getTimerStr                 ( *(lpfHC_getTimerStr)                  s_pfFun[ fnHC_getTimerStr ]             )

	#define	_HC_isPrime                     ( *(lpfHC_isPrime)                      s_pfFun[ fnHC_isPrime ]                 )
	#define	_HC_getPrimePi                  ( *(lpfHC_getPrimePi)                   s_pfFun[ fnHC_getPrimePi ]              )
	#define	_HC_getPrime                    ( *(lpfHC_getPrime)                     s_pfFun[ fnHC_getPrime ]                )
	#define	_HC_getPrimeCount               ( *(lpfHC_getPrimeCount)                s_pfFun[ fnHC_getPrimeCount ]           )
	#define	_HC_getPrimeList                ( *(lpfHC_getPrimeList)                 s_pfFun[ fnHC_getPrimeList ]            )

	#define	_HC_previousPrime               ( *(lpfHC_previousPrime)                s_pfFun[ fnHC_previousPrime ]           )
	#define	_HC_nextPrime                   ( *(lpfHC_nextPrime)                    s_pfFun[ fnHC_nextPrime ]               )

	#define	_HC_gcd                         ( *(lpfHC_gcd)                          s_pfFun[ fnHC_gcd ]                     )
	#define	_HC_gcd_v32                     ( *(lpfHC_gcd_v32)                      s_pfFun[ fnHC_gcd_v32 ]                 )
	#define	_HC_gcdEx                       ( *(lpfHC_gcdEx)                        s_pfFun[ fnHC_gcdEx ]                   )
	#define	_HC_invertMod                   ( *(lpfHC_invertMod)                    s_pfFun[ fnHC_invertMod ]               )
	#define	_HC_lcm                         ( *(lpfHC_lcm)                          s_pfFun[ fnHC_lcm ]                     )
	#define	_HC_powMod                      ( *(lpfHC_powMod)                       s_pfFun[ fnHC_powMod ]                  )



	#ifndef _NO_HI
	#define	_HI_abs                         ( *(lpfHI_abs)                          s_pfFun[ fnHI_abs ]                     )
	#define	_HI_add                         ( *(lpfHI_add)                          s_pfFun[ fnHI_add ]                     )
	#define	_HI_add_u32                     ( *(lpfHI_add_u32)                      s_pfFun[ fnHI_add_u32 ]                 )
	#define	_HI_bitAnd                      ( *(lpfHI_bitAnd)                       s_pfFun[ fnHI_bitAnd ]                  )
	#define	_HI_bitLShift                   ( *(lpfHI_bitLShift)                    s_pfFun[ fnHI_bitLShift ]               )
	#define	_HI_bitRShift                   ( *(lpfHI_bitRShift)                    s_pfFun[ fnHI_bitRShift ]               )
	#define	_HI_bitOr                       ( *(lpfHI_bitOr)                        s_pfFun[ fnHI_bitOr ]                   )
	#define	_HI_bitXor                      ( *(lpfHI_bitXor)                       s_pfFun[ fnHI_bitXor ]                  )
	#define	_HI_ceil                        ( *(lpfHI_ceil)                         s_pfFun[ fnHI_ceil ]                    )
	#define	_HI_combination                 ( *(lpfHI_combination)                  s_pfFun[ fnHI_combination ]             )
	#define	_HI_compareAbs_hi               ( *(lpfHI_compareAbs_hi)                s_pfFun[ fnHI_compareAbs_hi ]           )
	#define	_HI_compareAbs_s32              ( *(lpfHI_compareAbs_s32)               s_pfFun[ fnHI_compareAbs_s32 ]          )
	#define	_HI_compareAbs_u32              ( *(lpfHI_compareAbs_u32)               s_pfFun[ fnHI_compareAbs_u32 ]          )
	#define	_HI_compare_hi                  ( *(lpfHI_compare_hi)                   s_pfFun[ fnHI_compare_hi ]              )
	#define	_HI_compare_s32                 ( *(lpfHI_compare_s32)                  s_pfFun[ fnHI_compare_s32 ]             )
	#define	_HI_compare_u32                 ( *(lpfHI_compare_u32)                  s_pfFun[ fnHI_compare_u32 ]             )
	#define	_HI_decLShift                   ( *(lpfHI_decLShift)                    s_pfFun[ fnHI_decLShift ]               )
	#define	_HI_decRShift                   ( *(lpfHI_decRShift)                    s_pfFun[ fnHI_decRShift ]               )
	#define	_HI_delete                      ( *(lpfHI_delete)                       s_pfFun[ fnHI_delete ]                  )
	#define	_HI_divRem                      ( *(lpfHI_divRem)                       s_pfFun[ fnHI_divRem ]                  )
	#define	_HI_div_s32                     ( *(lpfHI_div_s32)                      s_pfFun[ fnHI_div_s32 ]                 )
	#define	_HI_factorial                   ( *(lpfHI_factorial)                    s_pfFun[ fnHI_factorial ]               )
	#define	_HI_factorial2                  ( *(lpfHI_factorial2)                   s_pfFun[ fnHI_factorial2 ]              )
	#define	_HI_fibonacci                   ( *(lpfHI_fibonacci)                    s_pfFun[ fnHI_fibonacci ]               )
	#define	_HI_floor                       ( *(lpfHI_floor)                        s_pfFun[ fnHI_floor ]                   )
	#define	_HI_freeStrBuffer               ( *(lpfHI_freeStrBuffer)                s_pfFun[ fnHI_freeStrBuffer ]           )
	#define	_HI_gcd                         ( *(lpfHI_gcd)                          s_pfFun[ fnHI_gcd ]                     )
	#define	_HI_gcdEx                       ( *(lpfHI_gcdEx)                        s_pfFun[ fnHI_gcdEx ]                   )
	#define	_HI_gcd_vhi                     ( *(lpfHI_gcd_vhi)                      s_pfFun[ fnHI_gcd_vhi ]                 )
	#define	_HI_generatePrime               ( *(lpfHI_generatePrime)                s_pfFun[ fnHI_generatePrime ]           )
	#define	_HI_getBits                     ( *(lpfHI_getBits)                      s_pfFun[ fnHI_getBits ]                 )
	#define	_HI_getCount                    ( *(lpfHI_getCount)                     s_pfFun[ fnHI_getCount ]                )
	#define	_HI_getDigits                   ( *(lpfHI_getDigits)                    s_pfFun[ fnHI_getDigits ]               )
	#define	_HI_getHexStr                   ( *(lpfHI_getHexStr)                    s_pfFun[ fnHI_getHexStr ]               )
	#define	_HI_getSign                     ( *(lpfHI_getSign)                      s_pfFun[ fnHI_getSign ]                 )
	#define	_HI_getStr                      ( *(lpfHI_getStr)                       s_pfFun[ fnHI_getStr ]                  )
	#define	_HI_getStrRadix                 ( *(lpfHI_getStrRadix)                  s_pfFun[ fnHI_getStrRadix ]             )
	#define	_HI_getTailDecZeros             ( *(lpfHI_getTailDecZeros)              s_pfFun[ fnHI_getTailDecZeros ]         )
	#define	_HI_get_s32                     ( *(lpfHI_get_s32)                      s_pfFun[ fnHI_get_s32 ]                 )
	#define	_HI_get_s64                     ( *(lpfHI_get_s64)                      s_pfFun[ fnHI_get_s64 ]                 )
	#define	_HI_get_u32                     ( *(lpfHI_get_u32)                      s_pfFun[ fnHI_get_u32 ]                 )
	#define	_HI_get_u64                     ( *(lpfHI_get_u64)                      s_pfFun[ fnHI_get_u64 ]                 )
	#define	_HI_invertMod                   ( *(lpfHI_invertMod)                    s_pfFun[ fnHI_invertMod ]               )
	#define	_HI_invertMod_u32               ( *(lpfHI_invertMod_u32)                s_pfFun[ fnHI_invertMod_u32 ]           )
	#define	_HI_isAbsOne                    ( *(lpfHI_isAbsOne)                     s_pfFun[ fnHI_isAbsOne ]                )
	#define	_HI_isEven                      ( *(lpfHI_isEven)                       s_pfFun[ fnHI_isEven ]                  )
	#define	_HI_isOdd                       ( *(lpfHI_isOdd)                        s_pfFun[ fnHI_isOdd ]                   )
	#define	_HI_isPrime                     ( *(lpfHI_isPrime)                      s_pfFun[ fnHI_isPrime ]                 )
	#define	_HI_isZero                      ( *(lpfHI_isZero)                       s_pfFun[ fnHI_isZero ]                  )
	#define	_HI_lcm                         ( *(lpfHI_lcm)                          s_pfFun[ fnHI_lcm ]                     )
	#define	_HI_lcm_v32                     ( *(lpfHI_lcm_v32)                      s_pfFun[ fnHI_lcm_v32 ]                 )
	#define	_HI_lcm_vhi                     ( *(lpfHI_lcm_vhi)                      s_pfFun[ fnHI_lcm_vhi ]                 )
	#define	_HI_log                         ( *(lpfHI_log)                          s_pfFun[ fnHI_log ]                     )
	#define	_HI_log_u32                     ( *(lpfHI_log_u32)                      s_pfFun[ fnHI_log_u32 ]                 )
	#define	_HI_lucas                       ( *(lpfHI_lucas)                        s_pfFun[ fnHI_lucas ]                   )
	#define	_HI_mod                         ( *(lpfHI_mod)                          s_pfFun[ fnHI_mod ]                     )
	#define	_HI_modPowTen                   ( *(lpfHI_modPowTen)                    s_pfFun[ fnHI_modPowTen ]               )
	#define	_HI_mul                         ( *(lpfHI_mul)                          s_pfFun[ fnHI_mul ]                     )
	#define	_HI_mulMod                      ( *(lpfHI_mulMod)                       s_pfFun[ fnHI_mulMod ]                  )
	#define	_HI_mul_u32                     ( *(lpfHI_mul_u32)                      s_pfFun[ fnHI_mul_u32 ]                 )
	#define	_HI_negate                      ( *(lpfHI_negate)                       s_pfFun[ fnHI_negate ]                  )
	#define	_HI_new                         ( *(lpfHI_new)                          s_pfFun[ fnHI_new ]                     )
	#define	_HI_nextPrime                   ( *(lpfHI_nextPrime)                    s_pfFun[ fnHI_nextPrime ]               )
	#define	_HI_permutation                 ( *(lpfHI_permutation)                  s_pfFun[ fnHI_permutation ]             )
	#define	_HI_pow                         ( *(lpfHI_pow)                          s_pfFun[ fnHI_pow ]                     )
	#define	_HI_powMod                      ( *(lpfHI_powMod)                       s_pfFun[ fnHI_powMod ]                  )
	#define	_HI_powMod_u32                  ( *(lpfHI_powMod_u32)                   s_pfFun[ fnHI_powMod_u32 ]              )
	#define	_HI_powMod_u32_u32              ( *(lpfHI_powMod_u32_u32)               s_pfFun[ fnHI_powMod_u32_u32 ]          )
	#define	_HI_previousPrime               ( *(lpfHI_previousPrime)                s_pfFun[ fnHI_previousPrime ]           )
	#define	_HI_primeFactorial              ( *(lpfHI_primeFactorial)               s_pfFun[ fnHI_primeFactorial ]          )
	#define	_HI_product_v32                 ( *(lpfHI_product_v32)                  s_pfFun[ fnHI_product_v32 ]             )
	#define	_HI_product_vhi                 ( *(lpfHI_product_vhi)                  s_pfFun[ fnHI_product_vhi ]             )
	#define	_HI_random                      ( *(lpfHI_random)                       s_pfFun[ fnHI_random ]                  )
	#define	_HI_rootRem                     ( *(lpfHI_rootRem)                      s_pfFun[ fnHI_rootRem ]                 )
	#define	_HI_setHexStr                   ( *(lpfHI_setHexStr)                    s_pfFun[ fnHI_setHexStr ]               )
	#define	_HI_set_hi                      ( *(lpfHI_set_hi)                       s_pfFun[ fnHI_set_hi ]                  )

#ifndef _NO_HX
	#define	_HI_set_hx                      ( *(lpfHI_set_hx)                       s_pfFun[ fnHI_set_hx ]                  )
#endif	/* #ifndef _NO_HX */

#ifndef _NO_RC
	#define	_HI_set_rc                      ( *(lpfHI_set_rc)                       s_pfFun[ fnHI_set_rc ]                  )
#endif	/* #ifndef _NO_RC */

	#define	_HI_set_s32                     ( *(lpfHI_set_s32)                      s_pfFun[ fnHI_set_s32 ]                 )
	#define	_HI_set_s64                     ( *(lpfHI_set_s64)                      s_pfFun[ fnHI_set_s64 ]                 )
	#define	_HI_set_str                     ( *(lpfHI_set_str)                      s_pfFun[ fnHI_set_str ]                 )
	#define	_HI_set_u32                     ( *(lpfHI_set_u32)                      s_pfFun[ fnHI_set_u32 ]                 )
	#define	_HI_set_u64                     ( *(lpfHI_set_u64)                      s_pfFun[ fnHI_set_u64 ]                 )
	#define	_HI_sub                         ( *(lpfHI_sub)                          s_pfFun[ fnHI_sub ]                     )
	#define	_HI_sub_u32                     ( *(lpfHI_sub_u32)                      s_pfFun[ fnHI_sub_u32 ]                 )
	#define	_HI_sumsOfLikePowers_v32        ( *(lpfHI_sumsOfLikePowers_v32)         s_pfFun[ fnHI_sumsOfLikePowers_v32 ]    )
	#define	_HI_sumsOfLikePowers_vhi        ( *(lpfHI_sumsOfLikePowers_vhi)         s_pfFun[ fnHI_sumsOfLikePowers_vhi ]    )
	#define	_HI_swap                        ( *(lpfHI_swap)                         s_pfFun[ fnHI_swap ]                    )
	#define	_HI_testPrimality               ( *(lpfHI_testPrimality)                s_pfFun[ fnHI_testPrimality ]           )
	#define	_HI_truncate                    ( *(lpfHI_truncate)                     s_pfFun[ fnHI_truncate ]                )
#endif	/* #ifndef _NO_HI */



#ifndef _NO_HX
	#define	_HX_abs                         ( *(lpfHX_abs)                          s_pfFun[ fnHX_abs ]                     )
	#define	_HX_add                         ( *(lpfHX_add)                          s_pfFun[ fnHX_add ]                     )
	#define	_HX_add_u32                     ( *(lpfHX_add_u32)                      s_pfFun[ fnHX_add_u32 ]                 )
	#define	_HX_bitAnd                      ( *(lpfHX_bitAnd)                       s_pfFun[ fnHX_bitAnd ]                  )
	#define	_HX_bitLShift                   ( *(lpfHX_bitLShift)                    s_pfFun[ fnHX_bitLShift ]               )
	#define	_HX_bitRShift                   ( *(lpfHX_bitRShift)                    s_pfFun[ fnHX_bitRShift ]               )
	#define	_HX_bitOr                       ( *(lpfHX_bitOr)                        s_pfFun[ fnHX_bitOr ]                   )
	#define	_HX_bitXor                      ( *(lpfHX_bitXor)                       s_pfFun[ fnHX_bitXor ]                  )
	#define	_HX_ceil                        ( *(lpfHX_ceil)                         s_pfFun[ fnHX_ceil ]                    )
	#define	_HX_combination                 ( *(lpfHX_combination)                  s_pfFun[ fnHX_combination ]             )
	#define	_HX_compareAbs_hx               ( *(lpfHX_compareAbs_hx)                s_pfFun[ fnHX_compareAbs_hx ]           )
	#define	_HX_compareAbs_s32              ( *(lpfHX_compareAbs_s32)               s_pfFun[ fnHX_compareAbs_s32 ]          )
	#define	_HX_compareAbs_u32              ( *(lpfHX_compareAbs_u32)               s_pfFun[ fnHX_compareAbs_u32 ]          )
	#define	_HX_compare_hx                  ( *(lpfHX_compare_hx)                   s_pfFun[ fnHX_compare_hx ]              )
	#define	_HX_compare_s32                 ( *(lpfHX_compare_s32)                  s_pfFun[ fnHX_compare_s32 ]             )
	#define	_HX_compare_u32                 ( *(lpfHX_compare_u32)                  s_pfFun[ fnHX_compare_u32 ]             )
	#define	_HX_delete                      ( *(lpfHX_delete)                       s_pfFun[ fnHX_delete ]                  )
	#define	_HX_divRem                      ( *(lpfHX_divRem)                       s_pfFun[ fnHX_divRem ]                  )
	#define	_HX_div_s32                     ( *(lpfHX_div_s32)                      s_pfFun[ fnHX_div_s32 ]                 )
	#define	_HX_factorial                   ( *(lpfHX_factorial)                    s_pfFun[ fnHX_factorial ]               )
	#define	_HX_factorial2                  ( *(lpfHX_factorial2)                   s_pfFun[ fnHX_factorial2 ]              )
	#define	_HX_fibonacci                   ( *(lpfHX_fibonacci)                    s_pfFun[ fnHX_fibonacci ]               )
	#define	_HX_floor                       ( *(lpfHX_floor)                        s_pfFun[ fnHX_floor ]                   )
	#define	_HX_freeStrBuffer               ( *(lpfHX_freeStrBuffer)                s_pfFun[ fnHX_freeStrBuffer ]           )
	#define	_HX_gcd                         ( *(lpfHX_gcd)                          s_pfFun[ fnHX_gcd ]                     )
	#define	_HX_gcdEx                       ( *(lpfHX_gcdEx)                        s_pfFun[ fnHX_gcdEx ]                   )
	#define	_HX_gcd_vhx                     ( *(lpfHX_gcd_vhx)                      s_pfFun[ fnHX_gcd_vhx ]                 )
	#define	_HX_generatePrime               ( *(lpfHX_generatePrime)                s_pfFun[ fnHX_generatePrime ]           )
	#define	_HX_getBits                     ( *(lpfHX_getBits)                      s_pfFun[ fnHX_getBits ]                 )
	#define	_HX_getCount                    ( *(lpfHX_getCount)                     s_pfFun[ fnHX_getCount ]                )
	#define	_HX_getDigits                   ( *(lpfHX_getDigits)                    s_pfFun[ fnHX_getDigits ]               )
	#define	_HX_getHexStr                   ( *(lpfHX_getHexStr)                    s_pfFun[ fnHX_getHexStr ]               )
	#define	_HX_getSign                     ( *(lpfHX_getSign)                      s_pfFun[ fnHX_getSign ]                 )
	#define	_HX_getStr                      ( *(lpfHX_getStr)                       s_pfFun[ fnHX_getStr ]                  )
	#define	_HX_getStrRadix                 ( *(lpfHX_getStrRadix)                  s_pfFun[ fnHX_getStrRadix ]             )
	#define	_HX_getTailBitZeros             ( *(lpfHX_getTailBitZeros)              s_pfFun[ fnHX_getTailBitZeros ]         )
	#define	_HX_getText                     ( *(lpfHX_getText)                      s_pfFun[ fnHX_getText ]                 )
	#define	_HX_get_s32                     ( *(lpfHX_get_s32)                      s_pfFun[ fnHX_get_s32 ]                 )
	#define	_HX_get_s64                     ( *(lpfHX_get_s64)                      s_pfFun[ fnHX_get_s64 ]                 )
	#define	_HX_get_u32                     ( *(lpfHX_get_u32)                      s_pfFun[ fnHX_get_u32 ]                 )
	#define	_HX_get_u64                     ( *(lpfHX_get_u64)                      s_pfFun[ fnHX_get_u64 ]                 )
	#define	_HX_invertMod                   ( *(lpfHX_invertMod)                    s_pfFun[ fnHX_invertMod ]               )
	#define	_HX_invertMod_u32               ( *(lpfHX_invertMod_u32)                s_pfFun[ fnHX_invertMod_u32 ]           )
	#define	_HX_isAbsOne                    ( *(lpfHX_isAbsOne)                     s_pfFun[ fnHX_isAbsOne ]                )
	#define	_HX_isBitOne                    ( *(lpfHX_isBitOne)                     s_pfFun[ fnHX_isBitOne ]                )
	#define	_HX_isEven                      ( *(lpfHX_isEven)                       s_pfFun[ fnHX_isEven ]                  )
	#define	_HX_isOdd                       ( *(lpfHX_isOdd)                        s_pfFun[ fnHX_isOdd ]                   )
	#define	_HX_isPrime                     ( *(lpfHX_isPrime)                      s_pfFun[ fnHX_isPrime ]                 )
	#define	_HX_isZero                      ( *(lpfHX_isZero)                       s_pfFun[ fnHX_isZero ]                  )
	#define	_HX_lcm                         ( *(lpfHX_lcm)                          s_pfFun[ fnHX_lcm ]                     )
	#define	_HX_lcm_v32                     ( *(lpfHX_lcm_v32)                      s_pfFun[ fnHX_lcm_v32 ]                 )
	#define	_HX_lcm_vhx                     ( *(lpfHX_lcm_vhx)                      s_pfFun[ fnHX_lcm_vhx ]                 )
	#define	_HX_log                         ( *(lpfHX_log)                          s_pfFun[ fnHX_log ]                     )
	#define	_HX_log_u32                     ( *(lpfHX_log_u32)                      s_pfFun[ fnHX_log_u32 ]                 )
	#define	_HX_lucas                       ( *(lpfHX_lucas)                        s_pfFun[ fnHX_lucas ]                   )
	#define	_HX_mod                         ( *(lpfHX_mod)                          s_pfFun[ fnHX_mod ]                     )
	#define	_HX_modPowTwo                   ( *(lpfHX_modPowTwo)                    s_pfFun[ fnHX_modPowTwo ]               )
	#define	_HX_mul                         ( *(lpfHX_mul)                          s_pfFun[ fnHX_mul ]                     )
	#define	_HX_mulMod                      ( *(lpfHX_mulMod)                       s_pfFun[ fnHX_mulMod ]                  )
	#define	_HX_mul_u32                     ( *(lpfHX_mul_u32)                      s_pfFun[ fnHX_mul_u32 ]                 )
	#define	_HX_negate                      ( *(lpfHX_negate)                       s_pfFun[ fnHX_negate ]                  )
	#define	_HX_new                         ( *(lpfHX_new)                          s_pfFun[ fnHX_new ]                     )
	#define	_HX_nextPrime                   ( *(lpfHX_nextPrime)                    s_pfFun[ fnHX_nextPrime ]               )
	#define	_HX_permutation                 ( *(lpfHX_permutation)                  s_pfFun[ fnHX_permutation ]             )
	#define	_HX_pow                         ( *(lpfHX_pow)                          s_pfFun[ fnHX_pow ]                     )
	#define	_HX_powMod                      ( *(lpfHX_powMod)                       s_pfFun[ fnHX_powMod ]                  )
	#define	_HX_powMod_u32                  ( *(lpfHX_powMod_u32)                   s_pfFun[ fnHX_powMod_u32 ]              )
	#define	_HX_powMod_u32_u32              ( *(lpfHX_powMod_u32_u32)               s_pfFun[ fnHX_powMod_u32_u32 ]          )
	#define	_HX_previousPrime               ( *(lpfHX_previousPrime)                s_pfFun[ fnHX_previousPrime ]           )
	#define	_HX_primeFactorial              ( *(lpfHX_primeFactorial)               s_pfFun[ fnHX_primeFactorial ]          )
	#define	_HX_product_v32                 ( *(lpfHX_product_v32)                  s_pfFun[ fnHX_product_v32 ]             )
	#define	_HX_product_vhx                 ( *(lpfHX_product_vhx)                  s_pfFun[ fnHX_product_vhx ]             )
	#define	_HX_random                      ( *(lpfHX_random)                       s_pfFun[ fnHX_random ]                  )
	#define	_HX_rootRem                     ( *(lpfHX_rootRem)                      s_pfFun[ fnHX_rootRem ]                 )
	#define	_HX_setHexStr                   ( *(lpfHX_setHexStr)                    s_pfFun[ fnHX_setHexStr ]               )
	#define	_HX_setText                     ( *(lpfHX_setText)                      s_pfFun[ fnHX_setText ]                 )

#ifndef _NO_HI
	#define	_HX_set_hi                      ( *(lpfHX_set_hi)                       s_pfFun[ fnHX_set_hi ]                  )
#endif	/* #ifndef _NO_HI */

	#define	_HX_set_hx                      ( *(lpfHX_set_hx)                       s_pfFun[ fnHX_set_hx ]                  )

#ifndef _NO_RC
	#define	_HX_set_rc                      ( *(lpfHX_set_rc)                       s_pfFun[ fnHX_set_rc ]                  )
#endif	/* #ifndef _NO_RC */

	#define	_HX_set_s32                     ( *(lpfHX_set_s32)                      s_pfFun[ fnHX_set_s32 ]                 )
	#define	_HX_set_s64                     ( *(lpfHX_set_s64)                      s_pfFun[ fnHX_set_s64 ]                 )
	#define	_HX_set_str                     ( *(lpfHX_set_str)                      s_pfFun[ fnHX_set_str ]                 )
	#define	_HX_set_u32                     ( *(lpfHX_set_u32)                      s_pfFun[ fnHX_set_u32 ]                 )
	#define	_HX_set_u64                     ( *(lpfHX_set_u64)                      s_pfFun[ fnHX_set_u64 ]                 )
	#define	_HX_sub                         ( *(lpfHX_sub)                          s_pfFun[ fnHX_sub ]                     )
	#define	_HX_sub_u32                     ( *(lpfHX_sub_u32)                      s_pfFun[ fnHX_sub_u32 ]                 )
	#define	_HX_sumsOfLikePowers_v32        ( *(lpfHX_sumsOfLikePowers_v32)         s_pfFun[ fnHX_sumsOfLikePowers_v32 ]    )
	#define	_HX_sumsOfLikePowers_vhx        ( *(lpfHX_sumsOfLikePowers_vhx)         s_pfFun[ fnHX_sumsOfLikePowers_vhx ]    )
	#define	_HX_swap                        ( *(lpfHX_swap)                         s_pfFun[ fnHX_swap ]                    )
	#define	_HX_testPrimality               ( *(lpfHX_testPrimality)                s_pfFun[ fnHX_testPrimality ]           )
	#define	_HX_truncate                    ( *(lpfHX_truncate)                     s_pfFun[ fnHX_truncate ]                )
#endif  /* #ifndef _NO_HX */



#ifndef _NO_RC
	#define	_RC_clearVector                 ( *(lpfRC_clearVector)                  s_pfFun[ fnRC_clearVector ]             )
	#define	_RC_convert2Radix               ( *(lpfRC_convert2Radix)                s_pfFun[ fnRC_convert2Radix ]           )
	#define	_RC_delete                      ( *(lpfRC_delete)                       s_pfFun[ fnRC_delete ]                  )
	#define	_RC_getRadix                    ( *(lpfRC_getRadix)                     s_pfFun[ fnRC_getRadix ]                )
	#define	_RC_getCount                    ( *(lpfRC_getCount)                     s_pfFun[ fnRC_getCount ]                )
	#define	_RC_getSign                     ( *(lpfRC_getSign)                      s_pfFun[ fnRC_getSign ]                 )
	#define	_RC_getVector                   ( *(lpfRC_getVector)                    s_pfFun[ fnRC_getVector ]               )
	#define	_RC_get_s32                     ( *(lpfRC_get_s32)                      s_pfFun[ fnRC_get_s32 ]                 )
	#define	_RC_get_s64                     ( *(lpfRC_get_s64)                      s_pfFun[ fnRC_get_s64 ]                 )
	#define	_RC_get_u32                     ( *(lpfRC_get_u32)                      s_pfFun[ fnRC_get_u32 ]                 )
	#define	_RC_get_u64                     ( *(lpfRC_get_u64)                      s_pfFun[ fnRC_get_u64 ]                 )
	#define	_RC_new                         ( *(lpfRC_new)                          s_pfFun[ fnRC_new ]                     )
	#define	_RC_new_str                     ( *(lpfRC_new_str)                      s_pfFun[ fnRC_new_str ]                 )
	#define	_RC_resetRadix                  ( *(lpfRC_resetRadix)                   s_pfFun[ fnRC_resetRadix ]              )
	#define	_RC_resetSign                   ( *(lpfRC_resetSign)                    s_pfFun[ fnRC_resetSign ]               )
	#define	_RC_resetVector                 ( *(lpfRC_resetVector)                  s_pfFun[ fnRC_resetVector ]             )

#ifnde

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -