清_风_明_月

int 128 实现

来源 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
//$//  邮箱地址　：[email protected]
//$//
//$//  作者声明　：此部分代码全是作者所写，可以随便传播，但要保持
//$//       文件的完整性,如果您有问题或有好的建议、意见请您
//$//          给我来信,非常感谢!
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
//$//

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  
//$//		邮箱地址　：[email protected] 
//$//					 
//$//		作者声明　：此部分代码全是作者所写，可以随便传播，但要保持 
//$//				   文件的完整性,如果您有问题或有好的建议、意见请您 
//$//			       给我来信,非常感谢!			 
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 
//$//							 
 
 
 
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.cpp: implementation of the CALU 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
//$//
//$// 作者 : 韩松
//$//
//$// 程序名称　：CALU
//$// 发布日期：02/10/01
//$// 邮箱地址　：[email protected]
//$//
//$// 作者声明　：此部分代码全是作者所写，可以随便传播，但要保持
//$// 文件的完整性,如果您有问题或有好的建议、意见请您
//$// 给我来信,非常感谢!
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
//$//
//
// Construction/Destruction
//
CALU::CALU()
{
PSW = NOFLAG;
}
CALU::~CALU()
{
}
// Set Flag
inline void CALU::SetPSW(unsigned short Flag, const DWORD& Set)
{
if ( Set )
PSW |= Flag;
else PSW &= ~Flag;
}
// Get Flag
inline bool CALU::GetPSW(const unsigned short Flag) const
{
return ( ( PSW & Flag ) != 0 );
}
// Set Flag
inline void CALU::SetPSW(const unsigned short Flag)
{
PSW |= Flag;
}
// Clear Flag
inline void CALU::ClearPSW(const unsigned short Flag)
{
PSW &= ~Flag;
}
// Get Low 32 Bit ( unsinged __int64 )
DWORD CALU::LO32(const UINT64 &nnTemp)
{
return ( (DWORD)( ( (UINT64)(nnTemp)) & ((UINT64)(0X00000000FFFFFFFF)) ) );
}
// Get High 32 Bit ( unsinged __int64 )
DWORD CALU::HI32(const UINT64 &nnTemp)
{
return ( (DWORD)( ( ((UINT64)(nnTemp)) & ((UINT64)(0XFFFFFFFF00000000))) >> 32 ) );
}
// Clear Carry
void CALU::CLC()
{
ClearPSW( CF );
}
// Complement Carry
inline void CALU::CMC()
{
if ( GetPSW( CF ) )
CLC();
else STC();
}
// Set Carry
inline void CALU::STC()
{
SetPSW( CF );
}
// Test
void CALU::TEST(const DWORD OPR1, const DWORD OPR2)
{
SetPSW( ZF, ( ( OPR1 & OPR2 )==0 ) );
}
// And
void CALU::AND(DWORD &DST, const DWORD SRC)
{
DST &= SRC;
}
// Or
void CALU::OR(DWORD &DST, const DWORD SRC)
{
DST |= SRC;
}
// Not
void CALU::NOT(DWORD &DST)
{
DST = ~DST;
}
// Exclusive or
void CALU::XOR(DWORD &DST, DWORD SRC)
{
DST ^= SRC;
}
// Add
inline void CALU::ADD(DWORD &DST, DWORD SRC)
{
UINT64 nnTemp;
nnTemp = (UINT64)DST + (UINT64)SRC;
SetPSW( CF, ( nnTemp > MAX ) );
DST = LO32( nnTemp );
}
// Add width Carry
inline void CALU::ADC(DWORD &DST, DWORD SRC)
{
UINT64 nnTemp;
nnTemp = (UINT64)DST + (UINT64)SRC + (int)GetPSW( CF );
SetPSW( CF, ( nnTemp > MAX ) );
DST = LO32( nnTemp );
}
// Add 3 Parameters
void CALU::ADD(DWORD &DST, DWORD SRC1, DWORD SRC2)
{
ADD( SRC1, SRC2 );
DST = SRC1;
}
// Add With Carry 3 Parameter
void CALU::ADC(DWORD &DST, DWORD SRC1, DWORD SRC2)
{
ADC( SRC1, SRC2 );
DST = SRC1;
}
// Subtract
inline void CALU::SUB(DWORD &DST, DWORD SRC)
{
UINT64 nnTemp;
nnTemp = (UINT64)DST - (UINT64)SRC;
SetPSW( CF, ( nnTemp > MAX ) );
DST = (DWORD)nnTemp;
}
// Subtract with borrow
inline void CALU::SBB(DWORD &DST, DWORD SRC)
{
UINT64 nnTemp;
nnTemp = (UINT64)DST - (UINT64)SRC - (int)GetPSW( CF );
SetPSW( CF, ( nnTemp > MAX ) );
DST = (DWORD)nnTemp;
}
// Subtract 3 Parameters
void CALU::SUB(DWORD &DST, DWORD SRC1, DWORD SRC2)
{
SUB( SRC1, SRC2 );
DST = SRC1;
}
// Subtrace with borrow 3 Parameters
void CALU::SBB(DWORD &DST, DWORD SRC1, DWORD SRC2)
{
SBB( SRC1, SRC2 );
DST = SRC1;
}
// Shift logical left ( CNT >= 1 )
void CALU::SHL(DWORD &OPR, const UINT CNT)
{
OPR <= ( CNT - 1 );
SetPSW( CF, ( ( OPR & 0X80000000 ) != 0 ) );
OPR <= 1;
}
// Shift logical left ( CNT >= 1 ) return Low 32 Bit
void CALU::SHL( DWORD& DSTH, DWORD& DSTL, DWORD SRC, const UINT CNT)
{
UINT64 nnTemp = (UINT64)SRC;
nnTemp <= ( CNT - 1 );
SetPSW( CF, ( ( nnTemp & UINT64(0X8000000000000000) ) != 0 ) );
nnTemp <= 1;
DSTH = HI32( nnTemp );
DSTL = LO32( nnTemp );
}
// Mov uShift Bit To DST
void CALU::SHL(DWORD &DST, DWORD &SRC, const UINT CNT)
{
DWORD DSTH = 0;
SHL( DSTH, SRC, SRC, CNT );
DST |= DSTH;
}
// Shift Arithmetic right CNT >= 1
void CALU::SHR(DWORD &OPR, const UINT CNT)
{
OPR >>= ( CNT - 1 );
SetPSW( CF, ( ( OPR & 0X00000001 ) != 0 ) );
OPR >>= 1;
}
//
void CALU::SHR(DWORD SRC, DWORD &DSTH, DWORD &DSTL, const UINT CNT)
{
UINT64 nnTemp = (UINT64)SRC;
nnTemp <= 32;
nnTemp >>= ( CNT - 1 );
SetPSW( CF, ( ( nnTemp & 0X0000000000000001 ) != 0 ) );
nnTemp >>= 1;
DSTH = HI32( nnTemp );
DSTL = LO32( nnTemp );
}
//
void CALU::SHR(DWORD &SRC, DWORD &DST, const UINT CNT)
{
DWORD DSTL = 0;
SHR( SRC, SRC, DSTL, CNT );
DST |= DSTL;
}
void CALU::MUL(UINT64 &DST, DWORD SRC1, DWORD SRC2)
{
DST = ( SRC1 * SRC2 );
}

