hugecalc.c

这是一个应用软件,用于处理大数,里面包含一些小的实用的软件,如生成 素数 ,大数阶乘.

		"HX_powMod_u32_u32",
		"HX_previousPrime",
		"HX_primeFactorial",
		"HX_product_v32",
		"HX_product_vhx",
		"HX_random",
		"HX_rootRem",

	#if !( defined( UNICODE ) || defined( _UNICODE ))
		"HX_setHexStrA",
		"HX_setTextA",
	#else
		"HX_setHexStrW",
		"HX_setTextW",
	#endif

#ifndef _NO_HI
		"HX_set_hi",
#endif	/* #ifndef _NO_HI */

		"HX_set_hx",

#ifndef _NO_RC
		"HX_set_rc",
#endif	/* #ifndef _NO_RC */

		"HX_set_s32",
		"HX_set_s64",

	#if !( defined( UNICODE ) || defined( _UNICODE ))
		"HX_set_strA",
	#else
		"HX_set_strW",
	#endif

		"HX_set_u32",
		"HX_set_u64",
		"HX_sub",
		"HX_sub_u32",
		"HX_sumsOfLikePowers_v32",
		"HX_sumsOfLikePowers_vhx",
		"HX_swap",
		"HX_testPrimality",
		"HX_truncate",
#endif  /* #ifndef _NO_HX */



#ifndef _NO_RC
		"RC_clearVector",
		"RC_convert2Radix",
		"RC_delete",
		"RC_getRadix",
		"RC_getCount",
		"RC_getSign",
		"RC_getVector",
		"RC_get_s32",
		"RC_get_s64",
		"RC_get_u32",
		"RC_get_u64",
		"RC_new",

	#if !( defined( UNICODE ) || defined( _UNICODE ))
		"RC_new_strA",
	#else
		"RC_new_strW",
	#endif

		"RC_resetRadix",
		"RC_resetSign",
		"RC_resetVector",

#ifndef _NO_HI
		"RC_set_hi",
#endif	/* #ifndef _NO_RC */

#ifndef _NO_HX
		"RC_set_hx",
#endif	/* #ifndef _NO_HX */

		"RC_set_rc",
		"RC_get_s32",
		"RC_get_s64",
		"RC_get_u32",
		"RC_get_u64",
		"RC_sumOfDigits",
#endif	/* #ifndef _NO_RC */

	};	/* end "const char lpProcName[ _fnFunNums ][ 32 ] =" */


	/* ___Release existing library___ */
	hugeCalcDLLFree();

	/* ___Load library___1st:specified dir 2nd:Window default dir___ */
	if ( NULL != lpszDLLPath )
	{
		_tcscat( szDLLPathName, lpszDLLPath );
	}
	_tcscat( szDLLPathName, szDLLName );

	if ( NULL == ( s_hInstDLL = LoadLibrary( szDLLPathName )))
	{
		if ( NULL == ( s_hInstDLL = LoadLibrary( szDLLName )))
		{
			return FALSE;
		}
	}

#ifdef _DEBUG
	k = _fnFunNums;	/* 查看导出函数总数目 */
/*	printf( "%u\n", k );	*/
#endif

	for ( k = 0; k < _fnFunNums; ++k )
	{
		if ( NULL == ( s_pfFun[ k ] = GetProcAddress( s_hInstDLL, lpProcName[ k ] )))
		{
			hugeCalcDLLFree();
			return FALSE;
		}
	}

	return TRUE;
}

