int 128 实现

最新推荐文章于 2024-09-04 22:22:27 发布
最新推荐文章于 2024-09-04 22:22:27 发布
阅读量1.5k 收藏
点赞数
文章标签： dst c parameters interface file class

来源 http://www.pudn.com/downloads2/sourcecode/windows/other/detail4334.html

 

// ALU.h: interface for the CALU class.
//
//
 
#if !defined(AFX_ALU_H__1B2838C0_9CDB_11D6_879C_A66C3336830C__INCLUDED_)
#define AFX_ALU_H__1B2838C0_9CDB_11D6_879C_A66C3336830C__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
#define   OF   0X0800
#define   DF   0X0400
#define   IF   0X0200
#define   TF   0X0100
#define   SF   0X0080
#define   ZF   0X0040
#define   AF   0X0010
#define   PF   0X0004
#define   CF   0X0001
 
//  15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0   
// +-----------------------------------------------+
// |  |  |  |  |OF|DF|IF|TF|SF|ZF|  |AF|  |PF|  |CF|      
// +-----------------------------------------------+
 
//#define   LO32 ( (nn_Temp) )  ( (unsigned long)( (

(nn_Temp) & ( (unsigned __int64)(0X00000000FFFFFFFF))   ) )   )
//#define   HI32 ( (nn_Temp) )  ( (unsigned long)( (

(nn_Temp) & (((unsigned __int64)(0XFFFFFFFF00000000)) >> 32 ) ) ) )
 
#define   NOFLAG  0
#define   MAX   0XFFFFFFFF
 
 


//$//                                                                          
//$//                    作者 : 韩 松                                 
//$//                                                                          
//$//  程序名称　：CALU           
//$//       发布日期  ：02/10/01 
//$//  邮箱地址　：hs_china@yahoo.com
//$//     
//$//  作者声明　：此部分代码全是作者所写，可以随便传播，但要保持
//$//       文件的完整性,如果您有问题或有好的建议、意见请您
//$//          给我来信,非常感谢!   
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
//$//       


 
 
typedef unsigned __int64 UINT64;
 
class CALU  
{
public:
 void MUL( UINT64& DST, DWORD SRC1, DWORD SRC2 );
 inline void ADD ( DWORD& DST, DWORD SRC );
 inline void ADC ( DWORD& DST, DWORD SRC );
     void ADD ( DWORD& DST, DWORD SRC1, DWORD SRC2 );
     void ADC ( DWORD& DST, DWORD SRC1, DWORD SRC2 );
 
 inline void SUB ( DWORD& DST, DWORD SRC );
 inline void SBB ( DWORD& DST, DWORD SRC );
     void SUB ( DWORD& DST, DWORD SRC1, DWORD SRC2 );
     void SBB ( DWORD& DST, DWORD SRC1, DWORD SRC2 );
 
     void AND ( DWORD& DST, const DWORD SRC );
     void OR  ( DWORD& DST, const DWORD SRC );
     void NOT ( DWORD& DST );
     void XOR ( DWORD& DST, DWORD SRC );
     void TEST( const DWORD OPR1, const DWORD OPR2 );
 
     void SHL ( DWORD& OPR, const UINT CNT );
     void SHL ( DWORD& DST, DWORD& SRC, const UINT CNT );
     void SHL ( DWORD& DSTH,DWORD& DSTL,DWORD SRC, const UINT CNT );
 
     void SHR ( DWORD& OPR, const UINT CNT );
        void SHR ( DWORD& SRC, DWORD& DST, const UINT CNT );
     void SHR ( DWORD  SRC, DWORD& DSTH,DWORD& DSTL, const UINT CNT);
 
     void STC ( void );
     void CMC ( void );
     void CLC ( void );
 
     DWORD HI32( const UINT64& nnTemp );
     DWORD LO32( const UINT64& nnTemp );
 
private:
 
 inline void ClearPSW( const unsigned short Flag );
 inline void SetPSW ( const unsigned short Flag );
 inline bool GetPSW ( const unsigned short Flag ) const;
 inline void SetPSW ( unsigned short Flag, const DWORD& Set );
 
protected:
 
 CALU();
 virtual ~CALU();
 
private:
 
 
 unsigned short PSW;
};
 
#endif // !defined(AFX_ALU_H__1B2838C0_9CDB_11D6_879C_A66C3336830C__INCLUDED_)

 

 

 

// ALU.h: interface for the CALU class. 
// 
// 
 
#if !defined(AFX_ALU_H__1B2838C0_9CDB_11D6_879C_A66C3336830C__INCLUDED_) 
#define AFX_ALU_H__1B2838C0_9CDB_11D6_879C_A66C3336830C__INCLUDED_ 
 
#if _MSC_VER > 1000 
#pragma once 
#endif // _MSC_VER > 1000 
 
#define			OF			0X0800 
#define			DF			0X0400 
#define			IF			0X0200 
#define			TF			0X0100 
#define			SF			0X0080 
#define			ZF			0X0040 
#define			AF			0X0010 
#define			PF			0X0004 
#define			CF			0X0001 
 
//	 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0    
//	+-----------------------------------------------+ 
//	|  |  |  |  |OF|DF|IF|TF|SF|ZF|  |AF|  |PF|  |CF|       
//	+-----------------------------------------------+ 
 
//#define			LO32 ( (nn_Temp) )		( (unsigned long)( ( (nn_Temp) & ( (unsigned __int64)(0X00000000FFFFFFFF))		 ) )   ) 
//#define			HI32 ( (nn_Temp) )		( (unsigned long)( ( (nn_Temp) & (((unsigned __int64)(0XFFFFFFFF00000000)) >> 32 ) ) ) ) 
 
#define			NOFLAG		0 
#define			MAX			0XFFFFFFFF 
 
 
 
//$//                                                                           
//$//			         	       作者 : 韩 松                                  
//$//                                                                           
//$//		程序名称　：CALU            
//$//       发布日期  ：02/10/01  
//$//		邮箱地址　：hs_china@yahoo.com 
//$//					 
//$//		作者声明　：此部分代码全是作者所写，可以随便传播，但要保持 
//$//				   文件的完整性,如果您有问题或有好的建议、意见请您 
//$//			       给我来信,非常感谢!			 
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 
//$//							 
 
 
 
typedef unsigned __int64	UINT64; 
 
class CALU   
{ 
public: 
	void MUL( UINT64& DST, DWORD SRC1, DWORD SRC2 ); 
	inline void ADD ( DWORD& DST, DWORD SRC ); 
	inline void ADC ( DWORD& DST, DWORD SRC ); 
		   void ADD ( DWORD& DST, DWORD SRC1, DWORD SRC2 ); 
		   void ADC ( DWORD& DST, DWORD SRC1, DWORD SRC2 ); 
 
	inline void SUB ( DWORD& DST, DWORD SRC ); 
	inline void SBB ( DWORD& DST, DWORD SRC ); 
		   void SUB ( DWORD& DST, DWORD SRC1, DWORD SRC2 ); 
		   void SBB ( DWORD& DST, DWORD SRC1, DWORD SRC2 ); 
 
		   void AND ( DWORD& DST, const DWORD SRC ); 
		   void OR  ( DWORD& DST, const DWORD SRC ); 
		   void NOT ( DWORD& DST ); 
		   void XOR ( DWORD& DST, DWORD SRC ); 
		   void TEST( const DWORD OPR1, const DWORD OPR2 ); 
 
		   void SHL	( DWORD& OPR, const UINT CNT ); 
		   void SHL	( DWORD& DST, DWORD& SRC, const UINT CNT ); 
		   void SHL	( DWORD& DSTH,DWORD& DSTL,DWORD SRC, const UINT CNT ); 
 
		   void SHR	( DWORD& OPR, const UINT CNT ); 
	   	   void SHR	( DWORD& SRC, DWORD& DST, const UINT CNT ); 
		   void SHR	( DWORD  SRC, DWORD& DSTH,DWORD& DSTL, const UINT CNT); 
 
		   void STC	( void ); 
		   void CMC	( void ); 
		   void CLC	( void ); 
 
		   DWORD HI32( const UINT64& nnTemp ); 
		   DWORD LO32( const UINT64& nnTemp ); 
 
private: 
	 
	inline void ClearPSW( const unsigned short Flag ); 
	inline void SetPSW	( const unsigned short Flag ); 
	inline bool GetPSW	( const unsigned short Flag ) const; 
	inline void SetPSW	( unsigned short Flag, const DWORD& Set ); 
 
protected: 
	 
	CALU(); 
	virtual ~CALU(); 
 
private: 
 
 
	unsigned short	PSW; 
}; 
 