// 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
//$//  邮箱地址　：[email protected]
//$//
//$//  作者声明　：此部分代码全是作者所写，可以随便传播，但要保持
//$//       文件的完整性,如果您有问题或有好的建议、意见请您
//$//          给我来信,非常感谢!
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
//$//

#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  
//$//		邮箱地址　：[email protected] 
//$//					 
//$//		作者声明　：此部分代码全是作者所写，可以随便传播，但要保持 
//$//				   文件的完整性,如果您有问题或有好的建议、意见请您 
//$//			       给我来信,非常感谢!			 
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 
//$//							 
 
 
 
#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.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
//$// 邮箱地址　：[email protected]
//$//
//$// 作者声明　：此部分代码全是作者所写，可以随便传播，但要保持
//$// 文件的完整性,如果您有问题或有好的建议、意见请您
//$// 给我来信,非常感谢!
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
//$//
//
// 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
{
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
{
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 );
}
*/

// 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  
//$//		邮箱地址　：[email protected] 
//$//					 
//$//		作者声明　：此部分代码全是作者所写，可以随便传播，但要保持 
//$//				   文件的完整性,如果您有问题或有好的建议、意见请您 
//$//			       给我来信,非常感谢!			 
//$//　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　 
//$//							 
 
 
 
// 
// 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 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 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 ); 
} 
*/

