complex_hss.pas

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

function  C_add (const Z1:TComplex;const x:CmxFloat):TComplex;{Z:=Z1+x}
begin
    result.x := Z1.x+x ;
    result.y := Z1.y;
end;

Procedure C_addV(var Z1: TComplex; const Z2: TComplex);{Z1:=Z1+Z2}
Begin
    Z1.x:=Z1.x+Z2.x;
    Z1.y:=Z1.y+Z2.y;
End;

Procedure C_addV (var Z1:TComplex;const x:CmxFloat); {Z1:=Z1+x}
begin
    Z1.x:=Z1.x+X;
    //Z1.y:=Z1.y;
End;

function C_sub (const Z1:TComplex;const Z2:TComplex):TComplex;{Z:=Z1-z2}
begin
    result.x := Z1.x - Z2.x ;
    result.y := Z1.y - Z2.y ;
end;

function C_sub (const Z1:TComplex;const x:CmxFloat):TComplex;{Z:=Z1-x}
begin
    result.x := Z1.x - x ;
    result.y := Z1.y ;
end;
Procedure C_subV(var Z1: TComplex; const Z2: TComplex);   {Z1:=Z1-Z2}
Begin
    Z1.x:=Z1.x-Z2.x;
    Z1.y:=Z1.y-Z2.y;
End;

Procedure C_subV (var Z1:TComplex;const x:CmxFloat); {Z1:=Z1-x}
begin
    Z1.x := Z1.x - x ;
    //Z1.y := Z1.y ;
end;

//==============================================================================
{复数函数_乘除}
Function  C_Mul (const Z1: TComplex; const Z2: TComplex): TComplex; register;assembler{Z:=Z1*Z2}
{Begin
    result.x:=Z1.x*Z2.x - Z1.y*Z2.y;
    result.y:=Z1.x*Z2.y + Z1.y*Z2.x; }
asm
    //eax : Z1 , edx : Z2 , ecx : Result
    
		fld	 CmxFloat [edx+FloatByte]//	Z2.y
		fld	 CmxFloat [edx]//	Z2.x
		fld	 CmxFloat [eax+FloatByte]//	Z1.y
		fld	 CmxFloat [eax]//	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 CmxFloat [ecx]//	result.x
		fstp CmxFloat [ecx+FloatByte]//	result.y

End;

Function  C_Mul (const Z1: TComplex;const x: CmxFloat): TComplex; {Z:=Z1*x}
Begin
    result.x:=Z1.x*X ;
    result.y:=Z1.y*X;
End;

Procedure C_MulV(var Z1: TComplex; const Z2: TComplex);register;assembler {Z1:=Z1*Z2}
{var tmp: CmxFloat;
Begin
    tmp :=Z1.x*Z2.x - Z1.y*Z2.y;
    Z1.y:=Z1.x*Z2.y + Z1.y*Z2.x;
    Z1.x:=tmp;}
asm
    //eax : Z1 , edx : Z2

		fld	 CmxFloat [edx+FloatByte]//	Z2.y
		fld	 CmxFloat [edx]//	Z2.x
		fld	 CmxFloat [eax+FloatByte]//	Z1.y
		fld	 CmxFloat [eax]//	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 CmxFloat [eax]//	Z1.x
		fstp CmxFloat [eax+FloatByte]//	Z1.y


End;

Procedure C_MulV(var Z1: TComplex;const x: CmxFloat); {Z1:=Z1*x}
var tmp: CmxFloat;
Begin
    tmp :=Z1.x*X ;
    Z1.y:=Z1.y*X;
    Z1.x:=tmp;
End;

Function  C_Div (const Z1: TComplex;const Z2: TComplex): TComplex; {Z:=Z1/Z2}
var tmp: CmxFloat;
Begin
    tmp:= 1.0/(sqr(Z2.x) + sqr(Z2.y) + SmallLimit);
    result.x:=(Z1.x*Z2.x + Z1.y*Z2.y)*tmp;
    result.y:=(Z1.y*Z2.x - Z1.x*Z2.y)*tmp;
End;

Function  C_Div(const Z1: TComplex;const x: CmxFloat): TComplex; {Z:=Z1/x}
var
  invx :CmxFloat;
