tcomplex.cpp

编译类_Hss VC版_源代码支持表达式的编译执行,速度超快,支持实数和复数,并附带一个复数函数库你还可以同时找到VB和VC版和Delphi版

// TComplex.cpp: implementation of the TComplex class.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "TComplex.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif


//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

#include <complex>

//在VC文档中指出类的成员函数默认调用约定为thiscall,this指针放在ecx寄存器
#define _reg_this  ecx


Extended TComplex::radius() const
{
	Extended  result;
	__asm
	{
          fld	 _ExFloatPtr [_reg_this+_ExFloatByte]//	Z1.y
          fld	 _ExFloatPtr [_reg_this]//	Z1.x

          fmul    st,st(0)
          fxch    st(1)
          fmul    st,st(0)
          faddp   st(1),st
          fsqrt

          fstp _ExFloatPtr result
	}
	return  result;
}

Extended TComplex::angle() const
{
	Extended  result;
	__asm
	{
          fld	 _ExFloatPtr [_reg_this+_ExFloatByte]//	Z1.y
          fld	 _ExFloatPtr [_reg_this]//	Z1.x

		      fpatan

          fstp _ExFloatPtr result
	}
	return  result;
}

void  TComplex::FromPolar (const Extended & radius,const Extended & angle)
{
    __asm
    {
          mov   eax,[angle]
          fld   _ExFloatPtr [eax]
          fsincos
          mov   eax,[radius]
          fld   _ExFloatPtr [eax]
          fmul  st(2),st
          fmulp st(1),st

          fstp _ExFloatPtr [_reg_this]
          fstp _ExFloatPtr [_reg_this+_ExFloatByte]
    }
}

void  TComplex::ToPolar   (Extended * radius,Extended * angle)
{
    __asm
    {
        fld	 _ExFloatPtr  [_reg_this+_ExFloatByte] //  Z.y
        fld  _ExFloatPtr  [_reg_this] //  Z.x

          fld   st(1)
          fld   st(1)
          fpatan

          fxch  st(2)
          fmul  st,st(0)
          fxch  st(1)
          fmul  st,st(0)
          faddp st(1),st
          fsqrt

        fstp	_ExFloatPtr [radius]
        fstp	_ExFloatPtr [angle]
    }
}
/////////////////

  const double _tempHalf	 = 0.5 ;
  const double _tempHalfHalf = 0.25;

void    TComplex::Add     (const TComplex & x)
{
	__asm
	 {
        mov   eax,[x]
        fld  _ExFloatPtr [_reg_this]
        fld  _ExFloatPtr [eax]
        faddp st(1),st
        fld  _ExFloatPtr [_reg_this+_ExFloatByte]
        fld  _ExFloatPtr [eax+_ExFloatByte]
        faddp st(1),st
        fstp _ExFloatPtr [_reg_this+_ExFloatByte]
        fstp _ExFloatPtr [_reg_this]
   }
}

void    TComplex::Sub     (const TComplex & x)
{
	__asm
	 {
        mov   eax,[x]
        fld  _ExFloatPtr [_reg_this]
        fld  _ExFloatPtr [eax]
        fsubp st(1),st
        fld  _ExFloatPtr [_reg_this+_ExFloatByte]
        fld  _ExFloatPtr [eax+_ExFloatByte]
        fsubp st(1),st
        fstp _ExFloatPtr [_reg_this+_ExFloatByte]
        fstp _ExFloatPtr [_reg_this]
   }
}

void    TComplex::Mul     (const TComplex & x)
{
  __asm
  {
    mov  eax,[x]
		fld	 _ExFloatPtr [eax+_ExFloatByte]//	Z2.y
		fld	 _ExFloatPtr [eax]//	Z2.x
		fld	 _ExFloatPtr [_reg_this+_ExFloatByte]//	Z1.y
		fld	 _ExFloatPtr [_reg_this]//	Z1.x

          fld     st(3)
          fmul    st,st(1)
          fld     st(2)
          fmul    st,st(4)
          faddp   st(1),st

          fxch    st(3)
          fmulp   st(1),st
          fxch    st(3)
          fmulp   st(1),st
          fsubp   st(2),st
          fxch    st(1)

		fstp _ExFloatPtr [_reg_this]//	result.x
		fstp _ExFloatPtr [_reg_this+_ExFloatByte]//	result.y
  }
}
void    TComplex::Div     (const TComplex & x)
{
  __asm
  {
    mov  eax,[x]
 		fld	 _ExFloatPtr [eax+_ExFloatByte]//	Z2.y
		fld	 _ExFloatPtr [eax]//	Z2.x
		fld	 _ExFloatPtr [_reg_this+_ExFloatByte]//	Z1.y
		fld	 _ExFloatPtr [_reg_this]//	Z1.x

          fld     st(2)
          fmul    st,st(0)
          fld     st(4)
          fmul    st,st(0)
          faddp   st(1),st

          fld1
          fdivrp  st(1),st      

          fld     st(3)         
          fmul    st,st(3)
          fld     st(5)
          fmul    st,st(3)
          fsubp   st(1),st
          fmul    st,st(1)

          fxch    st(4)
          fmulp   st(2),st
          fxch    st(4)
          fmulp   st(2),st
          faddp   st(1),st
          fmulp   st(2),st
          fxch    st(1)

		fstp _ExFloatPtr [_reg_this]//	result.x
		fstp _ExFloatPtr [_reg_this+_ExFloatByte]//	result.y
  }
}