#endif // !defined(AFX_ALU_H__1B2838C0_9CDB_11D6_879C_A66C3336830C__INCLUDED_)

 

 

 

  1. // ALU.cpp: implementation of the CALU class.    
  2. //    
  3. //   
  4.    
  5. #include "stdafx.h"    
  6. #include "Int128.h"    
  7. #include "ALU.h"    
  8.    
  9. #ifdef _DEBUG    
  10. #undef THIS_FILE    
  11. static char THIS_FILE[]=__FILE__;   
  12. #define new DEBUG_NEW    
  13. #endif    
  14.    
  15.    
  16.    
  17.    
  18. //$//                                                                             
  19. //$//                              作者 : 韩 松                                    
  20. //$//                                                                             
  21. //$//       程序名称　：CALU               
  22. //$//       发布日期  ：02/10/01     
  23. //$//       邮箱地址　：hs_china@yahoo.com    
  24. //$//                       
  25. //$//       作者声明　：此部分代码全是作者所写，可以随便传播，但要保持   
  26. //$//                  文件的完整性,如果您有问题或有好的建议、意见请您   
  27. //$//                  给我来信,非常感谢!              
  28. //$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　    
  29. //$//                               
  30.    
  31.    
  32.    
  33. //   
  34. // Construction/Destruction    
  35. //   
  36.    
  37. CALU::CALU()   
  38. {   
  39.     PSW = NOFLAG;   
  40. }   
  41.    
  42. CALU::~CALU()   
  43. {   
  44.    
  45. }   
  46.    
  47. // Set Flag    
  48. inline void CALU::SetPSW(unsigned short Flag, const DWORD& Set)   
  49. {   
  50.     if ( Set )   
  51.          PSW |=  Flag;   
  52.     else PSW &= ~Flag;   
  53. }   
  54.    
  55. // Get Flag    
  56. inline bool CALU::GetPSW(const unsigned short Flag) const   
  57. {   
  58.     return ( ( PSW & Flag ) != 0 );   
  59. }   
  60.    
  61. // Set Flag    
  62. inline void CALU::SetPSW(const unsigned short Flag)   
  63. {   
  64.     PSW |= Flag;   
  65. }   
  66.    
  67. // Clear Flag    
  68. inline void CALU::ClearPSW(const unsigned short Flag)   
  69. {   
  70.     PSW &= ~Flag;   
  71. }   
  72.    
  73. // Get Low 32 Bit ( unsinged __int64 )    
  74. DWORD CALU::LO32(const UINT64 &nnTemp)   
  75. {   
  76.     return ( (DWORD)( (  (UINT64)(nnTemp)) & ((UINT64)(0X00000000FFFFFFFF)) ) );   
  77. }   
  78.    
  79. // Get High 32 Bit ( unsinged __int64 )    
  80. DWORD CALU::HI32(const UINT64 &nnTemp)   
  81. {   
  82.     return ( (DWORD)( ( ((UINT64)(nnTemp)) & ((UINT64)(0XFFFFFFFF00000000))) >> 32 ) );          
  83. }   
  84.    
  85. // Clear Carry    
  86. void CALU::CLC()   
  87. {   
  88.     ClearPSW( CF );   
  89. }   
  90.    
  91. // Complement Carry    
  92. inline void CALU::CMC()   
  93. {   
  94.     if ( GetPSW( CF ) )   
  95.          CLC();   
  96.     else STC();   
  97. }   
  98.    
  99. // Set Carry    
  100. inline void CALU::STC()   
  101. {   
  102.     SetPSW( CF );   
  103. }   
  104.    
  105. // Test    
  106. void CALU::TEST(const DWORD OPR1, const DWORD OPR2)   
  107. {   
  108.     SetPSW( ZF, ( ( OPR1 & OPR2 )==0 ) );   
  109. }   
  110.    
  111. // And    
  112. void CALU::AND(DWORD &DST, const DWORD SRC)   
  113. {   
  114.     DST &= SRC;   
  115. }   
  116.    
  117. // Or    
  118. void CALU::OR(DWORD &DST, const DWORD SRC)   
  119. {   
  120.     DST |= SRC;   
  121. }   
  122.    
  123. // Not    
  124. void CALU::NOT(DWORD &DST)   
  125. {   
  126.     DST = ~DST;   
  127. }   
  128.    
  129. // Exclusive or    
  130. void CALU::XOR(DWORD &DST, DWORD SRC)   
  131. {   
  132.     DST ^= SRC;   
  133. }   
  134.    
  135. // Add    
  136. inline void CALU::ADD(DWORD &DST, DWORD SRC)   
  137. {   
  138.     UINT64  nnTemp;   
  139.    
  140.     nnTemp = (UINT64)DST + (UINT64)SRC;   
  141.    
  142.     SetPSW( CF, ( nnTemp > MAX ) );   
  143.    
  144.     DST = LO32( nnTemp );   
  145. }   
  146.    
  147. // Add width Carry    
  148. inline void CALU::ADC(DWORD &DST, DWORD SRC)   
  149. {   
  150.     UINT64  nnTemp;   
  151.    
  152.     nnTemp = (UINT64)DST + (UINT64)SRC + (int)GetPSW( CF );   
  153.    
  154.     SetPSW( CF, ( nnTemp > MAX ) );   
  155.    
  156.     DST = LO32( nnTemp );    
  157. }   
  158.    
  159. // Add 3 Parameters    
  160. void CALU::ADD(DWORD &DST, DWORD SRC1, DWORD SRC2)   
  161. {   
  162.     ADD( SRC1, SRC2 );   
  163.    
  164.     DST = SRC1;   
  165. }   
  166.    
  167. // Add With Carry   3 Parameter    
  168. void CALU::ADC(DWORD &DST, DWORD SRC1, DWORD SRC2)   
  169. {   
  170.     ADC( SRC1, SRC2 );   
  171.    
  172.     DST = SRC1;   
  173. }   
  174.    
  175. // Subtract    
  176. inline void CALU::SUB(DWORD &DST, DWORD SRC)   
  177. {   
  178.     UINT64  nnTemp;   
  179.    
  180.     nnTemp = (UINT64)DST - (UINT64)SRC;   
  181.    
  182.     SetPSW( CF, ( nnTemp > MAX ) );   
  183.    
  184.     DST = (DWORD)nnTemp;   
  185. }   
  186.    
  187. // Subtract with borrow    
  188. inline void CALU::SBB(DWORD &DST, DWORD SRC)   
  189. {   
  190.     UINT64  nnTemp;   
  191.    
  192.     nnTemp = (UINT64)DST - (UINT64)SRC - (int)GetPSW( CF );   
  193.    
  194.     SetPSW( CF, ( nnTemp > MAX ) );   
  195.    
  196.     DST = (DWORD)nnTemp;   
  197. }   
  198.    
  199. // Subtract 3 Parameters    
  200. void CALU::SUB(DWORD &DST, DWORD SRC1, DWORD SRC2)   
  201. {   
  202.     SUB( SRC1, SRC2 );   
  203.    
  204.     DST = SRC1;   
  205. }   
  206.    
  207. // Subtrace with borrow 3 Parameters    
  208. void CALU::SBB(DWORD &DST, DWORD SRC1, DWORD SRC2)   
  209. {   
  210.     SBB( SRC1, SRC2 );   
  211.    
  212.     DST = SRC1;   
  213. }   
  214.    
  215. // Shift logical left  ( CNT >= 1 )    
  216. void CALU::SHL(DWORD &OPR, const UINT CNT)   
  217. {   
  218.     OPR <= ( CNT - 1 );   
  219.        
  220.     SetPSW( CF, ( ( OPR & 0X80000000 ) != 0 ) );   
  221.    
  222.     OPR <= 1;   
  223. }   
  224.    
  225. // Shift logical left  ( CNT >= 1 )   return Low 32 Bit   
  226. void CALU::SHL( DWORD& DSTH, DWORD& DSTL, DWORD SRC, const UINT CNT)   
  227. {   
  228.     UINT64  nnTemp = (UINT64)SRC;   
  229.    
  230.     nnTemp <= ( CNT - 1 );   
  231.        
  232.     SetPSW( CF, ( ( nnTemp & UINT64(0X8000000000000000) ) != 0 ) );   
  233.    
  234.     nnTemp <= 1;   
  235.    
  236.     DSTH = HI32( nnTemp );   
  237.     DSTL = LO32( nnTemp );   
  238. }   
  239.    
  240. // Mov uShift Bit To DST     
  241. void CALU::SHL(DWORD &DST, DWORD &SRC, const UINT CNT)   
  242. {   
  243.     DWORD   DSTH = 0;   
  244.    
  245.     SHL( DSTH, SRC, SRC, CNT );   
  246.    
  247.     DST |= DSTH;   
  248. }   
  249.    
  250. // Shift Arithmetic right   CNT >= 1    
  251. void CALU::SHR(DWORD &OPR, const UINT CNT)   
  252. {   
  253.     OPR >>= ( CNT - 1 );   
  254.        
  255.     SetPSW( CF, ( ( OPR & 0X00000001 ) != 0 ) );   
  256.    
  257.     OPR >>= 1;       
  258. }   
  259.    
  260. //     
  261. void CALU::SHR(DWORD SRC, DWORD &DSTH, DWORD &DSTL, const UINT CNT)   
  262. {   
  263.     UINT64  nnTemp = (UINT64)SRC;   
  264.    
  265.     nnTemp <= 32;   
  266.    
  267.     nnTemp >>= ( CNT - 1 );   
  268.    
  269.     SetPSW( CF, ( ( nnTemp & 0X0000000000000001 ) != 0 ) );   
  270.    
  271.     nnTemp >>= 1;   
  272.    
  273.     DSTH = HI32( nnTemp );   
  274.     DSTL = LO32( nnTemp );   
  275. }   
  276.    
  277. //     
  278. void CALU::SHR(DWORD &SRC, DWORD &DST, const UINT CNT)   
  279. {   
  280.     DWORD   DSTL = 0;   
  281.        
  282.     SHR( SRC, SRC, DSTL, CNT );    
  283.    
  284.     DST |= DSTL;   
  285. }   
  286.    
  287. void CALU::MUL(UINT64 &DST, DWORD SRC1, DWORD SRC2)   
  288. {   
  289.      DST = ( SRC1 * SRC2 );   
  290. }   

 

// Int128.h: interface for the CHSInt128 class.
//
//
 
 
#if !defined(AFX_INT100_H__44379E2E_9CCE_11D6_879C_D4EFB1FC566C__INCLUDED_)
#define AFX_INT100_H__44379E2E_9CCE_11D6_879C_D4EFB1FC566C__INCLUDED_
 
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
 
 


//$//                                                                          
//$//                    作者 : 韩 松                                 
//$//                                                                          
//$//  程序名称　：CHSInt128           
//$//       发布日期  ：02/10/01 
//$//  邮箱地址　：hs_china@yahoo.com
//$//     
//$//  作者声明　：此部分代码全是作者所写，可以随便传播，但要保持
//$//       文件的完整性,如果您有问题或有好的建议、意见请您
//$//          给我来信,非常感谢!   
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
//$//       


 
 
#include "alu.h"

 
/*
 127     0
+-----------------------+
| m_D | m_C | m_B | m_A |
+-----------------------+
*/
 
 
 
class CHSInt128  : private CALU
{
public:
 DWORD m_A;          

  // Low 32 Bit
 DWORD m_B;
 DWORD m_C; 
 DWORD m_D;          

  // Heigh 32 Bit
 
public:
 CHSInt128  ( const int   nValue  );
 CHSInt128  ( const long  lValue  );
 CHSInt128  ( const __int64& nnValue );
 CHSInt128  ( const UINT  uValue  );
 CHSInt128  ( const DWORD  dwValue );
 CHSInt128  ( const UINT64&  nnValue );
 CHSInt128  ( const CHSInt128& iValue  );
 CHSInt128  ();
 virtual   ~CHSInt128();
 
 bool   ToStr  ( CString& strValue );
 bool   FromStr  ( LPCTSTR lpszValue );
 CHSInt128&  operator= ( const CHSInt128& iValue );
 
 CHSInt128  operator- ( const CHSInt128& iValue ); // const;
 CHSInt128&  operator-= ( const CHSInt128& iValue );
 CHSInt128  operator+ ( const CHSInt128& iValue ); // const;
 CHSInt128&  operator+= ( const CHSInt128& iValue );
 CHSInt128  operator* ( const CHSInt128& iValue ) const;
 CHSInt128&  operator*= ( const CHSInt128& iValue );
 CHSInt128  operator/ ( const CHSInt128& iValue ) const;
 CHSInt128&  operator/= ( const CHSInt128& iValue );
 CHSInt128  operator% ( const CHSInt128& iValue ) const;
 CHSInt128&  operator%= ( const CHSInt128& iValue );
 
 CHSInt128&  operator++ ( void );     

 // ++n  
 CHSInt128&  operator-- ( void );     

 // --n 
 CHSInt128  operator++ ( int );     

 // n++   
 CHSInt128  operator-- ( int );     

 // n--
 
 CHSInt128  operator^ ( const CHSInt128& iValue ) const;
 CHSInt128  operator& ( const CHSInt128& iValue ) const;
 CHSInt128  operator| ( const CHSInt128& iValue ) const;
 CHSInt128  operator~ ( void ) const;
 
 CHSInt128&  operator^= ( const CHSInt128& iValue );
 CHSInt128&  operator&= ( const CHSInt128& iValue );
 CHSInt128&  operator|= ( const CHSInt128& iValue );
 
 CHSInt128  operator<  ( const UINT nShift );
 CHSInt128&  operator<= ( const UINT nShift );
 CHSInt128  operator>>  ( const UINT nShift );
 CHSInt128&  operator>>= ( const UINT nShift );
 