你可能感兴趣的:(int 128 实现)

OC语言多界面传值五大方式 Magnetic_h ios ui 学习 objective-c 开发语言
前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
element实现动态路由+面包屑软件技术NINI vue案例 vue.js 前端
el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
C语言宏函数南林yan C语言 c语言
一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务 java 架构
在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
理解Gunicorn：Python WSGI服务器的基石范范0825 ipython linux 运维
理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
2021年12月19日，春蕾教育集团团建活动感受——黄晓丹黄错错加油
感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
c++ 的iostream 和 c++的stdio的区别和联系黄卷青灯77 c++算法开发语言 iostream stdio
在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码说私域人工智能小程序
摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
消息中间件有哪些常见类型 xmh-sxh-1314 java
消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
每日一题——第八十九题互联网打工人no1 C语言程序设计每日一练 c语言
题目：在字符串中找到提取数字，并统计一共找到多少整数，a123xxyu23&8889，那么找到的整数为123，23，8889//思想：#include#include#includeintmain(){charstr[]="a123xxyu23&8889";intcount=0;intnum=0;//用于临时存放当前正在构建的整数。boolinNum=false;//用于标记当前是否正在读取一个整
每日一题——第九十题互联网打工人no1 C语言程序设计每日一练 c语言
题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
每日一题——第八十一题互联网打工人no1 C语言程序设计每日一练 c语言
打印如下图案:#includeintmain(){inti,j;charch='A';for(i=1;i<5;i++,ch++){for(j=0;j<5-i;j++){printf("");//控制空格输出}for(j=1;j<2*i;j++)//条件j<2*i{printf("%c",ch);//控制字符输出}printf("\n");}return0;}
每日一题——第八十四题互联网打工人no1 C语言程序设计每日一练 c语言
题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
每日一题——第八十二题互联网打工人no1 C语言程序设计每日一练 c语言
题目：将一个控制台输入的字符串中的所有元音字母复制到另一字符串中#include#include#include#include#defineMAX_INPUT1024boolisVowel(charp);intmain(){charinput[MAX_INPUT];charoutput[MAX_INPUT];printf("请输入一串字符串：\n");fgets(input,sizeof(inp
每日一题——第八十三题互联网打工人no1 C语言程序设计每日一练 c语言
题目：将输入的整形数字输出,输出1990，输出"1990"#include#defineMAX_INPUT1024intmain(){intarrr_num[MAX_INPUT];intnum,i=0;printf("请输入一个数字：");scanf_s("%d",&num);while(num!=0){arrr_num[i++]=num%10;num/=10;}printf("\"");for(
腾讯云技术深度探索：构建高效云原生微服务架构我的运维人生云原生架构腾讯云运维开发技术共享
腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
从0到500+，我是如何利用自媒体赚钱？一列脚印
运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
使用LLaVa和Ollama实现多模态RAG示例 llzwxh888 python 人工智能开发语言
本文将详细介绍如何使用LLaVa和Ollama实现多模态RAG（检索增强生成），通过提取图像中的结构化数据、生成图像字幕等功能来展示这一技术的强大之处。安装环境首先，您需要安装以下依赖包：!pipinstallllama-index-multi-modal-llms-ollama!pipinstallllama-index-readers-file!pipinstallunstructured!p
利用LangChain的StackExchange组件实现智能问答系统 nseejrukjhad langchain microsoft 数据库 python
利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
python八股文面试题分享及解析(1) Shawn________ python
#1.'''a=1b=2不用中间变量交换a和b'''#1.a=1b=2a,b=b,aprint(a)print(b)结果：21#2.ll=[]foriinrange(3):ll.append({'num':i})print(11)结果:#[{'num':0},{'num':1},{'num':2}]#3.kk=[]a={'num':0}foriinrange(3):#0,12#可变类型，不仅仅改变
MongoDB Oplog 窗口喝醉酒的小白 MongoDB 运维
在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
Faiss Tips：高效向量搜索与聚类的利器焦习娜Samantha
FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Python 实现图片裁剪（附代码） | Python工具剑客阿良_ALiang
前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
Redis系列：Geo 类型赋能亿级地图位置计算 Ly768768 redis bootstrap 数据库
1前言我们在篇深刻理解高性能Redis的本质的时候就介绍过Redis的几种基本数据结构，它是基于不同业务场景而设计的：动态字符串(REDIS_STRING)：整数(REDIS_ENCODING_INT)、字符串(REDIS_ENCODING_RAW)双端列表(REDIS_ENCODING_LINKEDLIST)压缩列表(REDIS_ENCODING_ZIPLIST)跳跃表(REDIS_ENCODI
ARM驱动学习之5 LEDS驱动 JT灬新一嵌入式 C 底层 arm开发学习单片机
ARM驱动学习之5LEDS驱动知识点：•linuxGPIO申请函数和赋值函数–gpio_request–gpio_set_value•三星平台配置GPIO函数–s3c_gpio_cfgpin•GPIO配置输出模式的宏变量–S3C_GPIO_OUTPUT注意点：DRIVER_NAME和DEVICE_NAME匹配。实现步骤：1.加入需要的头文件：//Linux平台的gpio头文件#include//三
ARM驱动学习之4小结 JT灬新一嵌入式 C++arm开发学习 linux
ARM驱动学习之4小结#include#include#include#include#include#defineDEVICE_NAME"hello_ctl123"MODULE_LICENSE("DualBSD/GPL");MODULE_AUTHOR("TOPEET");staticlonghello_ioctl(structfile*file,unsignedintcmd,unsignedlo
Low Power概念介绍-Voltage Area 飞奔的大虎
随着智能手机，以及物联网的普及，芯片功耗的问题最近几年得到了越来越多的重视。为了实现集成电路的低功耗设计目标，我们需要在系统设计阶段就采用低功耗设计的方案。而且，随着设计流程的逐步推进，到了芯片后端设计阶段，降低芯片功耗的方法已经很少了，节省的功耗百分比也不断下降。芯片的功耗主要由静态功耗（staticleakagepower）和动态功耗(dynamicpower)构成。静态功耗主要是指电路处于等
矩阵求逆（JAVA）初等行变换 qiuwanchi 矩阵求逆（JAVA）
package gaodai.matrix; import gaodai.determinant.DeterminantCalculation; import java.util.ArrayList; import java.util.List; import java.util.Scanner; /** * 矩阵求逆(初等行变换) * @author 邱万迟 *
JDK timer antlove java jdk schedule code timer
1.java.util.Timer.schedule(TimerTask task, long delay)：多长时间（毫秒）后执行任务 2.java.util.Timer.schedule(TimerTask task, Date time)：设定某个时间执行任务 3.java.util.Timer.schedule(TimerTask task, long delay,longperiod
JVM调优总结 -Xms -Xmx -Xmn -Xss coder_xpf jvm 应用服务器
堆大小设置JVM 中最大堆大小有三方面限制：相关操作系统的数据模型（32-bt还是64-bit）限制；系统的可用虚拟内存限制；系统的可用物理内存限制。32位系统下，一般限制在1.5G~2G；64为操作系统对内存无限制。我在Windows Server 2003 系统，3.5G物理内存，JDK5.0下测试，最大可设置为1478m。典型设置： java -Xmx
JDBC连接数据库 Array_06 jdbc
package Util; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class JDBCUtil { //完
Unsupported major.minor version 51.0（jdk版本错误） oloz java
java.lang.UnsupportedClassVersionError: cn/support/cache/CacheType : Unsupported major.minor version 51.0 (unable to load class cn.support.cache.CacheType) at org.apache.catalina.loader.WebappClassL
用多个线程处理1个List集合 362217990 多线程 thread list 集合
昨天发了一个提问，启动5个线程将一个List中的内容，然后将5个线程的内容拼接起来，由于时间比较急迫，自己就写了一个Demo，希望对菜鸟有参考意义。。 import java.util.ArrayList; import java.util.List; import java.util.concurrent.CountDownLatch; public c
JSP简单访问数据库香水浓 sql mysql jsp
学习使用javaBean，代码很烂，仅为留个脚印 public class DBHelper { private String driverName; private String url; private String user; private String password; private Connection connection; privat
Flex4中使用组件添加柱状图、饼状图等图表 AdyZhang Flex
1.添加一个最简单的柱状图 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 <?xml version= "1.0"&n
Android 5.0 - ProgressBar 进度条无法展示到按钮的前面 aijuans android
在低于SDK < 21 的版本中，ProgressBar 可以展示到按钮前面，并且为之在按钮的中间，但是切换到android 5.0后进度条ProgressBar 展示顺序变化了，按钮再前面，ProgressBar 在后面了我的xml配置文件如下： [html] view plain copy <RelativeLa
查询汇总的sql baalwolf sql
select list.listname, list.createtime,listcount from dream_list as list , (select listid,count(listid) as listcount from dream_list_user group by listid order by count(
Linux du命令和df命令区别 BigBird2012 linux
1，两者区别 du，disk usage,是通过搜索文件来计算每个文件的大小然后累加，du能看到的文件只是一些当前存在的，没有被删除的。他计算的大小就是当前他认为存在的所有文件大小的累加和。
AngularJS中的$apply，用还是不用？ bijian1013 JavaScript AngularJS $apply
在AngularJS开发中，何时应该调用$scope.$apply()，何时不应该调用。下面我们透彻地解释这个问题。但是首先，让我们把$apply转换成一种简化的形式。 scope.$apply就像一个懒惰的工人。它需要按照命
[Zookeeper学习笔记十]Zookeeper源代码分析之ClientCnxn数据序列化和反序列化 bit1129 zookeeper
ClientCnxn是Zookeeper客户端和Zookeeper服务器端进行通信和事件通知处理的主要类，它内部包含两个类，1. SendThread 2. EventThread， SendThread负责客户端和服务器端的数据通信，也包括事件信息的传输，EventThread主要在客户端回调注册的Watchers进行通知处理 ClientCnxn构造方法 &
【Java命令一】jmap bit1129 Java命令
jmap命令的用法： [hadoop@hadoop sbin]$ jmap Usage: jmap [option] <pid> (to connect to running process) jmap [option] <executable <core> (to connect to a
Apache 服务器安全防护及实战 ronin47
此文转自IBM. Apache 服务简介 Web 服务器也称为 WWW 服务器或 HTTP 服务器 (HTTP Server)，它是 Internet 上最常见也是使用最频繁的服务器之一，Web 服务器能够为用户提供网页浏览、论坛访问等等服务。由于用户在通过 Web 浏览器访问信息资源的过程中，无须再关心一些技术性的细节，而且界面非常友好，因而 Web 在 Internet 上一推出就得到
unity 3d实例化位置出现布置？ brotherlamp unity教程 unity unity资料 unity视频 unity自学
问：unity 3d实例化位置出现布置？答：实例化的同时就可以指定被实例化的物体的位置,即 position Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object 这样你不需要再用Transform.Position了, 如果你省略了第二个参数(
《重构，改善现有代码的设计》第八章 Duplicate Observed Data bylijinnan java 重构
import java.awt.Color; import java.awt.Container; import java.awt.FlowLayout; import java.awt.Label; import java.awt.TextField; import java.awt.event.FocusAdapter; import java.awt.event.FocusE
struts2更改struts.xml配置目录 chiangfai struts.xml
struts2默认是读取classes目录下的配置文件，要更改配置文件目录，比如放在WEB-INF下，路径应该写成../struts.xml(非/WEB-INF/struts.xml) web.xml文件修改如下： <filter> <filter-name>struts2</filter-name> <filter-class&g
redis做缓存时的一点优化 chenchao051 redis hadoop pipeline
最近集群上有个job，其中需要短时间内频繁访问缓存，大概7亿多次。我这边的缓存是使用redis来做的，问题就来了。首先，redis中存的是普通kv，没有考虑使用hash等解结构，那么以为着这个job需要访问7亿多次redis，导致效率低，且出现很多redi
mysql导出数据不输出标题行 daizj mysql 数据导出去掉第一行去掉标题
当想使用数据库中的某些数据，想将其导入到文件中，而想去掉第一行的标题是可以加上-N参数如通过下面命令导出数据： mysql -uuserName -ppasswd -hhost -Pport -Ddatabase -e " select * from tableName" > exportResult.txt 结果为： studentid
phpexcel导出excel表简单入门示例 dcj3sjt126com PHP Excel phpexcel
先下载PHPEXCEL类文件，放在class目录下面，然后新建一个index.php文件，内容如下 <?php error_reporting(E_ALL); ini_set('display_errors', TRUE); ini_set('display_startup_errors', TRUE); if (PHP_SAPI == 'cli') die('
爱情格言 dcj3sjt126com 格言
1) I love you not because of who you are, but because of who I am when I am with you. 　　我爱你，不是因为你是一个怎样的人，而是因为我喜欢与你在一起时的感觉。 　　2) No man or woman is worth your tears, and the one who is, won‘t
转 Activity 详解——Activity文档翻译 e200702084 android UI sqlite 配置管理网络应用
activity 展现在用户面前的经常是全屏窗口，你也可以将 activity 作为浮动窗口来使用（使用设置了 windowIsFloating 的主题），或者嵌入到其他的 activity （使用 ActivityGroup ）中。当用户离开 activity 时你可以在 onPause() 进行相应的操作。更重要的是，用户做的任何改变都应该在该点上提交 ( 经常提交到 ContentPro
win7安装MongoDB服务 geeksun mongodb
1. 下载MongoDB的windows版本：mongodb-win32-x86_64-2008plus-ssl-3.0.4.zip，Linux版本也在这里下载，下载地址： http://www.mongodb.org/downloads 2. 解压MongoDB在D:\server\mongodb, 在D:\server\mongodb下创建d
Javascript魔法方法:__defineGetter__,__defineSetter__ hongtoushizi js
转载自： http://www.blackglory.me/javascript-magic-method-definegetter-definesetter/ 在javascript的类中,可以用defineGetter和defineSetter_控制成员变量的Get和Set行为例如,在一个图书类中,我们自动为Book加上书名符号: function Book(name){
错误的日期格式可能导致走nginx proxy cache时不能进行304响应 jinnianshilongnian cache
昨天在整合某些系统的nginx配置时，出现了当使用nginx cache时无法返回304响应的情况，出问题的响应头： Content-Type:text/html; charset=gb2312 Date:Mon, 05 Jan 2015 01:58:05 GMT Expires:Mon , 05 Jan 15 02:03:00 GMT Last-Modified:Mon, 05
数据源架构模式之行数据入口 home198979 PHP 架构行数据入口
注：看不懂的请勿踩，此文章非针对java，java爱好者可直接略过。一、概念行数据入口（Row Data Gateway）：充当数据源中单条记录入口的对象，每行一个实例。二、简单实现行数据入口为了方便理解，还是先简单实现： <?php /** * 行数据入口类 */ class OrderGateway { /*定义元数
Linux各个目录的作用及内容 pda158 linux 脚本
1）根目录“/” 　　根目录位于目录结构的最顶层，用斜线（/）表示，类似于 Windows 操作系统的“C:\“，包含Fedora操作系统中所有的目录和文件。　　2）/bin 　　/bin 　　目录又称为二进制目录，包含了那些供系统管理员和普通用户使用的重要 linux命令的二进制映像。该目录存放的内容包括各种可执行文件，还有某些可执行文件的符号连接。常用的命令有：cp、d
ubuntu12.04上编译openjdk7 ol_beta HotSpot jvm jdk OpenJDK
获取源码从openjdk代码仓库获取(比较慢) 安装mercurial Mercurial是一个版本管理工具。 sudo apt-get install mercurial 将以下内容添加到$HOME/.hgrc文件中，如果没有则自己创建一个： [extensions] forest=/home/lichengwu/hgforest-crew/forest.py fe
将数据库字段转换成设计文档所需的字段 vipbooks 设计模式工作正则表达式
哈哈，出差这么久终于回来了，回家的感觉真好！ PowerDesigner的物理数据库一出来，设计文档中要改的字段就多得不计其数，如果要把PowerDesigner中的字段一个个Copy到设计文档中，那将会是一件非常痛苦的事情。