void  TComplex::Chs   ()
{
	__asm
	 {
       fld _ExFloatPtr [_reg_this]
       fchs
       fld _ExFloatPtr [_reg_this+_ExFloatByte]
       fchs
       fstp _ExFloatPtr [_reg_this+_ExFloatByte]
       fstp _ExFloatPtr [_reg_this]
   }
}

//复数绝对值、取整、距离函数

void  TComplex::Abs    () 							//Z=|Z|  绝对值
{
	__asm
	{
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]

          fmul    st,st(0)
          fxch    st(1)
          fmul    st,st(0)
          faddp   st(1),st
          fsqrt

	 fstp _ExFloatPtr [_reg_this]
   xor    eax,eax
   mov    [_reg_this+_ExFloatByte],eax
   mov    [_reg_this+(_ExFloatByte+4)],eax
   mov    [_reg_this+(_ExFloatByte+8)],ax
	}
}

void  TComplex::AbsSqr () 							//Z=|Z|^2
{
	__asm
	{
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]

       fmul  st,st(0)
       fxch  st(1)
       fmul  st,st(0)
       faddp st(1),st

	 fstp _ExFloatPtr [_reg_this]
   xor    eax,eax
   mov    [_reg_this+_ExFloatByte],eax
   mov    [_reg_this+(_ExFloatByte+4)],eax
   mov    [_reg_this+(_ExFloatByte+8)],ax
	}
}

void  TComplex::AbsA   () 							//Z._Re=abs(Z._Re);Z._Im=abs(Z._Im)
{
	this->_Re.Abs();
	this->_Im.Abs();
}

void  TComplex::Distance(const TComplex& x)				//Z._Re=|Z-x|,Z._Im=0
{
	__asm
	{
   mov  eax,[x]
	 fld _ExFloatPtr [eax+_ExFloatByte]
	 fld _ExFloatPtr [eax]
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]

            fsubp     st(2),st
            fsubp     st(2),st
            fmul      st,st(0)

            fxch      st(1)
            fmul      st,st(0)
            
            faddp     st(1),st
            fsqrt

	 fstp _ExFloatPtr [_reg_this]
   xor    eax,eax
   mov    [_reg_this+_ExFloatByte],eax
   mov    [_reg_this+(_ExFloatByte+4)],eax
   mov    [_reg_this+(_ExFloatByte+8)],ax
	}
}	

void  TComplex::Floor  () 							//Z=Floor(Z)    //取整，小于x的最大整数
{
  WORD x0,x1;
	__asm
	{
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]


		FNSTCW  Word ptr x0           // 保存协处理器控制字,用来恢复
		FNSTCW  Word ptr x1         // 保存协处理器控制字,用来修改
		FWAIT
		OR      Word ptr x1, 0700H  // 使RC场向负无穷大取整    //必须保证 RC=00  然后改为 RC=01
		FLDCW   Word ptr x1         // 载入协处理器控制字,RC场已经修改
		FRNDINT
		fxch	st(1)
		FRNDINT
		fxch	st(1)
		FWAIT
		FLDCW   Word ptr x0           // 恢复协处理器控制字


		fstp _ExFloatPtr	[_reg_this]
		fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}

void  TComplex::Ceil   () 							//Z=Ceil(Z)     //取整，大于x的最小整数
{
  WORD x0,x1;
	__asm
	{
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]

		FNSTCW  Word ptr x0           // 保存协处理器控制字,用来恢复
		FNSTCW  Word ptr x1         // 保存协处理器控制字,用来修改
		FWAIT
		OR      Word ptr x1, 0B00H  // 使RC场向负无穷大取整    //必须保证 RC=00  然后改为 RC=10
		FLDCW   Word ptr x1         // 载入协处理器控制字,RC场已经修改
		FRNDINT
		fxch	st(1)
		FRNDINT
		fxch	st(1)
		FWAIT
		FLDCW   Word ptr x0           // 恢复协处理器控制字


		fstp _ExFloatPtr	[_reg_this]
		fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}