 bool   operator== ( const CHSInt128& iValue ) const;
 bool   operator!= ( const CHSInt128& iValue ) const;
 bool   operator> ( const CHSInt128& iValue ) const;
 bool   operator< ( const CHSInt128& iValue ) const;
 bool   operator>= ( const CHSInt128& iValue ) const;
 bool   operator= ( const CHSInt128& iValue ) const;
/*
 operator int();
 operator unsigned int();
 operator long();
 operator unsigned long();
 operator __int64();
 operator unsigned __int64();
*/
 
 void   SetPositiveFlag  ( void );
 void   SetNegativeFlag  ( void );
 void   Complement   ( void );
 void   ComplementInverse( void );
 void   Min     ( void );
 void   Max     ( void );
 void   Zero    ( void );
 void   SetAt    ( UINT uIndex, bool bSet );
 
 bool   IsZero    ( void ) const;
 bool   IsNegative   ( void ) const;
 bool   IsPositive   ( void ) const;
 bool   GetAt    ( UINT uIndex ) const;
 CHSInt128  GetRight   ( UINT uCount ) const;
 CHSInt128  GetLeft    ( UINT uCount ) const;
 
 void  Division    ( const CHSInt128& iDivisor,

CHSInt128& iQuotient, CHSInt128& iRemainder) const;
 
};
 
#endif // !defined(AFX_INT100_H__44379E2E_9CCE_11D6_879C_D4EFB1FC566C__INCLUDED_)

 

 

// Int128.h: interface for the CHSInt128 class. 
// 
// 
 
 
#if !defined(AFX_INT100_H__44379E2E_9CCE_11D6_879C_D4EFB1FC566C__INCLUDED_) 
#define AFX_INT100_H__44379E2E_9CCE_11D6_879C_D4EFB1FC566C__INCLUDED_ 
 
#if _MSC_VER > 1000 
#pragma once 
#endif // _MSC_VER > 1000 
 
 
 
//$//                                                                           
//$//			         	       作者 : 韩 松                                  
//$//                                                                           
//$//		程序名称　：CHSInt128            
//$//       发布日期  ：02/10/01  
//$//		邮箱地址　：hs_china@yahoo.com 
//$//					 
//$//		作者声明　：此部分代码全是作者所写，可以随便传播，但要保持 
//$//				   文件的完整性,如果您有问题或有好的建议、意见请您 
//$//			       给我来信,非常感谢!			 
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 
//$//							 
 
 
 
#include "alu.h" 
 
 
/* 
 127				 0 
+-----------------------+ 
| m_D | m_C | m_B | m_A | 
+-----------------------+ 
*/ 
 
 
 
class CHSInt128  : private CALU 
{ 
public: 
	DWORD	m_A;												// Low 32 Bit 
	DWORD	m_B; 
	DWORD	m_C;	 
	DWORD	m_D;												// Heigh 32 Bit 
 
public: 
	CHSInt128		( const int		 nValue  ); 
	CHSInt128		( const long	 lValue  ); 
	CHSInt128		( const __int64& nnValue ); 
	CHSInt128		( const UINT	 uValue  ); 
	CHSInt128		( const DWORD	 dwValue ); 
	CHSInt128		( const UINT64&	 nnValue ); 
	CHSInt128		( const CHSInt128& iValue  ); 
	CHSInt128		(); 
	virtual			~CHSInt128(); 
 
	bool			ToStr		( CString& strValue ); 
	bool			FromStr		( LPCTSTR lpszValue ); 
	CHSInt128&		operator=	( const CHSInt128& iValue ); 
	 
	CHSInt128		operator-	( const CHSInt128& iValue );	// const; 
	CHSInt128&		operator-=	( const CHSInt128& iValue ); 
	CHSInt128		operator+	( const CHSInt128& iValue );	// const; 
	CHSInt128&		operator+=	( const CHSInt128& iValue ); 
	CHSInt128		operator*	( const CHSInt128& iValue ) const; 
	CHSInt128&		operator*=	( const CHSInt128& iValue ); 
	CHSInt128		operator/	( const CHSInt128& iValue ) const; 
	CHSInt128&		operator/=	( const CHSInt128& iValue ); 
	CHSInt128		operator%	( const CHSInt128& iValue ) const; 
	CHSInt128&		operator%=	( const CHSInt128& iValue ); 
 
	CHSInt128&		operator++	( void );						// ++n		 
	CHSInt128&		operator--	( void );						// --n	 
	CHSInt128		operator++	( int );						// n++			 
	CHSInt128		operator--	( int );						// n-- 
 
	CHSInt128		operator^	( const CHSInt128& iValue ) const; 
	CHSInt128		operator&	( const CHSInt128& iValue ) const; 
	CHSInt128		operator|	( const CHSInt128& iValue ) const; 
	CHSInt128		operator~	( void ) const; 
 
	CHSInt128&		operator^=	( const CHSInt128& iValue ); 
	CHSInt128&		operator&=	( const CHSInt128& iValue ); 
	CHSInt128&		operator|=	( const CHSInt128& iValue ); 
 
	CHSInt128		operator< 	( const UINT nShift ); 
	CHSInt128&		operator<= ( const UINT nShift ); 
	CHSInt128		operator>>  ( const UINT nShift ); 
	CHSInt128&		operator>>= ( const UINT nShift ); 
 
	bool			operator==	( const CHSInt128& iValue ) const; 
	bool			operator!=	( const CHSInt128& iValue ) const; 
	bool			operator>	( const CHSInt128& iValue ) const; 
	bool			operator<	( const CHSInt128& iValue ) const; 
	bool			operator>=	( const CHSInt128& iValue ) const; 
	bool			operator=	( const CHSInt128& iValue ) const; 
/* 
	operator	int(); 
	operator	unsigned int(); 
	operator	long(); 
	operator	unsigned long(); 
	operator	__int64(); 
	operator	unsigned __int64(); 
*/ 
 
	void			SetPositiveFlag	 ( void ); 
	void			SetNegativeFlag	 ( void ); 
	void			Complement		 ( void ); 
	void			ComplementInverse( void ); 
	void			Min				 ( void ); 
	void			Max				 ( void ); 
	void			Zero			 ( void ); 
	void			SetAt			 ( UINT uIndex, bool bSet ); 
 
	bool			IsZero			 ( void ) const; 
	bool			IsNegative		 ( void ) const; 
	bool			IsPositive		 ( void ) const; 
	bool			GetAt			 ( UINT uIndex ) const; 
	CHSInt128		GetRight		 ( UINT uCount ) const; 
	CHSInt128		GetLeft			 ( UINT uCount ) const; 
 
	void		Division			 ( const CHSInt128& iDivisor, CHSInt128& iQuotient, CHSInt128& iRemainder) const; 
 
}; 
 