void hugeCalcDLLFree( void )
{
	if ( NULL != s_hInstDLL )
	{
		FreeLibrary( s_hInstDLL );
		s_hInstDLL = NULL;
	}
}



	typedef const LPCTSTR (WINAPI* lpfHC_getVer)( void );

	typedef const LPCTSTR (WINAPI* lpfHC_getSN)( void );

	typedef const HCLicenseLevel (WINAPI* lpfHC_getLicenseLevel)( void );
	typedef const UINT32 (WINAPI* lpfHC_getExportFunNums)( const UINT32 u32Mask /*= _HC_Export_ANSI_C*/ );

	typedef const HCErrCode (WINAPI* lpfHC_getLastError)( void );

	/* It usefull when use multithread. */
	typedef void (WINAPI* lpfHC_setTerminate)( const BOOL bTerminate /*= TRUE*/ );
	typedef const BOOL (WINAPI* lpfHC_isTerminated)( void );

	typedef void (WINAPI* lpfHC_seedRandom)( const UINT32 u32Seed /*= 0*/ );

	/* before calculate, pls call bEnableTimer as TRUE, and after finishing call as FALSE */
	typedef void (WINAPI* lpfHC_resetTimer)( const UINT32 u32Timer /*= 0*/, const TimerUnit enumTimerUnit /*= TIMER_UNIT_us*/ );
	typedef void (WINAPI* lpfHC_enableTimer)( const BOOL bEnableTimer /*= TRUE*/ );
	typedef const UINT32 (WINAPI* lpfHC_getTimer)( const TimerUnit enumTimerUnit /*= TIMER_UNIT_us*/ );
	typedef const LPCTSTR (WINAPI* lpfHC_getTimerStr)( const FormatTime enumFormatTime /*= FT_DOT06SEC_s*/ );

	typedef const BOOL (WINAPI* lpfHC_isPrime)( const UINT32 u32Num );
	typedef const UINT32 (WINAPI* lpfHC_getPrimePi)( const UINT32 u32Num );
	typedef const UINT32 (WINAPI* lpfHC_getPrime)( const UINT32 u32Index );
	typedef const UINT32 (WINAPI* lpfHC_getPrimeCount)( const UINT32 u32LBound, const UINT32 u32UBound );
	typedef const UINT32 (WINAPI* lpfHC_getPrimeList)( UINT32 * const lpPrimeBuffer, const UINT32 u32BufferSize, const UINT32 u32LBound, const UINT32 u32UBound );

	/* Returns the largest prime number less than the argument. */
	typedef const SINT32 (WINAPI* lpfHC_previousPrime)( const SINT32 s32Benchmark );
	/* Returns the smallest prime number greater than the argument. */
	typedef const SINT32 (WINAPI* lpfHC_nextPrime)( const SINT32 s32Benchmark );

	/* Greatest Common Divisor */
	typedef const UINT32 (WINAPI* lpfHC_gcd)( const UINT32 u32Num1, const UINT32 u32Num2 );

	typedef const UINT32 (WINAPI* lpfHC_gcd_v32)( const UINT32_CVECTOR vU32Num );

	/* GcdEx: g = GcdEx)( x, y, u, v ) = u * x + v * y. g is always positive, even if one or both of u and v are negative. */
	typedef const UINT32 (WINAPI* lpfHC_gcdEx)( SINT32 * const x, SINT32 * const y, const SINT32 u, const SINT32 v );

	typedef const UINT32 (WINAPI* lpfHC_invertMod)( const UINT32 u32InvertBase, const UINT32 u32Mod );

	/* Lowest Common Multiple */
	typedef const UINT64 (WINAPI* lpfHC_lcm)( const UINT32 u32Num1, const UINT32 u32Num2 );

	/* PowMod */
	typedef const UINT32 (WINAPI* lpfHC_powMod)( const UINT32 u32Base, const UINT32 u32Exp, const UINT32 u32Mod );



#ifndef _NO_HI
	/* constructor */
	typedef HHUGEINT (WINAPI* lpfHI_new)( void );

	/* destructor */
	typedef void (WINAPI* lpfHI_delete)( HHUGEINT hHugeInt );

	typedef const UINT32 (WINAPI* lpfHI_getCount)( void );

	/* reload operators */
	typedef HHUGEINT (WINAPI* lpfHI_set_s32)( HHUGEINT hHugeInt, const SINT32 s32Num );
	typedef HHUGEINT (WINAPI* lpfHI_set_s64)( HHUGEINT hHugeInt, const SINT64 s64Num );
	typedef HHUGEINT (WINAPI* lpfHI_set_u32)( HHUGEINT hHugeInt, const UINT32 u32Num );
	typedef HHUGEINT (WINAPI* lpfHI_set_u64)( HHUGEINT hHugeInt, const UINT64 u64Num );
	typedef HHUGEINT (WINAPI* lpfHI_set_str)( HHUGEINT hHugeInt, const LPCTSTR lpszNum );
	typedef HHUGEINT (WINAPI* lpfHI_set_hi)( HHUGEINT hHugeInt, const HHUGEINT hRight );

#ifndef _NO_HX
	typedef HHUGEINT (WINAPI* lpfHI_set_hx)( HHUGEINT hHugeInt, const HHUGEINTX hRight );
#endif	/* #ifndef _NO_HX */

#ifndef _NO_RC
	typedef HHUGEINT (WINAPI* lpfHI_set_rc)( HHUGEINT hHugeInt, const HRADIXCONVERTER hRight );