void  TComplex::Trunc  ()							//Z=Trunc(Z)    //向零取整，即截断
{
  WORD x0,x1;
	__asm
	{
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]

		FNSTCW  Word ptr x0           // 保存协处理器控制字,用来恢复
		FNSTCW  Word ptr x1         // 保存协处理器控制字,用来修改
		FWAIT
		OR      Word ptr x1, 0f00H  // 使RC场向零取整     改为 RC=11
		FLDCW   Word ptr x1         // 载入协处理器控制字,RC场已经修改
		FRNDINT
		fxch	st(1)
		FRNDINT
		fxch	st(1)
		FWAIT
		FLDCW   Word ptr x0           // 恢复协处理器控制字

		fstp _ExFloatPtr	[_reg_this]
		fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}

void  TComplex::Round  () 							//Z=Round(Z)    //四舍五入到整数
{

	__asm
	{
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]

		FRNDINT
		fxch	st(1)
		FRNDINT
		fxch	st(1)

		fstp _ExFloatPtr	[_reg_this]
		fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}

//得零、单位虚数、归一化、共轭、虚实交换、倒数 、求符号


void  TComplex::Zero  ()                                       //Z=0   //得零
{
  __asm
  {
   xor    eax,eax
   mov    [_reg_this],eax
   mov    [_reg_this+4],eax
   mov    [_reg_this+8],ax
   mov    [_reg_this+_ExFloatByte],eax
   mov    [_reg_this+(_ExFloatByte+4)],eax
   mov    [_reg_this+(_ExFloatByte+8)],ax
  }
}

void  TComplex::Imag1 ()                                       //Z._Im=1,Z._Re=0
{
  __asm
  {
   xor    eax,eax
   mov    [_reg_this],eax
   mov    [_reg_this+4],eax
   mov    [_reg_this+8],ax
   fld1
   fstp _ExFloatPtr [_reg_this+_ExFloatByte]
  }
}

void  TComplex::Unity () 							//Z=Z/|Z|    //归一化
{
	__asm
	{
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]

          fld     st(0)
          fmul    st,st(0)
          fld     st(2)
          fmul    st,st(0)
          faddp   st(1),st
          fsqrt

          fld1
          fdivrp  st(1),st

          fmul    st(1),st
          fmulp   st(2),st

		fstp _ExFloatPtr	[_reg_this]
		fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}

void  TComplex::Conj  () 							//Z._Re=Z._Re; Z._Im=-Z._Im  //共轭
{
	this->_Im.Chs();
}

void  TComplex::Flip  () 							//Z._Re=Z._Im; Z._Im=Z._Re      //虚实交换
{
	__asm
	{
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]
    fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
    fstp _ExFloatPtr	[_reg_this]
	}
}