Begin
    if x<>0 then
    begin
        invx:=1.0/x;
        result.x:=Z1.x*invx;
        result.y:=Z1.y*invx;
    end
    else
    begin          
        result.x:=Z1.x*LargeLimit;
        result.y:=Z1.y*LargeLimit;
    end;
End;

Procedure C_DivV(var Z1: TComplex; const Z2: TComplex); {Z1:=Z1/Z2}
var tmp1: CmxFloat;
    tmp2: CmxFloat;
Begin
    tmp1 := 1.0/(sqr(Z2.x) + sqr(Z2.y) + SmallLimit) ;
    tmp2 :=(Z1.x*Z2.x + Z1.y*Z2.y)*tmp1;
    Z1.y :=(Z1.y*Z2.x - Z1.x*Z2.y)*tmp1;
    Z1.x := tmp2;
End;

Procedure  C_DivV(var Z1: TComplex; const x: CmxFloat); {Z1:=Z1/x}
var
  invx :CmxFloat;
Begin
    if x<>0 then
    begin
        invx:=1.0/x;
        Z1.x:=Z1.x*invx;
        Z1.y:=Z1.y*invx;
    end
    else
    begin          
        Z1.x:=Z1.x*LargeLimit;
        Z1.y:=Z1.y*LargeLimit;
    end;
End;

//==============================================================================
{复数绝对值、取整、距离函数}
Function C_Abs (const Z1: TComplex): TComplex; {Z:=|Z1|}  {绝对值}
Begin
    result.x:=sqrt( sqr(Z1.x)+sqr(Z1.y) );
    result.y:=0;
End;

Procedure C_AbsV(var Z1: TComplex); {Z1:=|Z1|}
Begin
    Z1.x:=sqrt( sqr(Z1.x)+sqr(Z1.y) );
    Z1.y:=0;
End;

function  C_AbsSqr (const Z:TComplex):TComplex;
begin
  result.x:=sqr(Z.x)+sqr(Z.y);
  result.y:=0;
end;

Procedure  C_AbsSqrV (var Z:TComplex);
begin
  Z.x:=sqr(Z.x)+sqr(Z.y);
  Z.y:=0;
end;

Function C_AbsA (const Z1: TComplex): TComplex; {Z:=absA(Z1)}
Begin
    result.x:=Abs(Z1.x);
    result.y:=Abs(Z1.y);
End;

Procedure C_AbsAV(var Z1: TComplex); {Z1:=absA(Z1)}
Begin
    Z1.x:=Abs(Z1.x);
    Z1.y:=Abs(Z1.y);
End;

Function C_Floor (const Z1: TComplex): TComplex; {Z:=Floor(Z1)}  {取整，小于x的最大整数}
Begin
    With Z1 do
    begin
        result.x:=Floor(X);
        result.y:=Floor(Y);
    end;
End;

Procedure C_FloorV(var Z1: TComplex); {Z1:=Floor(Z1)}
Begin
    With Z1 do
    begin
        X:=Floor(X);
        Y:=Floor(Y);
    end;
End;

Function C_Ceil (const Z1: TComplex): TComplex; {Z:=Ceil(Z1)}  {取整，大于x的最小整数}
Begin
    With Z1 do
    begin
        result.x:=Ceil(X);
        result.y:=Ceil(Y);
    end;
End;

Procedure C_CeilV(var Z1: TComplex); {Z1:=Ceil(Z1)}
Begin
    With Z1 do
    begin
        X:=Ceil(X);
        Y:=Ceil(Y);
    end;
End;

Function C_Trunc (const Z1: TComplex): TComplex; {Z:=Trunc(Z1)} {向零取整，即截断}
Begin
    With Z1 do
    begin
        result.x:=Trunc(X);
        result.y:=Trunc(Y);
    end;
End;

Procedure C_TruncV(var Z1: TComplex); {Z1:=Trunc(Z1)}
Begin
    With Z1 do
    begin
        X:=Trunc(X);
        Y:=Trunc(Y);
    end;
End;

Function C_Round (const Z1: TComplex): TComplex; {Z:=Round(Z1)} {四舍五入到整数}
Begin
    With Z1 do
    begin
        result.x:=Round(X);
        result.y:=Round(Y);
    end;
End;

Procedure C_RoundV(var Z1: TComplex); {Z1:=Round(Z1)}
Begin
    With Z1 do
    begin
        X:=Round(X);
        Y:=Round(Y);
    end;
End;