#endif // !defined(AFX_INT100_H__44379E2E_9CCE_11D6_879C_D4EFB1FC566C__INCLUDED_)

 

 

  1. // int128.cpp: implementation of the CHSInt128 class.   
  2. //    
  3. //   
  4.    
  5. #include "stdafx.h"    
  6. #include "int128.h"    
  7. #include "alu.h"    
  8.    
  9. #ifdef _DEBUG    
  10. #undef THIS_FILE    
  11. static char THIS_FILE[]=__FILE__;   
  12. #define new DEBUG_NEW    
  13. #endif    
  14.    
  15.    
  16.    
  17. //$//                                                                             
  18. //$//                              作者 : 韩 松                                    
  19. //$//                                                                             
  20. //$//       程序名称　：CHSInt128               
  21. //$//       程序类型　：菜单类           
  22. //$//                     发布日期  ：02/10/01    
  23. //$//       邮箱地址　：hs_china@yahoo.com    
  24. //$//                       
  25. //$//       作者声明　：此部分代码全是作者所写，可以随便传播，但要保持   
  26. //$//                  文件的完整性,如果您有问题或有好的建议、意见请您   
  27. //$//                  给我来信,非常感谢!              
  28. //$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　    
  29. //$//                               
  30.    
  31.    
  32.    
  33. //   
  34. // Construction/Destruction    
  35. //   
  36.    
  37. // Default    
  38. CHSInt128::CHSInt128()   
  39. {   
  40.     m_A = m_B = m_C = m_D = 0;   
  41. }   
  42.    
  43. CHSInt128::~CHSInt128()   
  44. {   
  45.    
  46. }   
  47.    
  48. // unsigned int    
  49. CHSInt128::CHSInt128(const UINT uValue)   
  50. {      
  51.     *this = CHSInt128( (DWORD)uValue );   
  52. }   
  53.    
  54. // int    
  55. CHSInt128::CHSInt128(const int nValue)   
  56. {   
  57.     if ( nValue  0 )   
  58.     {   
  59.         *this = CHSInt128( DWORD( -nValue ) );   
  60.         Complement();   
  61.     }   
  62.     else   
  63.     {   
  64.         *this = CHSInt128( (DWORD)nValue );   
  65.     }   
  66. }   
  67.    
  68. // unsigned long    
  69. CHSInt128::CHSInt128(const DWORD dwValue)   
  70. {   
  71.     m_D = m_B = m_C = 0;       
  72.    
  73.     m_A = dwValue;   
  74. }   
  75.    
  76. // long    
  77. CHSInt128::CHSInt128(const long lValue)   
  78. {   
  79.     if ( lValue  0 )   
  80.     {   
  81.         *this = CHSInt128( (DWORD)( -lValue ) );   
  82.         Complement();   
  83.     }   
  84.     else   
  85.     {   
  86.         *this = CHSInt128( (DWORD)lValue );   
  87.     }   
  88. }   
  89.    
  90. // unsigned __int64    
  91. CHSInt128::CHSInt128(const UINT64 &nnValue)   
  92. {   
  93.     m_D = m_C = 0;   
  94.    
  95.     m_B = HI32( nnValue );   
  96.     m_A = LO32( nnValue );     
  97. }          
  98.                                                    
  99. // __int64    
  100. CHSInt128::CHSInt128(const __int64 &nnValue)   
  101. {   
  102.     if ( nnValue  0 )   
  103.     {   
  104.         *this = CHSInt128( (UINT64)(-nnValue) );   
  105.         Complement();   
  106.     }   
  107.     else   
  108.     {   
  109.         *this = CHSInt128( (UINT64)nnValue );   
  110.     }   
  111. }   
  112.    
  113. // CHSInt128    
  114. CHSInt128::CHSInt128(const CHSInt128 &iValue)   
  115. {   
  116.     m_A = iValue.m_A;   
  117.     m_B = iValue.m_B;   
  118.     m_C = iValue.m_C;   
  119.     m_D = iValue.m_D;   
  120. }   
  121.    
  122. // Operator =    
  123. CHSInt128& CHSInt128::operator =(const CHSInt128& iValue)   
  124. {   
  125.     m_A = iValue.m_A;   
  126.     m_B = iValue.m_B;   
  127.     m_C = iValue.m_C;   
  128.     m_D = iValue.m_D;   
  129.    
  130.     return *this;   
  131. }   
  132.    
  133. // Operator +    
  134. CHSInt128 CHSInt128::operator +(const CHSInt128 &iValue)   
  135. {   
  136.     CHSInt128  iTemp;   
  137.    
  138.     ADD( iTemp.m_A, m_A, iValue.m_A );   
  139.     ADC( iTemp.m_B, m_B, iValue.m_B );   
  140.     ADC( iTemp.m_C, m_C, iValue.m_C );   
  141.     ADC( iTemp.m_D, m_D, iValue.m_D );   
  142.    
  143.     return iTemp;   
  144. }   
  145.    
  146. // Operator ++n    
  147. CHSInt128& CHSInt128::operator ++()   
  148. {   
  149.     *this = *this + CHSInt128( 1 );   
  150.    
  151.     return  *this;   
  152. }   
  153.    
  154. // Operator n++    
  155. CHSInt128 CHSInt128::operator ++( int )   
  156. {   
  157.     CHSInt128    iTemp( *this );   
  158.    
  159.     *this = *this + CHSInt128( 1 );   
  160.    
  161.     return  iTemp;   
  162. }   
  163.    
  164. // Operator +=    
  165. CHSInt128& CHSInt128::operator +=(const CHSInt128 &iValue)   
  166. {   
  167.     *this = *this + iValue;   
  168.    
  169.     return *this;   
  170. }   
  171.    
  172. // Operator -    
  173. CHSInt128 CHSInt128::operator -(const CHSInt128 &iValue)   
  174. {   
  175.     CHSInt128   iTemp;   
  176.    
  177.     SUB( iTemp.m_A, m_A, iValue.m_A );   
  178.     SBB( iTemp.m_B, m_B, iValue.m_B );   
  179.     SBB( iTemp.m_C, m_C, iValue.m_B );   
  180.     SBB( iTemp.m_D, m_D, iValue.m_B );   
  181.    
  182.     return iTemp;   
  183. }   
  184.    
  185. // Operator --n    
  186. CHSInt128& CHSInt128::operator --()   
  187. {   
  188.     *this = *this - CHSInt128( 1 );   
  189.    
  190.     return *this;   
  191. }   
  192.    
  193. // Operator n--    
  194. CHSInt128 CHSInt128::operator --( int )   
  195. {   
  196.     CHSInt128    iTemp( *this );   
  197.    
  198.     *this = *this - CHSInt128( 1 );   
  199.    
  200.     return  iTemp;   
  201. }   
  202.    
  203. // Operator -=    
  204. CHSInt128& CHSInt128::operator -=(const CHSInt128 &iValue)   
  205. {   
  206.     *this = *this - iValue;   
  207.    
  208.     return *this;   
  209. }   
  210.    
  211. // Operator &    
  212. CHSInt128 CHSInt128::operator &(const CHSInt128 &iValue) const   
  213. {   
  214.     CHSInt128    iTemp;   
  215.    
  216.     iTemp.m_A  = m_A & iValue.m_A;   
  217.     iTemp.m_B  = m_B & iValue.m_B;   
  218.     iTemp.m_C  = m_C & iValue.m_C;   
  219.     iTemp.m_D  = m_D & iValue.m_D;   
  220.    
  221.     return iTemp;   
  222. }   
  223.    
  224. // Operator &=    
  225. CHSInt128& CHSInt128::operator &=(const CHSInt128 &iValue)   
  226. {   
  227.     *this = *this & iValue;   
  228.        
  229.     return *this;   
  230. }   
  231.    
  232. // Operator |    
  233. CHSInt128 CHSInt128::operator |(const CHSInt128 &iValue) const   
  234. {   
  235.     CHSInt128    iTemp;   
  236.    
  237.     iTemp.m_A  = m_A | iValue.m_A;   
  238.     iTemp.m_B  = m_B | iValue.m_B;   
  239.     iTemp.m_C  = m_C | iValue.m_C;   
  240.     iTemp.m_D  = m_D | iValue.m_D;   
  241.    
  242.     return iTemp;   
  243. }   
  244.    
  245. // Operator |=    
  246. CHSInt128& CHSInt128::operator |=(const CHSInt128 &iValue)   
  247. {   
  248.     *this = *this | iValue;   
  249.    
  250.     return *this;   
  251. }   
  252.    
  253. // Operator ^    
  254. CHSInt128 CHSInt128::operator ^(const CHSInt128 &iValue) const   
  255. {   
  256.     CHSInt128    iTemp;   
  257.    
  258.     iTemp.m_A  = m_A ^ iValue.m_A;   
  259.     iTemp.m_B  = m_B ^ iValue.m_B;   
  260.     iTemp.m_C  = m_C ^ iValue.m_C;   
  261.     iTemp.m_D  = m_D ^ iValue.m_D;   
  262.    
  263.     return iTemp;   
  264. }   
  265.    
  266. // Operator ^=    
  267. CHSInt128& CHSInt128::operator ^=(const CHSInt128 &iValue)   
  268. {   
  269.     *this = *this ^ iValue;   
  270.    
  271.     return *this;   
  272. }   
  273.    
  274. // Operator ~    
  275. CHSInt128 CHSInt128::operator ~() const   
  276. {   
  277.     CHSInt128    iTemp;   
  278.    
  279.     iTemp.m_A  = ~m_A;   
  280.     iTemp.m_B  = ~m_B;   
  281.     iTemp.m_C  = ~m_C;   
  282.     iTemp.m_D  = ~m_D;   
  283.    
  284.     return iTemp;   
  285. }   
  286.    
  287. // Operator <    
  288. CHSInt128 CHSInt128::operator <<( const UINT uShift)   
  289. {   
  290.     CHSInt128   iTemp( *this );   
  291.    
  292.     UINT    uShiftN = ( uShift / 32 );   
  293.     UINT    uShiftL = ( uShift % 32 );   
  294.    
  295.     for ( UINT iN=0; iN<uShiftN; iN++ )   
  296.     {   
  297.         SHL( iTemp.m_D, 32 );   
  298.         SHL( iTemp.m_D, iTemp.m_C, 32 );   
  299.         SHL( iTemp.m_C, iTemp.m_B, 32 );   
  300.         SHL( iTemp.m_B, iTemp.m_A, 32 );   
  301.     }   
  302.    
  303.     if ( uShiftL > 0 )   
  304.     {   
  305.         SHL( iTemp.m_D, uShiftL );   
  306.         SHL( iTemp.m_D, iTemp.m_C, uShiftL );   
  307.         SHL( iTemp.m_C, iTemp.m_B, uShiftL );   
  308.         SHL( iTemp.m_B, iTemp.m_A, uShiftL );   
  309.     }          
  310.    
  311.     return iTemp;   
  312. }   
  313.    
  314. // Operator <=    
  315. CHSInt128& CHSInt128::operator <=( const UINT uShift )   
  316. {   
  317.     *this = ( *this < uShift );   
  318.    
  319.     return *this;   
  320. }   
  321.    
  322. // Operator >>     
  323. CHSInt128 CHSInt128::operator >>(const UINT uShift)   
  324. {   
  325.     CHSInt128    iTemp( *this );   
  326.    
  327.     UINT    uShiftN = ( uShift / 32 );   
  328.     UINT    uShiftL = ( uShift % 32 );   
  329.    
  330.     for ( UINT iN=0; iN<uShiftN; iN++ )   
  331.     {   
  332.         SHR( iTemp.m_A, 32 );   
  333.         SHR( iTemp.m_B, iTemp.m_A, 32 );   
  334.         SHR( iTemp.m_C, iTemp.m_B, 32 );   
  335.         SHR( iTemp.m_D, iTemp.m_C, 32 );   
  336.     }   
  337.    
  338.     if ( uShiftL > 0 )   
  339.     {   
  340.         SHR( iTemp.m_A, uShiftL );   
  341.         SHR( iTemp.m_B, iTemp.m_A, uShiftL );   
  342.         SHR( iTemp.m_C, iTemp.m_B, uShiftL );   
  343.         SHR( iTemp.m_D, iTemp.m_C, uShiftL );   
  344.     }   
  345.    
  346.     return iTemp;   
  347. }   
  348.    
  349. // Operator >>=    
  350. CHSInt128& CHSInt128::operator >>=(const UINT uShift)   
  351. {   
  352.     *this = ( *this >> uShift );   
  353.    
  354.     return *this;   
  355. }   
  356.    
  357. // Operator ==    
  358. bool CHSInt128::operator ==(const CHSInt128 &iValue) const   
  359. {   
  360.     return ( ( m_A == iValue.m_A ) &&   
  361.              ( m_B == iValue.m_B ) &&   
  362.              ( m_C == iValue.m_C ) &&   
  363.              ( m_D == iValue.m_D )    
  364.             );   
  365. }   
  366.    
  367. // Operator !=    
  368. bool CHSInt128::operator !=(const CHSInt128 &iValue) const   
  369. {   
  370.     return ( ( m_A != iValue.m_A ) ||   
  371.              ( m_B != iValue.m_B ) ||   
  372.              ( m_C != iValue.m_C ) ||   
  373.              ( m_D != iValue.m_D )    
  374.             );   
  375. }   
  376.    
  377. // Operator >    
  378. bool CHSInt128::operator >(const CHSInt128& iValue ) const   
  379. {   
  380.     if ( m_D > iValue.m_D ) return true;   
  381.     if ( m_D  iValue.m_D ) return false;   
  382.    
  383.     if ( m_C > iValue.m_C )  return true;   
  384.     if ( m_C  iValue.m_C ) return false;   
  385.    
  386.     if ( m_B > iValue.m_B )  return true;   
  387.     if ( m_B  iValue.m_B )  return false;   
  388.    
  389.     if ( m_A > iValue.m_A )  return true;   
  390.     if ( m_A  iValue.m_A )  return false;   
  391.    
  392.     return false;   
  393. }   
  394.    
  395. // Operator >=    
  396. bool CHSInt128::operator >=(const CHSInt128& iValue ) const   
  397. {   
  398.     return ( ( *this > iValue )  || ( *this == iValue ) );   
  399. }   
  400.    
  401. // Operator     
  402. bool CHSInt128::operator <(const CHSInt128& iValue ) const   
  403. {   
  404.     if ( m_D  iValue.m_D ) return true;   
  405.     if ( m_D > iValue.m_D ) return false;   
  406.    
  407.     if ( m_C  iValue.m_C )  return true;   
  408.     if ( m_C > iValue.m_C ) return false;   
  409.    
  410.     if ( m_B  iValue.m_B )  return true;   
  411.     if ( m_B > iValue.m_B )  return false;   
  412.    
  413.     if ( m_A  iValue.m_A )  return true;   
  414.     if ( m_A > iValue.m_A )  return false;   
  415.    
  416.     return false;   
  417. }   
  418.    
  419. // Operator =    
  420. bool CHSInt128::operator =(const CHSInt128& iValue ) const   
  421. {   
  422.     return ( ( *this  iValue )  || ( *this == iValue ) );   
  423. }   
  424.    
  425. // Operator *    
  426. CHSInt128 CHSInt128::operator *(const CHSInt128 &iValue) const   
  427. {   
  428.     CHSInt128   iResult;   
  429.    
  430.     CHSInt128 iT1( ((UINT64)m_A)*((UINT64)iValue.m_A) );   
  431.     CHSInt128 iT2( ((UINT64)m_B)*((UINT64)iValue.m_A) );   
  432.     CHSInt128 iT3( ((UINT64)m_C)*((UINT64)iValue.m_A) );   
  433.     CHSInt128 iT4( ((UINT64)m_D)*((UINT64)iValue.m_A) );   
  434.        
  435.     iResult += iT1;    
  436.     iResult += ( iT2 < 32 );   
  437.     iResult += ( iT3 < 64 );   
  438.     iResult += ( iT4 < 96 );   
  439.    
  440.     CHSInt128 iT5( ((UINT64)m_A)*((UINT64)iValue.m_B) );   
  441.     CHSInt128 iT6( ((UINT64)m_B)*((UINT64)iValue.m_B) );   
  442.     CHSInt128 iT7( ((UINT64)m_C)*((UINT64)iValue.m_B) );   
  443.        
  444.     iResult += ( iT5 < 32 );   
  445.     iResult += ( iT6 < 64 );   
  446.     iResult += ( iT7 < 96 );   
  447.    
  448.     CHSInt128 iT8( ((UINT64)m_A)*((UINT64)iValue.m_C) );   
  449.     CHSInt128 iT9( ((UINT64)m_B)*((UINT64)iValue.m_C) );   
  450.        
  451.     iResult += ( iT8 < 64 );   
  452.     iResult += ( iT9 < 96 );   
  453.    
  454.     CHSInt128 iT0( ((UINT64)m_A)*((UINT64)iValue.m_D) );   
  455.        
  456.     iResult += ( iT0 < 96 );   
  457.    
  458.     return iResult;   
  459. }   
  460.    
  461. // Operator *=    
  462. CHSInt128& CHSInt128::operator *=(const CHSInt128 &iValue)   
  463. {   
  464.     *this = *this * iValue;   
  465.    
  466.     return *this;   
  467. }   
  468.    
  469. // Operator /    
  470. CHSInt128 CHSInt128::operator /(const CHSInt128 &iValue) const   
  471. {   
  472.     CHSInt128 iQuotient;   
  473.     CHSInt128 iRemainder;   
  474.    
  475.     Division( iValue, iQuotient,iRemainder );      
  476.    
  477.     return iQuotient;   
  478. }   
  479.    
  480. // Operator /=    
  481. CHSInt128& CHSInt128::operator /=(const CHSInt128 &iValue)   
  482. {   
  483.     *this = *this / iValue;   
  484.    
  485.     return *this;   
  486. }   
  487.    
  488. // Operator %    
  489. CHSInt128 CHSInt128::operator %(const CHSInt128 &iValue) const   
  490. {   
  491.     CHSInt128 iQuotient;   
  492.     CHSInt128 iRemainder;   
  493.    
  494.     Division( iValue, iQuotient, iRemainder );   
  495.    
  496.     return iRemainder;   
  497. }   
  498.    
  499. // Operator %=    
  500. CHSInt128& CHSInt128::operator %=(const CHSInt128 &iValue)   
  501. {   
  502.     *this = *this % iValue;   
  503.        
  504.     return *this;   
  505. }   
  506.    
  507. // Complement    
  508. void CHSInt128::Complement( void )   
  509. {   
  510.     NOT( m_A  );   
  511.     NOT( m_B );   
  512.     NOT( m_C );   
  513.     NOT( m_D  );   
  514.    
  515.     *this = *this + CHSInt128( 1 );;   
  516. }   
  517.    
  518. // Inverse Complement    
  519. void CHSInt128::ComplementInverse( void )   
  520. {   
  521.     *this = *this - CHSInt128( 1 );;   
  522.    
  523.     NOT( m_A  );   
  524.     NOT( m_B );   
  525.     NOT( m_C );   
  526.     NOT( m_D  );   
  527. }   
  528.    
  529. // If Value is Positive return true    
  530. bool CHSInt128::IsPositive( void ) const   
  531. {   
  532.     return ( ( m_D & 0X80000000 ) == 0X00000000 );   
  533. }   
  534.    
  535. // Return true, If its Negative    
  536. bool CHSInt128::IsNegative( void ) const   
  537. {   
  538.     return ( ( m_D & 0X80000000 ) == 0X80000000 );   
  539. }   
  540.    
  541. // Set Negative Flag    
  542. void CHSInt128::SetNegativeFlag( void )   
  543. {   
  544.     OR ( m_D, 0X80000000 );    
  545. }   
  546.    
  547. // Set Positive Flag    
  548. void CHSInt128::SetPositiveFlag( void )   
  549. {   
  550.     AND( m_D, 0X7FFFFFFF );   
  551. }   
  552.    
  553. // Division    
  554. void CHSInt128::Division(const CHSInt128 &iDivisor, CHSInt128 &iQuotient, CHSInt128 &iRemainder) const   
  555. {   
  556.     if ( iDivisor == CHSInt128( 0 ) )   
  557.     {   
  558.         __asm   
  559.         {   
  560.             mov eax, 0   
  561.             div eax   
  562.         }   
  563.     }   
  564.    
  565.     iQuotient.Zero();   
  566.     iRemainder.Zero();   
  567.    
  568.     // 原码加减交替法计算 X/Y    
  569.     CHSInt128 iTempR0;                  // R0 : Remainder   
  570.     CHSInt128 iTempR1 ( *this );            // R1 : Quotient   
  571.     CHSInt128 iTempR2 ( iDivisor );     // R2 : Divisor   
  572.    
  573.     // if Dividend is Zero, No Need Calc    
  574.     if ( iTempR1.IsZero() ) return;   
  575.    
  576.     bool    bDivrNegative = false, bDivdNegative = false;   
  577.    
  578.     // 将补码转换为原码    
  579.     if ( iTempR1.IsNegative() )   
  580.     {   
  581.         iTempR1.ComplementInverse();   
  582.         bDivdNegative = true;   
  583.     }   
  584.     else iTempR1.SetAt( 127, 0 );   
  585.    
  586.     // 将补码转换为原码    
  587.     if ( iDivisor.IsNegative() )   
  588.     {   
  589.         iTempR2.ComplementInverse();   
  590.         bDivrNegative = true;   
  591.     }   
  592.     else iTempR2.SetAt( 127, 0 );   
  593.    
  594.     iTempR0 -= iTempR2;   
  595.    
  596.     for ( UINT iN = 0; iN  128; iN++ )   
  597.     {   
  598.         iTempR0 <= 1;   
  599.    
  600.         // Move iTempR1(High Bit) to iTempR0(Low Bit)   
  601.         if ( iTempR1.GetAt( 127 ) )    
  602.              iTempR0.SetAt( 0, 1 );   
  603.    
  604.         iTempR1 <= 1;   
  605.    
  606.         if ( iTempR0.GetAt( 127 ) )   
  607.         {   
  608.             iTempR0 += iTempR2;   
  609.         }   
  610.         else   
  611.         {   
  612.             iTempR1.SetAt( 0, 1 );   
  613.             iTempR0 -= iTempR2;   
  614.         }   
  615.     }              
  616.    
  617.     iTempR1 <= 1;   
  618.    
  619.     if ( !iTempR0.GetAt( 127 ) )   
  620.     {   
  621.         iTempR1.SetAt( 0, 1 );   
  622.     }   
  623.     else iTempR0 += iTempR2;   
  624.    
  625.     if ( bDivrNegative ^ bDivdNegative )   
  626.     {   
  627.         iTempR1.Complement();   
  628.     }   
  629.    
  630.     iQuotient  = iTempR1;   
  631.     iRemainder = iTempR0;   
  632. }   
  633.    
  634. // Set or Clear one bit where you want    
  635. void CHSInt128::SetAt(UINT uIndex, bool bSet)   
  636. {   
  637.     DWORD   dwBitAt = ( 0X00000001 < (uIndex % 32 ) );   
  638.    
  639.     if ( bSet )   
  640.     {   
  641.         if ( uIndex  32 )   
  642.             m_A |= dwBitAt;   
  643.         else   
  644.         if ( uIndex  64 )   
  645.             m_B |= dwBitAt;   
  646.         else   
  647.         if ( uIndex  96 )   
  648.             m_C |= dwBitAt;   
  649.         else   
  650.             m_D |= dwBitAt;   
  651.     }   
  652.     else   
  653.     {   
  654.         if ( uIndex  32 )   
  655.             m_A &= ~dwBitAt;   
  656.         else   
  657.         if ( uIndex  64 )   
  658.             m_B &= ~dwBitAt;   
  659.         else   
  660.         if ( uIndex  96 )   
  661.             m_C &= ~dwBitAt;   
  662.         else   
  663.             m_D &= ~dwBitAt;   
  664.     }   
  665. }   
  666.    
  667. // Get Bit At ...    
  668. bool CHSInt128::GetAt(UINT uIndex) const   
  669. {   
  670.     DWORD   dwBitAt = ( 0X00000001 < (uIndex % 32 ) );   
  671.    
  672.     if ( uIndex  32 )   return ( ( m_A & dwBitAt ) != 0 );   
  673.     else   
  674.     if ( uIndex  64 )   return ( ( m_B & dwBitAt ) != 0 );   
  675.     else   
  676.     if ( uIndex  96 )   return ( ( m_C & dwBitAt ) != 0 );   
  677.     else   
  678.                         return ( ( m_D & dwBitAt ) != 0 );   
  679. }   
  680.    
  681. // Is Me Zero ?    
  682. bool CHSInt128::IsZero() const   
  683. {   
  684.     return ( m_D == 0 &&   
  685.              m_C == 0 &&   
  686.              m_B == 0 &&   
  687.              m_A == 0    
  688.             );   
  689. }   
  690.    
  691. // Set Me Zero    
  692. void CHSInt128::Zero()   
  693. {   
  694.     m_A = m_B = m_C = m_D = 0;   
  695. }   
  696.    
  697. // Get CHSInt128 Left    
  698. CHSInt128 CHSInt128::GetLeft(UINT uCount) const   
  699. {   
  700.     CHSInt128 iTemp( *this );   
  701.    
  702.     iTemp >>= ( 128 - uCount );   
  703.    
  704.     return iTemp;   
  705. }   
  706.    
  707. // Get Right uCount bit    
  708. CHSInt128 CHSInt128::GetRight(UINT uCount) const   
  709. {   
  710.     CHSInt128 iTemp( *this );   
  711.    
  712.     iTemp <= ( 128 - uCount );   
  713.     iTemp >>= ( 128 - uCount );   
  714.    
  715.     return iTemp;   
  716. }   
  717.    
  718. // Set Me Max    
  719. void CHSInt128::Max()   
  720. {   
  721.     m_D = 0X7FFFFFFF;   
  722.    
  723.     m_C = m_B = m_A = 0XFFFFFFFF;   
  724. }   
  725.    
  726. // Set Me Min    
  727. void CHSInt128::Min()   
  728. {   
  729.     m_D = 0X80000000;   
  730.    
  731.     m_C = m_B = m_A = 0X00000000;      
  732. }   
  733.    
  734.    
  735. // Change From String Integer to CHSInt128   
  736. bool CHSInt128::FromStr(LPCTSTR lpszValue)   
  737. {   
  738.     CHSInt128   iTemp;   
  739.     CString strSrc = lpszValue;   
  740.     int     nLength, nIndex = 0;   
  741.     bool    bNegative = false;   
  742.     char    cSrc;   
  743.            
  744.     strSrc.TrimLeft();   
  745.     strSrc.TrimRight();   
  746.    
  747.     if ( strSrc[0] == '-' )   
  748.     {   
  749.         bNegative = true;   
  750.         nIndex = 1;   
  751.     }   
  752.    
  753.     if ( ( nLength = strSrc.GetLength() ) > 40 )    
  754.         nLength = 40;   
  755.        
  756.     while ( nIndex  nLength )   
  757.     {   
  758.         cSrc = strSrc[nIndex];   
  759.    
  760.         if (  cSrc  _T('0') || cSrc > _T('9') )  return false;   
  761.    
  762.         iTemp *= 10;   
  763.         iTemp += CHSInt128( (int)( cSrc - _T('0') ) );   
  764.    
  765.         nIndex++;   
  766.     }   
  767.    
  768.     *this = iTemp;   
  769.    
  770.     if ( bNegative )    Complement();   
  771.    
  772.     return true;   
  773. }   
  774.    
  775. // Translate from CHSInt128 to CString    
  776. bool CHSInt128::ToStr(CString &strValue)   
  777. {   
  778.     CHSInt128   iTemp( *this );   
  779.     char    cTarget;   
  780.    
  781.     strValue = _T("");   
  782.    
  783.     do   
  784.     {   
  785.         cTarget = ( (char)((int)( ( iTemp % 10 ).m_A )) + _T('0') );   
  786.    
  787.         strValue += cTarget;   
  788.    
  789.         iTemp /= 10;   
  790.    
  791.     } while( !iTemp.IsZero() );   
  792.    
  793.     strValue += ' ';   
  794.     strValue.MakeReverse();   
  795.    
  796.     if ( IsNegative() )        
  797.          strValue.SetAt( 0, '-' );   
  798.    
  799.     return true;   
  800. }   
  801. /*  
  802. CHSInt128::operator int()  
  803. {  
  804.     return ( (int)m_A );  
  805. }  
  806.   
  807. CHSInt128::operator unsigned int()  
  808. {  
  809.     return ( (unsigned int)m_A );  
  810. }  
  811.   
  812. CHSInt128::operator long()  
  813. {  
  814.     return ( (long)m_A );  
  815. }  
  816.   
  817. CHSInt128::operator unsigned long()  
  818. {  
  819.     return ( (unsigned long)m_A );  
  820. }  
  821.   
  822. CHSInt128::operator __int64()  
  823. {  
  824.     return ( ( ((__int64)(m_B))<<32 ) + (__int64)m_A );  
  825. }  
  826.   
  827. CHSInt128::operator unsigned __int64()  
  828. {  
  829.     return ( ( ((unsigned __int64)(m_B))<<32 ) + (unsigned __int64)m_A );  
  830. }  
  831. */  