#endif	/* #ifndef _NO_RC */

	typedef HHUGEINT (WINAPI* lpfHI_setHexStr)( HHUGEINT hHugeInt, const LPCTSTR lpszHexNum );

	/* Return non-zero if the value of )(*this) fits in SINT32, UINT32, SINT64 or UINT64, respectively. Otherwise, return zero. */
	typedef const SINT32 (WINAPI* lpfHI_get_s32)( const HHUGEINT hHugeInt );
	typedef const SINT64 (WINAPI* lpfHI_get_s64)( const HHUGEINT hHugeInt );
	typedef const UINT32 (WINAPI* lpfHI_get_u32)( const HHUGEINT hHugeInt );
	typedef const UINT64 (WINAPI* lpfHI_get_u64)( const HHUGEINT hHugeInt );

	/* CompareAbs */
	typedef const SINT32 (WINAPI* lpfHI_compareAbs_s32)( const HHUGEINT hLeft, const SINT32 s32Num );
	typedef const SINT32 (WINAPI* lpfHI_compareAbs_u32)( const HHUGEINT hLeft, const UINT32 u32Num );
	typedef const SINT32 (WINAPI* lpfHI_compareAbs_hi)( const HHUGEINT hLeft, const HHUGEINT hRight );

	/* Compare */
	typedef const SINT32 (WINAPI* lpfHI_compare_s32)( const HHUGEINT hLeft, const SINT32 s32Num );
	typedef const SINT32 (WINAPI* lpfHI_compare_u32)( const HHUGEINT hLeft, const UINT32 u32Num );
	typedef const SINT32 (WINAPI* lpfHI_compare_hi)( const HHUGEINT hLeft, const HHUGEINT hRight );

	/* get property */
	typedef const SIGN (WINAPI* lpfHI_getSign)( const HHUGEINT hHugeInt );
	typedef const BOOL (WINAPI* lpfHI_isZero)( const HHUGEINT hHugeInt );
	typedef const BOOL (WINAPI* lpfHI_isAbsOne)( const HHUGEINT hHugeInt );
	typedef const BOOL (WINAPI* lpfHI_isOdd)( const HHUGEINT hHugeInt );
	typedef const BOOL (WINAPI* lpfHI_isEven)( const HHUGEINT hHugeInt );
	typedef const BOOL (WINAPI* lpfHI_isPrime)( const HHUGEINT hHugeInt );
	typedef const PRIMALITY (WINAPI* lpfHI_testPrimality)( const HHUGEINT hHugeInt, const UINT32 u32Repeat /*= 5*/ );
	typedef const UINT32 (WINAPI* lpfHI_getBits)( const HHUGEINT hHugeInt );
	typedef const UINT32 (WINAPI* lpfHI_getDigits)( const HHUGEINT hHugeInt );
	typedef const UINT32 (WINAPI* lpfHI_getTailDecZeros)( const HHUGEINT hHugeInt );

	typedef HHUGEINT (WINAPI* lpfHI_bitLShift)( HHUGEINT hHugeInt, const UINT32 u32BitLShift );
	typedef HHUGEINT (WINAPI* lpfHI_bitRShift)( HHUGEINT hHugeInt, const UINT32 u32BitRShift );

	/* notice: base on decimal system !! */
	typedef HHUGEINT (WINAPI* lpfHI_decLShift)( HHUGEINT hHugeInt, const UINT32 u32DecLShift );
	typedef HHUGEINT (WINAPI* lpfHI_decRShift)( HHUGEINT hHugeInt, const UINT32 u32DecRShift );

	typedef HHUGEINT (WINAPI* lpfHI_bitAnd)( HHUGEINT hResult, const HHUGEINT hLeft, const HHUGEINT hRight );
	typedef HHUGEINT (WINAPI* lpfHI_bitXor)( HHUGEINT hResult, const HHUGEINT hLeft, const HHUGEINT hRight );
	typedef HHUGEINT (WINAPI* lpfHI_bitOr)( HHUGEINT hResult, const HHUGEINT hLeft, const HHUGEINT hRight );


	typedef HHUGEINT (WINAPI* lpfHI_abs)( HHUGEINT hHugeInt );
	typedef HHUGEINT (WINAPI* lpfHI_negate)( HHUGEINT hHugeInt );
	typedef HHUGEINT (WINAPI* lpfHI_swap)( HHUGEINT hLeft, HHUGEINT hRight );

	typedef HHUGEINT (WINAPI* lpfHI_ceil)( HHUGEINT hHugeInt, const UINT32 u32DecDigits );
	typedef HHUGEINT (WINAPI* lpfHI_truncate)( HHUGEINT hHugeInt, const UINT32 u32DecDigits );
	typedef HHUGEINT (WINAPI* lpfHI_floor)( HHUGEINT hHugeInt, const UINT32 u32DecDigits );

	typedef HHUGEINT (WINAPI* lpfHI_random)( HHUGEINT hHugeInt, const UINT32 u32DecDigits );
	typedef HHUGEINT (WINAPI* lpfHI_generatePrime)( HHUGEINT hHugeInt, const UINT32 u32DecDigits );
	typedef HHUGEINT (WINAPI* lpfHI_previousPrime)( HHUGEINT hResult, const HHUGEINT hBenchmark );
	typedef HHUGEINT (WINAPI* lpfHI_nextPrime)( HHUGEINT hResult, const HHUGEINT hBenchmark );

	/* + */
	typedef HHUGEINT (WINAPI* lpfHI_add)( HHUGEINT hResult, const HHUGEINT hLeft, const HHUGEINT hRight );
	typedef HHUGEINT (WINAPI* lpfHI_add_u32)( HHUGEINT hResult, const HHUGEINT hLeft, const UINT32 u32Num );

	/* - */
	typedef HHUGEINT (WINAPI* lpfHI_sub)( HHUGEINT hResult, const HHUGEINT hLeft, const HHUGEINT hRight );
	typedef HHUGEINT (WINAPI* lpfHI_sub_u32)( HHUGEINT hResult, const HHUGEINT hLeft, const UINT32 u32Num );

	/* * */
	typedef HHUGEINT (WINAPI* lpfHI_mul)( HHUGEINT hResult, const HHUGEINT hLeft, const HHUGEINT hRight );
	typedef HHUGEINT (WINAPI* lpfHI_mul_u32)( HHUGEINT hResult, const HHUGEINT hLeft, const UINT32 u32Num );

	/* Division, return quotient */