function  C_Distance(const Z1:TComplex;const Z2: TComplex):TComplex;overload;{Z.x:=|Z1-Z2|,Z.y:=0}
begin
    result.x:=sqrt( sqr(Z1.x-Z2.x)+sqr(Z1.y-Z2.y) );
    result.y:=0;
end;

Procedure C_DistanceV(var Z1:TComplex;const Z2: TComplex);overload;{Z1.x:=|Z1-Z2|,Z1.y:=0}
begin
    Z1.x:=sqrt( sqr(Z1.x-Z2.x)+sqr(Z1.y-Z2.y) );
    Z1.y:=0;
end;


Function  C_IsEqual(const Z1,Z2: TComplex):boolean;
begin
  result:= (Z1.x=Z2.x) and (Z1.y=Z2.y);
end;

Function  C_IsEqual(const Z1,Z2: TComplex;const Error:CmxFloat=0):boolean;
begin
  result:= (abs(Z1.x-Z2.x)+abs(Z1.y-Z2.y))<=abs(Error);
end;

Function  C_IsImag (const Z1: TComplex ):boolean;
begin
  if Z1.x=0 then
    result:=true
  else
    result:=false;
end;

Function  C_IsImag (const Z1: TComplex;const Error:CmxFloat=0):boolean;
begin
  if abs(Z1.x)<=abs(Error) then
    result:=true
  else
    result:=false;
end;


Function  C_IsZero (const Z1: TComplex ):boolean;Overload;                       {是否是零}
begin
  if (Z1.x=0) and (Z1.y=0) then
    result:=true
  else
    result:=false;
end;

Function  C_IsZero (const Z1: TComplex;const Error:CmxFloat=0):boolean;Overload; {是否是零}                      {是否是纯虚数}
begin
  if (abs(Z1.x)+abs(Z1.y))<=abs(Error) then
    result:=true
  else
    result:=false;
end;


//==============================================================================
{得零、单位虚数、归一化、共轭、虚实交换、倒数 、求符号、交换值}
Function C_Zero():TComplex; {Z:=0}
Begin
    result.x:=0;
    result.y:=0;
End;

Procedure C_ZeroV(var Z1: TComplex); {Z1:=0}
Begin
    Z1.x:=0;
    Z1.y:=0;
End;

Function  C_Imag1  ():TComplex; {Z.y:=1,Z.x:=0}
begin
    result.x:=0;
    result.y:=1;
end;

Procedure C_Imag1V (var Z1: TComplex); {Z1.y:=1,Z1.x:=0}
begin
    Z1.x:=0;
    Z1.y:=1;
end;

Function  C_Unity (const Z1: TComplex): TComplex; {归一化 Z:=Z1/|Z1|}
var tmp:CmxFloat;
begin
    tmp:= 1/sqrt(sqr(Z1.x) + sqr(Z1.y)+ SmallLimit) ;
    result.x:=Z1.x*tmp;
    result.y:=Z1.y*tmp;
end;

Procedure C_UnityV(var Z1: TComplex); {归一化 Z1:=Z1/|Z1|}
var tmp:CmxFloat;
begin
    tmp:= 1/sqrt(sqr(Z1.x)+ sqr(Z1.y) + SmallLimit) ;
    Z1.x:=Z1.x*tmp;
    Z1.y:=Z1.y*tmp;
end;

Function C_Conj (const Z1: TComplex): TComplex; {Z.x:=Z1.x; Z.y:=-Z1.y}
Begin
    result.x:= Z1.x;
    result.y:=-Z1.y;
End;

Procedure C_ConjV(var Z1: TComplex); {Z1.y:=-Z1.y}
Begin
    //Z1.x:=Z1.x;
    Z1.y:=-Z1.y;
End;

Function  C_Flip (const Z1: TComplex): TComplex; {Z.x:=Z1.y; Z.y:=Z1.x}
Begin
    result.x:=Z1.y;
    result.y:=Z1.x;
End;

Procedure C_FlipV(var Z1: TComplex); {Z1.x:=Z1.y; Z1.y:=Z1.x}
var tmp: CmxFloat;
Begin
    tmp :=Z1.x;
    Z1.x:=Z1.y;
    Z1.y:=tmp;
End;

Function  C_Rev (const Z1: TComplex): TComplex; {Z:=1/Z1}
var tmp: CmxFloat;
Begin