// int128.cpp: implementation of the CHSInt128 class. 
// 
// 
 
#include "stdafx.h" 
#include "int128.h" 
#include "alu.h" 
 
#ifdef _DEBUG 
#undef THIS_FILE 
static char THIS_FILE[]=__FILE__; 
#define new DEBUG_NEW 
#endif 
 
 
 
//$//                                                                           
//$//			         	       作者 : 韩 松                                  
//$//                                                                           
//$//		程序名称　：CHSInt128            
//$//		程序类型　：菜单类		 
//$//                     发布日期  ：02/10/01  
//$//		邮箱地址　：hs_china@yahoo.com 
//$//					 
//$//		作者声明　：此部分代码全是作者所写，可以随便传播，但要保持 
//$//				   文件的完整性,如果您有问题或有好的建议、意见请您 
//$//			       给我来信,非常感谢!			 
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 
//$//							 
 
 
 
// 
// Construction/Destruction 
// 
 
// Default 
CHSInt128::CHSInt128() 
{ 
	m_A = m_B = m_C = m_D = 0; 
} 
 
CHSInt128::~CHSInt128() 
{ 
 
} 
 
// unsigned int 
CHSInt128::CHSInt128(const UINT uValue) 
{	 
	*this = CHSInt128( (DWORD)uValue ); 
} 
 