void  TComplex::Rev   () 							//Z=1/Z       //倒数
{
	__asm
	{
	 fld _ExFloatPtr [_reg_this+_ExFloatByte]
	 fld _ExFloatPtr [_reg_this]

          fld     st(0)
          fmul    st,st(0)
          fld     st(2)
          fmul    st,st(0)
          faddp   st(1),st

          fld1
          fdivrp  st(1),st

          fmul    st(1),st
          fchs
          fmulp   st(2),st

    fstp _ExFloatPtr	[_reg_this]
    fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}	
			
void  TComplex::Sgn   ()							//Z=Sgn(Z)      //求符号
{
	this->_Re.Sgn();
	this->_Im.Sgn();
}

void  TComplex::Xchg  (TComplex *x)			//Z<=>x)   //交换值
{
//	TComplex  r(*x);
//	*x=*this;
//	*this=r;
    __asm
    {
        mov   eax,[x]
        fld  _ExFloatPtr [_reg_this]
        fld  _ExFloatPtr [_reg_this+_ExFloatByte]
        fld  _ExFloatPtr [eax]
        fld  _ExFloatPtr [eax+_ExFloatByte]
        fstp _ExFloatPtr [_reg_this+_ExFloatByte]
        fstp _ExFloatPtr [_reg_this]
        fstp _ExFloatPtr [eax+_ExFloatByte]
        fstp _ExFloatPtr [eax]
    }
}

//复数次方
void  TComplex::Sqr   () 							//Z=Z*Z   //平方
{
	__asm
	{
	    fld _ExFloatPtr [_reg_this+_ExFloatByte]
	    fld _ExFloatPtr [_reg_this]

        fld     st(1)
        fadd    st,st(1)
        fld     st(1)
        fsub    st,st(3)
        fmulp   st(1),st

        fxch    st(2)
        fmulp   st(1),st
        fadd    st,st(0)
        fxch    st(1)

      fstp _ExFloatPtr	[_reg_this]
      fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}

void  TComplex::Sqr3  () 							//Z=Z^3    //立方
{
	__asm
	{
	    fld _ExFloatPtr [_reg_this+_ExFloatByte]
	    fld _ExFloatPtr [_reg_this]

          fld     st(0)
          fmul    st,st(0)
          fld     st(2)
          fmul    st,st(0)

          fld     st(0)
          fadd    st,st(1)
          fadd    st,st(1)
          fsubr   st,st(2)
          fmulp   st(3),st

          fld     st(1)
          fadd    st,st(0)
          faddp   st(2),st
          fsubp   st(1),st
          fmulp   st(2),st

      fstp _ExFloatPtr	[_reg_this]
      fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}

void  TComplex::Sqr4  () 							//Z=Z^4    //四次方
{
	__asm
	{
	    fld _ExFloatPtr [_reg_this+_ExFloatByte]
	    fld _ExFloatPtr [_reg_this]

          fld     st(0)
          fsub    st,st(2)
          fld     st(1)
          fadd    st,st(3)
          fmulp   st(1),st

          fxch    st(2)
          fmulp   st(1),st
          fadd    st,st(0)
          fxch    st(1)


          fld     st(0)
          fsub    st,st(2)
          fld     st(1)
          fadd    st,st(3)
          fmulp   st(1),st

          fxch    st(2)
          fmulp   st(1),st
          fadd    st,st(0)
          fxch    st(1)

      fstp _ExFloatPtr	[_reg_this]
      fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}

void  TComplex::Power (const TComplex& x)		//Z=Z^x
{
  __asm
  {
      mov   eax,[x]
      fld	 _ExFloatPtr [eax+_ExFloatByte]
      fld	 _ExFloatPtr [eax]
	    fld  _ExFloatPtr [_reg_this+_ExFloatByte]
	    fld  _ExFloatPtr [_reg_this]

        fld     st(0)
        fmul    st,st(0)
        fld     st(2)
        fmul    st,st(0)
        faddp   st(1),st

        fldln2
        fxch    st(1)
        fyl2x

        fld     _tempHalf
        fmulp    st(1),st           //   fdivp   st(1),st

        fxch    st(2)
        fxch    st(1)
        fpatan


        fld     st(0)
        fmul    st,st(3)
        fxch    st(1)
        fmul    st,st(4)

        fxch    st(2)
        fmul    st(3),st
        fmulp   st(4),st

        faddp   st(3),st
        fsubp   st(1),st

        //Exp()
        FLDL2E          
        FMULp   st(1),st
        FLD  ST(0)
        FRNDINT         
        FSUB  ST(1), ST 
        FXCH  ST(1)     
        F2XM1
        FLD1
        FADDp   st(1),st
        FSCALE          
        FSTP    ST(1)

        fxch     st(1)
        fsincos
        fmul     st,st(2)
        fxch     st(1)
        fmulp    st(2),st

      fstp _ExFloatPtr	[_reg_this]
      fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
  }
}

void  TComplex::Exp   ()                           //Z=Exp(Z) //e^Z
{
	__asm
	{
	    fld  _ExFloatPtr [_reg_this+_ExFloatByte]
	    fld  _ExFloatPtr [_reg_this]

		FLDL2E
		FMULp   st(1),st
		FLD  ST(0)
		FRNDINT          
		FSUB  ST(1), ST  
		FXCH  ST(1)      
		F2XM1
		FLD1
		FADDp   st(1),st
		FSCALE           
		FSTP    ST(1)

		fxch     st(1)
		fsincos
		fmul     st,st(2)
		fxch     st(1)
		fmulp    st(2),st

      fstp _ExFloatPtr	[_reg_this]
      fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
	}
}

void  TComplex::Sqrt  ()					//Z=Sqrt(Z) //Z^0.5
{
	__asm
	{
	    fld  _ExFloatPtr [_reg_this+_ExFloatByte]
	    fld  _ExFloatPtr [_reg_this]

         fld      st(1)
         fld      st(1)
         fpatan

         Fld      _tempHalf
         fmulp    st(1),st           //   fdivp   st(1),st

         fsincos

         fxch     st(2)
         fmul     st,st(0)
         fxch     st(3)
         fmul     st,st(0)
         faddp    st(3),st

         fxch     st(2)
         fsqrt
         fsqrt
         fmul     st(2),st
         fmulp    st(1),st

      fstp _ExFloatPtr	[_reg_this]
      fstp _ExFloatPtr	[_reg_this+_ExFloatByte]
  }
}