// int 
CHSInt128::CHSInt128(const int nValue) 
{ 
	if ( nValue  0 ) 
	{ 
		*this = CHSInt128( DWORD( -nValue ) ); 
		Complement(); 
	} 
	else 
	{ 
		*this = CHSInt128( (DWORD)nValue ); 
	} 
} 
 
// unsigned long 
CHSInt128::CHSInt128(const DWORD dwValue) 
{ 
	m_D = m_B = m_C = 0;	 
 
	m_A = dwValue; 
} 
 
// long 
CHSInt128::CHSInt128(const long lValue) 
{ 
	if ( lValue  0 ) 
	{ 
		*this = CHSInt128( (DWORD)( -lValue ) ); 
		Complement(); 
	} 
	else 
	{ 
		*this = CHSInt128( (DWORD)lValue ); 
	} 
} 
 
// unsigned __int64 
CHSInt128::CHSInt128(const UINT64 &nnValue) 
{ 
	m_D = m_C = 0; 
 
	m_B = HI32( nnValue ); 
	m_A = LO32( nnValue );	 
}		 
												 
// __int64 
CHSInt128::CHSInt128(const __int64 &nnValue) 
{ 
	if ( nnValue  0 ) 
	{ 
		*this = CHSInt128( (UINT64)(-nnValue) ); 
		Complement(); 
	} 
	else 
	{ 
		*this = CHSInt128( (UINT64)nnValue ); 
	} 
} 
 
// CHSInt128 
CHSInt128::CHSInt128(const CHSInt128 &iValue) 
{ 
	m_A = iValue.m_A; 
	m_B = iValue.m_B; 
	m_C = iValue.m_C; 
	m_D = iValue.m_D; 
} 
 
// Operator = 
CHSInt128& CHSInt128::operator =(const CHSInt128& iValue) 
{ 
	m_A = iValue.m_A; 
	m_B = iValue.m_B; 
	m_C = iValue.m_C; 
	m_D = iValue.m_D; 
 
	return *this; 
} 
 
// Operator + 
CHSInt128 CHSInt128::operator +(const CHSInt128 &iValue) 
{ 
	CHSInt128  iTemp; 
 
	ADD( iTemp.m_A, m_A, iValue.m_A ); 
	ADC( iTemp.m_B, m_B, iValue.m_B ); 
	ADC( iTemp.m_C, m_C, iValue.m_C ); 
	ADC( iTemp.m_D, m_D, iValue.m_D ); 
 
	return iTemp; 
} 
 
// Operator ++n 
CHSInt128& CHSInt128::operator ++() 
{ 
	*this = *this + CHSInt128( 1 ); 
 
	return  *this; 
} 
 
// Operator n++ 
CHSInt128 CHSInt128::operator ++( int ) 
{ 
	CHSInt128	 iTemp( *this ); 
 
	*this = *this + CHSInt128( 1 ); 
 
	return  iTemp; 
} 
 
// Operator += 
CHSInt128& CHSInt128::operator +=(const CHSInt128 &iValue) 
{ 
	*this = *this + iValue; 
 
	return *this; 
} 
 
// Operator - 
CHSInt128 CHSInt128::operator -(const CHSInt128 &iValue) 
{ 
	CHSInt128	iTemp; 
 
	SUB( iTemp.m_A, m_A, iValue.m_A ); 
	SBB( iTemp.m_B, m_B, iValue.m_B ); 
	SBB( iTemp.m_C, m_C, iValue.m_B ); 
	SBB( iTemp.m_D, m_D, iValue.m_B ); 
 
	return iTemp; 
} 
 
// Operator --n 
CHSInt128& CHSInt128::operator --() 
{ 
	*this = *this - CHSInt128( 1 ); 
 
	return *this; 
} 
 
// Operator n-- 
CHSInt128 CHSInt128::operator --( int ) 
{ 
	CHSInt128	 iTemp( *this ); 
 
	*this = *this - CHSInt128( 1 ); 
 
	return  iTemp; 
} 
 
// Operator -= 
CHSInt128& CHSInt128::operator -=(const CHSInt128 &iValue) 
{ 
	*this = *this - iValue; 
 
	return *this; 
} 
 
// Operator & 
CHSInt128 CHSInt128::operator &(const CHSInt128 &iValue) const 
{ 
	CHSInt128	 iTemp; 
 
	iTemp.m_A  = m_A & iValue.m_A; 
	iTemp.m_B  = m_B & iValue.m_B; 
	iTemp.m_C  = m_C & iValue.m_C; 
	iTemp.m_D  = m_D & iValue.m_D; 
 
	return iTemp; 
} 
 
// Operator &= 
CHSInt128& CHSInt128::operator &=(const CHSInt128 &iValue) 
{ 
	*this = *this & iValue; 
	 
	return *this; 
} 
 
// Operator | 
CHSInt128 CHSInt128::operator |(const CHSInt128 &iValue) const 
{ 
	CHSInt128	 iTemp; 
 
	iTemp.m_A  = m_A | iValue.m_A; 
	iTemp.m_B  = m_B | iValue.m_B; 
	iTemp.m_C  = m_C | iValue.m_C; 
	iTemp.m_D  = m_D | iValue.m_D; 
 
	return iTemp; 
} 
 
// Operator |= 
CHSInt128& CHSInt128::operator |=(const CHSInt128 &iValue) 
{ 
	*this = *this | iValue; 
 
	return *this; 
} 
 
// Operator ^ 
CHSInt128 CHSInt128::operator ^(const CHSInt128 &iValue) const 
{ 
	CHSInt128	 iTemp; 
 
	iTemp.m_A  = m_A ^ iValue.m_A; 
	iTemp.m_B  = m_B ^ iValue.m_B; 
	iTemp.m_C  = m_C ^ iValue.m_C; 
	iTemp.m_D  = m_D ^ iValue.m_D; 
 
	return iTemp; 
} 
 
// Operator ^= 
CHSInt128& CHSInt128::operator ^=(const CHSInt128 &iValue) 
{ 
	*this = *this ^ iValue; 
 
	return *this; 
} 
 
// Operator ~ 
CHSInt128 CHSInt128::operator ~() const 
{ 
	CHSInt128	 iTemp; 
 
	iTemp.m_A  = ~m_A; 
	iTemp.m_B  = ~m_B; 
	iTemp.m_C  = ~m_C; 
	iTemp.m_D  = ~m_D; 
 
	return iTemp; 
} 
 
// Operator < 
CHSInt128 CHSInt128::operator <<( const UINT uShift) 
{ 
	CHSInt128	iTemp( *this ); 
 
	UINT	uShiftN = ( uShift / 32 ); 
	UINT	uShiftL = ( uShift % 32 ); 
 
	for ( UINT iN=0; iN<uShiftN; iN++ ) 
	{ 
		SHL( iTemp.m_D, 32 ); 
		SHL( iTemp.m_D, iTemp.m_C, 32 ); 
		SHL( iTemp.m_C, iTemp.m_B, 32 ); 
		SHL( iTemp.m_B, iTemp.m_A, 32 ); 
	} 
 
	if ( uShiftL > 0 ) 
	{ 
		SHL( iTemp.m_D, uShiftL ); 
		SHL( iTemp.m_D, iTemp.m_C, uShiftL ); 
		SHL( iTemp.m_C, iTemp.m_B, uShiftL ); 
		SHL( iTemp.m_B, iTemp.m_A, uShiftL ); 
	}		 
 
	return iTemp; 
} 
 
// Operator <= 
CHSInt128& CHSInt128::operator <=( const UINT uShift ) 
{ 
	*this = ( *this < uShift ); 
 
	return *this; 
} 
 
// Operator >>  
CHSInt128 CHSInt128::operator >>(const UINT uShift) 
{ 
	CHSInt128	 iTemp( *this ); 
 
	UINT	uShiftN = ( uShift / 32 ); 
	UINT	uShiftL = ( uShift % 32 ); 
 
	for ( UINT iN=0; iN<uShiftN; iN++ ) 
	{ 
		SHR( iTemp.m_A, 32 ); 
		SHR( iTemp.m_B, iTemp.m_A, 32 ); 
		SHR( iTemp.m_C, iTemp.m_B, 32 ); 
		SHR( iTemp.m_D, iTemp.m_C, 32 ); 
	} 
 
	if ( uShiftL > 0 ) 
	{ 
		SHR( iTemp.m_A, uShiftL ); 
		SHR( iTemp.m_B, iTemp.m_A, uShiftL ); 
		SHR( iTemp.m_C, iTemp.m_B, uShiftL ); 
		SHR( iTemp.m_D, iTemp.m_C, uShiftL ); 
	} 
 
	return iTemp; 
} 
 
// Operator >>= 
CHSInt128& CHSInt128::operator >>=(const UINT uShift) 
{ 
	*this = ( *this >> uShift ); 
 
	return *this; 
} 
 
// Operator == 
bool CHSInt128::operator ==(const CHSInt128 &iValue) const 
{ 
	return ( ( m_A == iValue.m_A ) && 
			 ( m_B == iValue.m_B ) && 
			 ( m_C == iValue.m_C ) && 
			 ( m_D == iValue.m_D )  
			); 
} 
 
// Operator != 
bool CHSInt128::operator !=(const CHSInt128 &iValue) const 
{ 
	return ( ( m_A != iValue.m_A ) || 
			 ( m_B != iValue.m_B ) || 
			 ( m_C != iValue.m_C ) || 
			 ( m_D != iValue.m_D )  
			); 
} 
 
// Operator > 
bool CHSInt128::operator >(const CHSInt128& iValue ) const 
{ 
	if ( m_D > iValue.m_D ) return true; 
	if ( m_D  iValue.m_D ) return false; 
 
	if ( m_C > iValue.m_C )	return true; 
	if ( m_C  iValue.m_C ) return false; 
 
	if ( m_B > iValue.m_B )	return true; 
	if ( m_B  iValue.m_B )	return false; 
 
	if ( m_A > iValue.m_A )	return true; 
	if ( m_A  iValue.m_A )	return false; 
 
	return false; 
} 
 
// Operator >= 
bool CHSInt128::operator >=(const CHSInt128& iValue ) const 
{ 
	return ( ( *this > iValue )	|| ( *this == iValue ) ); 
} 
 
// Operator  
bool CHSInt128::operator <(const CHSInt128& iValue ) const 
{ 
	if ( m_D  iValue.m_D ) return true; 
	if ( m_D > iValue.m_D ) return false; 
 
	if ( m_C  iValue.m_C )	return true; 
	if ( m_C > iValue.m_C ) return false; 
 
	if ( m_B  iValue.m_B )	return true; 
	if ( m_B > iValue.m_B )	return false; 
 
	if ( m_A  iValue.m_A )	return true; 
	if ( m_A > iValue.m_A )	return false; 
 
	return false; 
} 
 
// Operator = 
bool CHSInt128::operator =(const CHSInt128& iValue ) const 
{ 
	return ( ( *this  iValue )	|| ( *this == iValue ) ); 
} 
 
// Operator * 
CHSInt128 CHSInt128::operator *(const CHSInt128 &iValue) const 
{ 
	CHSInt128	iResult; 
 
	CHSInt128 iT1( ((UINT64)m_A)*((UINT64)iValue.m_A) ); 
	CHSInt128 iT2( ((UINT64)m_B)*((UINT64)iValue.m_A) ); 
	CHSInt128 iT3( ((UINT64)m_C)*((UINT64)iValue.m_A) ); 
	CHSInt128 iT4( ((UINT64)m_D)*((UINT64)iValue.m_A) ); 
	 
	iResult += iT1;	 
	iResult += ( iT2 < 32 ); 
	iResult += ( iT3 < 64 ); 
	iResult += ( iT4 < 96 ); 
 
	CHSInt128 iT5( ((UINT64)m_A)*((UINT64)iValue.m_B) ); 
	CHSInt128 iT6( ((UINT64)m_B)*((UINT64)iValue.m_B) ); 
	CHSInt128 iT7( ((UINT64)m_C)*((UINT64)iValue.m_B) ); 
	 
	iResult += ( iT5 < 32 ); 
	iResult += ( iT6 < 64 ); 
	iResult += ( iT7 < 96 ); 
 
	CHSInt128 iT8( ((UINT64)m_A)*((UINT64)iValue.m_C) ); 
	CHSInt128 iT9( ((UINT64)m_B)*((UINT64)iValue.m_C) ); 
	 
	iResult += ( iT8 < 64 ); 
	iResult += ( iT9 < 96 ); 
 
	CHSInt128 iT0( ((UINT64)m_A)*((UINT64)iValue.m_D) ); 
	 
	iResult += ( iT0 < 96 ); 
 
	return iResult; 
} 
 
// Operator *= 
CHSInt128& CHSInt128::operator *=(const CHSInt128 &iValue) 
{ 
	*this = *this * iValue; 
 
	return *this; 
} 
 
// Operator / 
CHSInt128 CHSInt128::operator /(const CHSInt128 &iValue) const 
{ 
	CHSInt128 iQuotient; 
	CHSInt128 iRemainder; 
 
	Division( iValue, iQuotient,iRemainder );	 
 
	return iQuotient; 
} 
 
// Operator /= 
CHSInt128& CHSInt128::operator /=(const CHSInt128 &iValue) 
{ 
	*this = *this / iValue; 
 
	return *this; 
} 
 
// Operator % 
CHSInt128 CHSInt128::operator %(const CHSInt128 &iValue) const 
{ 
	CHSInt128 iQuotient; 
	CHSInt128 iRemainder; 
 
	Division( iValue, iQuotient, iRemainder ); 
 
	return iRemainder; 
} 
 
// Operator %= 
CHSInt128& CHSInt128::operator %=(const CHSInt128 &iValue) 
{ 
	*this = *this % iValue; 
	 
	return *this; 
} 
 
// Complement 
void CHSInt128::Complement( void ) 
{ 
	NOT( m_A  ); 
	NOT( m_B ); 
	NOT( m_C ); 
	NOT( m_D  ); 
 
	*this = *this + CHSInt128( 1 );; 
} 
 
// Inverse Complement 
void CHSInt128::ComplementInverse( void ) 
{ 
	*this = *this - CHSInt128( 1 );; 
 
	NOT( m_A  ); 
	NOT( m_B ); 
	NOT( m_C ); 
	NOT( m_D  ); 
} 
 
// If Value is Positive return true 
bool CHSInt128::IsPositive( void ) const 
{ 
	return ( ( m_D & 0X80000000 ) == 0X00000000 ); 
} 
 
// Return true, If its Negative 
bool CHSInt128::IsNegative( void ) const 
{ 
	return ( ( m_D & 0X80000000 ) == 0X80000000 ); 
} 
 
// Set Negative Flag 
void CHSInt128::SetNegativeFlag( void ) 
{ 
	OR ( m_D, 0X80000000 );  
} 
 
// Set Positive Flag 
void CHSInt128::SetPositiveFlag( void ) 
{ 
	AND( m_D, 0X7FFFFFFF ); 
} 
 
// Division 
void CHSInt128::Division(const CHSInt128 &iDivisor, CHSInt128 &iQuotient, CHSInt128 &iRemainder) const 
{ 
	if ( iDivisor == CHSInt128( 0 ) ) 
	{ 
		__asm 
		{ 
			mov	eax, 0 
			div eax 
		} 
	} 
 
	iQuotient.Zero(); 
	iRemainder.Zero(); 
 
	// 原码加减交替法计算 X/Y 
	CHSInt128 iTempR0;					// R0 : Remainder 
	CHSInt128 iTempR1 ( *this );			// R1 : Quotient 
	CHSInt128 iTempR2 ( iDivisor );		// R2 : Divisor 
 
	// if Dividend is Zero, No Need Calc 
	if ( iTempR1.IsZero() )	return; 
 
	bool	bDivrNegative = false, bDivdNegative = false; 
 
	// 将补码转换为原码 
	if ( iTempR1.IsNegative() ) 
	{ 
		iTempR1.ComplementInverse(); 
		bDivdNegative = true; 
	} 
	else iTempR1.SetAt( 127, 0 ); 
 
	// 将补码转换为原码 
	if ( iDivisor.IsNegative() ) 
	{ 
		iTempR2.ComplementInverse(); 
		bDivrNegative = true; 
	} 
	else iTempR2.SetAt( 127, 0 ); 
 
	iTempR0 -= iTempR2; 
 
	for ( UINT iN = 0; iN  128; iN++ ) 
	{ 
		iTempR0 <= 1; 
 
		// Move iTempR1(High Bit) to iTempR0(Low Bit) 
		if ( iTempR1.GetAt( 127 ) )	 
			 iTempR0.SetAt( 0, 1 ); 
 
		iTempR1 <= 1; 
 
		if ( iTempR0.GetAt( 127 ) ) 
		{ 
			iTempR0 += iTempR2; 
		} 
		else 
		{ 
			iTempR1.SetAt( 0, 1 ); 
			iTempR0 -= iTempR2; 
		} 
	}			 
 
	iTempR1 <= 1; 
 
	if ( !iTempR0.GetAt( 127 ) ) 
	{ 
		iTempR1.SetAt( 0, 1 ); 
	} 
	else iTempR0 += iTempR2; 
 
	if ( bDivrNegative ^ bDivdNegative ) 
	{ 
		iTempR1.Complement(); 
	} 
 
	iQuotient  = iTempR1; 
	iRemainder = iTempR0; 
} 
 
// Set or Clear one bit where you want 
void CHSInt128::SetAt(UINT uIndex, bool bSet) 
{ 
	DWORD	dwBitAt = ( 0X00000001 < (uIndex % 32 ) ); 
 
	if ( bSet ) 
	{ 
		if ( uIndex  32 ) 
			m_A |= dwBitAt; 
		else 
		if ( uIndex  64 ) 
			m_B |= dwBitAt; 
		else 
		if ( uIndex  96 ) 
			m_C |= dwBitAt; 
		else 
			m_D |= dwBitAt; 
	} 
	else 
	{ 
		if ( uIndex  32 ) 
			m_A &= ~dwBitAt; 
		else 
		if ( uIndex  64 ) 
			m_B &= ~dwBitAt; 
		else 
		if ( uIndex  96 ) 
			m_C &= ~dwBitAt; 
		else 
			m_D &= ~dwBitAt; 
	} 
} 
 
// Get Bit At ... 
bool CHSInt128::GetAt(UINT uIndex) const 
{ 
	DWORD	dwBitAt = ( 0X00000001 < (uIndex % 32 ) ); 
 
	if ( uIndex  32 )	return ( ( m_A & dwBitAt ) != 0 ); 
	else 
	if ( uIndex  64 )	return ( ( m_B & dwBitAt ) != 0 ); 
	else 
	if ( uIndex  96 )	return ( ( m_C & dwBitAt ) != 0 ); 
	else 
						return ( ( m_D & dwBitAt ) != 0 ); 
} 
 
// Is Me Zero ? 
bool CHSInt128::IsZero() const 
{ 
	return ( m_D == 0 && 
			 m_C == 0 && 
			 m_B == 0 && 
			 m_A == 0  
            ); 
} 
 
// Set Me Zero 
void CHSInt128::Zero() 
{ 
	m_A = m_B = m_C = m_D = 0; 
} 
 
// Get CHSInt128 Left 
CHSInt128 CHSInt128::GetLeft(UINT uCount) const 
{ 
	CHSInt128 iTemp( *this ); 
 
	iTemp >>= ( 128 - uCount ); 
 
	return iTemp; 
} 
 
// Get Right uCount bit 
CHSInt128 CHSInt128::GetRight(UINT uCount) const 
{ 
	CHSInt128 iTemp( *this ); 
 
	iTemp <= ( 128 - uCount ); 
	iTemp >>= ( 128 - uCount ); 
 
	return iTemp; 
} 
 
// Set Me Max 
void CHSInt128::Max() 
{ 
	m_D = 0X7FFFFFFF; 
 
	m_C = m_B = m_A = 0XFFFFFFFF; 
} 
 
// Set Me Min 
void CHSInt128::Min() 
{ 
	m_D = 0X80000000; 
 
	m_C = m_B = m_A = 0X00000000;	 
} 
 
 
// Change From String Integer to CHSInt128 
bool CHSInt128::FromStr(LPCTSTR lpszValue) 
{ 
	CHSInt128	iTemp; 
	CString	strSrc = lpszValue; 
	int		nLength, nIndex = 0; 
	bool	bNegative = false; 
	char	cSrc; 
		 
	strSrc.TrimLeft(); 
	strSrc.TrimRight(); 
 
	if ( strSrc[0] == '-' ) 
	{ 
		bNegative = true; 
		nIndex = 1; 
	} 
 
	if ( ( nLength = strSrc.GetLength() ) > 40 )  
		nLength = 40; 
	 
	while ( nIndex  nLength ) 
	{ 
		cSrc = strSrc[nIndex]; 
 
		if (  cSrc  _T('0') || cSrc > _T('9') )	return false; 
 
		iTemp *= 10; 
		iTemp += CHSInt128( (int)( cSrc - _T('0') ) ); 
 
		nIndex++; 
	} 
 
	*this = iTemp; 
 
	if ( bNegative )	Complement(); 
 
	return true; 
} 
 
// Translate from CHSInt128 to CString 
bool CHSInt128::ToStr(CString &strValue) 
{ 
	CHSInt128	iTemp( *this ); 
	char	cTarget; 
 
	strValue = _T(""); 
 
	do 
	{ 
		cTarget = ( (char)((int)( ( iTemp % 10 ).m_A )) + _T('0') ); 
 
		strValue += cTarget; 
 
		iTemp /= 10; 
 
	} while( !iTemp.IsZero() ); 
 
	strValue += ' '; 
	strValue.MakeReverse(); 
 
	if ( IsNegative() )		 
		 strValue.SetAt( 0, '-' ); 
 
	return true; 
} 
/* 
CHSInt128::operator int() 
{ 
	return ( (int)m_A ); 
} 
 
CHSInt128::operator unsigned int() 
{ 
	return ( (unsigned int)m_A ); 
} 
 
CHSInt128::operator long() 
{ 
	return ( (long)m_A ); 
} 
 
CHSInt128::operator unsigned long() 
{ 
	return ( (unsigned long)m_A ); 
} 
 
CHSInt128::operator __int64() 
{ 
	return ( ( ((__int64)(m_B))<<32 ) + (__int64)m_A ); 
} 
 
CHSInt128::operator unsigned __int64() 
{ 
	return ( ( ((unsigned __int64)(m_B))<<32 ) + (unsigned __int64)m_A ); 
} 
*/
 

 

                

        

        

    

  


    

      

        

            

              
                
                  清_风_明_月
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
FP16、BF16、INT8、INT4精度模型加载所需显存以及硬件适配的分析

				
			

			

				

					herosunly的博客
				

				

					05-03
					
					13万+
					
				

			

		

		

			
				
本文主要介绍了FP16、INT8、INT4精度模型加载占用显存大小的分析，希望对学习大语言模型的同学们有所帮助。

文章目录

1. 前言
2. 模型加载显存占用大小
3. 不同精度是否与硬件适配

			
		

	



                

            
              



	

		

			

				
					
__int128

				
			

			

				

					Ordinarv
				

				

					10-05
					
					158
					
				

			

		

		

			
				
void scan(__int128 &x)
{
    x = 0;
    int f = 1;
    char ch;
    if((ch = getchar()) == '-') f = -f;
    else x = x*10 + ch-'0';
    while((ch = getchar()) >= '0' && ch <= '9')
 ...

			
		

	



              


  
              

                


	

		

			

				
					
C++ int128

				
			

			

				

					weixin_52559308的博客
				

				

					11-21
					
					3877
					
				

			

		

		

			
				
C++ int128
**
快速地调用，一般的方法
**
还可以，不过并不是最大的，有时还差点意思，相当于longlong强化版
#include<iostream>
using in = signed long long int;

int main(){
	
	int n,m;
	std::cin >> n >> m;
	
}

解题时使用的int128，避免了使用高精度的高代码强度
#include <bits/stdc++.h>
using in = 

			
		

	





	

		

			

				
					
__int128 的输入输出 （ 模板 ）

					
最新发布

				
			

			

				

					2301_81488029的博客
				

				

					09-04
					
					440
					
				

			

		

		

			
				
_int128属于高精度，__int128最大可以表示39位数，可以进行+,-,*,/,&,^,| 等基本运算，可以用快读快写输入输出。

			
		

	



		

			
		



	

		

			

				
					
__int128的实现

				
			

			

				

					dav74739的博客
				

				

					02-04
					
					720
					
				

			

		

		

			
				
#include<bitset>  
#include<algorithm>  
#include<iostream>  
#include<string>  
#include<deque>  
#include<cstdio>
using namespace std;  
  
class i...

			
		

	





	

		

			

				
					
int128的实现（基本完成）

				
			

			

				

					Fool256353的博客
				

				

					02-22
					
					1923
					
				

			

		

		

			
				
总所周知，我们这里的最高位的int的位数是64位（long long），最高表示的数是2^64-1（无符号），只有18,446,744,073,709,551,615大概10的20次方，有的时候是不够用的，用高精度数组的速度的效率又相对较慢，这时候就想到了int128了。至于为什么不让每种计算都支持int128嘛，因为懒得写了，还有乘法会爆int128、没必要，而且蓝桥杯要到了，我得加紧算法的学习了（这个东西花了我4天去改，虽然不是每一刻都在想，但是也挺搞事的）然后按照数学的计算，就可以设计出加减乘除了。

			
		

	





	

		

			

				
					
关于 __int128

				
			

			

				

					weixin_30596023的博客
				

				

					12-13
					
					526
					
				

			

		

		

			
				
__int128 是 GCC 提供的扩展（extension），可以当作 128 位整数使用。
关于 __int128 和 __int128_t

Normally, _t suffix means a typedef, __ prefix means reserved for compiler and _ prefix means reserved for standard library; I...

			
		

	





	

		

			

				
					
__int128的使用

				
			

			

				

					Youthenen的博客
				

				

					02-10
					
					932
					
				

			

		

		

			
				
输入输出：
C/C++标准IO是不认识__int128这种数据类型的，因此要自己实现IO，其他的运算，与int没有什么不同。
#include <bits/stdc++.h>
using namespace std;
inline __int128 read()
{
    __int128 x=0,f=1;
    char ch=getchar();
    while(ch&lt...

			
		

	





	

		

			

				
					
int128_c++int128_

				
			

			

				

					09-30
				

			

		

		

			
				
对于不支持`__int128_t`的编译器，程序员可以使用第三方库，如GMP（GNU Multiple Precision Arithmetic Library）或者Boost.Multiprecision库来实现大整数操作。  输入输出`int128`类型的数据时，由于这不是标准C++...

			
		

	





	

		

			

				
					
__int128使用详解和整形输入输出的优化(比scanf和printf快)

				
			

			

				

					weixin_46204555的博客
				

				

					10-28
					
					2579
					
				

			

		

		

			
				
__int128，__uint_i28和read，write函数讲解

			
		

	





	

		

			

				
					
C++中int128的应用与大数处理技巧

				
			

			

				

					
				

			

		

		

			
				
在使用int128类型进行输入输出操作时，C++标准库中的输入输出流并不直接支持`__int128`类型，因此需要借助一些特殊的方法来实现。通常，用户需要自定义输入输出操作符重载函数，以便于`__int128`能够被正确地读取和...

			
		

	





	

		

			

				
					
java byte数组与int,long,short,byte的转换实现方法

				
			

			

				

					09-01
				

			

		

		

			
				
Java中的`byte`类型是8位的，取值范围是-128到127。如果要将其转换为无符号的32位整数`int`，可以使用按位与操作符`&`和0xFF。`DataTypeChangeHelper`类中的`unsignedByteToInt`方法就实现了这一点：  ```java ...

			
		

	





	

		

			

				
					
三分模板+int128模板

				
			

			

				

					我们仍未知道那天所看见的花的名字。
				

				

					11-16
					
					303
					
				

			

		

		

			
				
while(l<r)
    {
        ll midl=l+(r-l)/3;
        ll midr=r-(r-l)/3;
        if(check(midl)<=check(midr))
            r=midr-1;
        else l=midl+1;
    }

#include <bits/stdc++.h>
using namespace std;
inline __int128 read()
{
    __int128 

			
		

	





	

		

			

				
					
C/C++ __int128的使用

					
热门推荐

				
			

			

				

					Authur_gyc
				

				

					09-02
					
					2万+
					
				

			

		

		

			
				
gcc是不支持__int128这种数据类型的，比如在codeblocks 16.01也是无法编译的，但是提交到大部分OJ上是可以编译且能用的。C/C++标准IO是不认识__int128这种数据类型的，因此要自己实现IO，其他的运算，与int没有什么不同。
参考来源
博客
https://blog.csdn.net/tianwei0822/article/details/80687466

...

			
		

	





	

		

			

				
					
关于__int128

				
			

			

				

					b24384504986189的博客
				

				

					08-15
					
					325
					
				

			

		

		

			
				
参考：关于__int128

__int128本身可以进行的运算有+ - * / %还有各种位运算符
但是__int128不可以进行输入输出的操作，如果想要进行输入输出需要自定义函数
__int128可以在 64 位的编译器中运行
亲测__int128大概最多能够储存 4e22 左右的数


输入：

void read(__int128 &x)
{
    x=0;
    i...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值