📄 complex_hss.pas
字号:
unit Complex_Hss;
/////////////////////////////////////////////////////////
// //
// 复数函数库 作者：侯思松 2001.12-2002.11 //
// //
// 有改进意见或发现任何错误请转告我，本人不胜感激 //
// E-Mail：HouSisong@263.net //
// ( 转载时请保留本说明:) ) //
// //
/////////////////////////////////////////////////////////
interface
uses SysUtils;
//更新列表
{
2003.3.29 错误更正：C_Power ，Error!!! sqr(sqr(Z1.y)) => sqr(Z1.y);
2003.3.29 保证复数精度 设置为 Cmx_Extended 扩展精度 时，不论系统的边界对齐方式设置怎样，
复数类型TComplex都占用32字节
}
//////////////////////////////////////////////////////////////////////////////
//定义运算中使用的浮点数精度,请按使用要求设置
// 可选择的标志：Cmx_Extended 扩展精度,Cmx_Double 双精度,Cmx_Single 单精度
{$DEFINE Cmx_Extended} //默认运算中使用扩展精度Extended浮点数
// 如果一定要同时使用不同的精度，请复制文件并修改精度标志
//////////////////////////////////////////////////////////////////////////////
{$IFDEF Cmx_Extended}
type CmxFloat=Extended; //扩展精度
const FloatByte = 16; //Extended实际使用为10Byte，但为了数据8字节对齐，所以这里为16
{$ENDIF}
{$IFDEF Cmx_Double}
type CmxFloat=Double; //双精度
const FloatByte = 8;
{$ENDIF}
{$IFDEF Cmx_Single}
type CmxFloat=Single; //单精度
const FloatByte = 4;
{$ENDIF}
{定义复数类型}
{$IFDEF Cmx_Extended}
{$ALIGN 8}
{$ENDIF}
type TComplex=record {复数类型}
x : CmxFloat; {实部}
y : CmxFloat; {虚部}
end;
type PTComplex=^TComplex;
type
PTComplexArray = ^TTComplexArray;
TTComplexArray = array[0..32767] of TComplex;
//============================================================================
{定义函数}
{
函数名称规范: "C_" 为前缀，表示复数 ；"V" 为后缀，表示迅速(不一定速度快);
一般情况下： x,y表示实数,s表示字符串，N表示整数;
复数Z1,Z2表示函数的参数，复数Z表示函数返回值;
参数Error表示误差,参数K表示求复数角度时加上"2*K*PI",
tmp*表示临时变量. }
{复数转换函数}
Function CreateTComplex (const x:CmxFloat;const y:CmxFloat):TComplex;overload; {Z:=x+y*i}
Function CreateTComplex (const x:CmxFloat):TComplex;overload; {Z:=x+0*i}
Function CreateTComplexR (const R:CmxFloat;const Arg:CmxFloat):TComplex; {Z:=r*e^(Arg*i)}
function GetTComplex_R (const Z1:TComplex):CmxFloat; {R:=|Z1|=(Z1.x*Z1.x+Z1.y*Z1.y)^0.5}
Procedure GetTComplex_RV (var Z1:TComplex); {Z1.x:=|Z1|,Z1.y:=0}
function GetTComplex_Arg (const Z1:TComplex):CmxFloat; {Arg:=Arctg(Z.y/Z.x),(-PI~PI)}
Procedure GetTComplex_ArgV(var Z1:TComplex); {Arg:=Arctg(Z.y/Z.x)}
function TComplexToStr (const Z1:TComplex):string; {TComplex => string , ( Str:='x+y*i' (简略) 默认 }
function TComplexToStri (const Z1:TComplex):string; {TComplex => string , ( Str:='x+y*i' ) }
function TComplexToStrBK (const Z1:TComplex):string; {TComplex => string , ( Str:='(x,y)' }
Function StrToTComplex (const Str:string;var Value:TComplex):boolean; {string => TComplex , ( Str:='x+y*i') 严格的语法格式检查 默认 }
function StrToTComplexi (const Str:string):TComplex; {string => TComplex , ( Str:='(x,y)' or Str:='x+y*i') }
function TComplexX (const x:CmxFloat):TComplex; {CmxFloat => TComplex,Z.x:=x,Z.y:=0}
function TComplexY (const y:CmxFloat):TComplex; {CmxFloat => TComplex,Z.y:=y,Z.x:=0}
function C_FromPolar (const Z:TComplex):TComplex; {极坐标到复数}
Procedure C_FromPolarV (var Z:TComplex); {极坐标到复数}
function C_ToPolar (const Z:TComplex):TComplex; {复数到极坐标}
Procedure C_ToPolarV (var Z:TComplex); {复数到极坐标}
{复数函数_加减}
function C_Add (const Z1:TComplex;const Z2:TComplex):TComplex;overload; {Z:=Z1+Z2}
Procedure C_AddV (var Z1:TComplex;const Z2:TComplex);overload; {Z1:=Z1+Z2}
function C_Add (const Z1:TComplex;const x:CmxFloat):TComplex;overload; {Z:=Z1+x}
Procedure C_AddV (var Z1:TComplex;const x:CmxFloat);overload; {Z1:=Z1+x}
function C_Sub (const Z1:TComplex;const Z2:TComplex):TComplex;overload; {Z:=Z1-Z2}
Procedure C_SubV (var Z1: TComplex; const Z2:TComplex);overload; {Z1:=Z1-Z2}
function C_Sub (const Z1:TComplex;const x:CmxFloat):TComplex;overload; {Z:=Z1-x}
Procedure C_SubV (var Z1: TComplex; const x:CmxFloat);overload; {Z1:=Z1-x}
{复数函数_乘除}
Function C_Mul (const Z1:TComplex;const Z2: TComplex): TComplex;overload; {Z:=Z1*Z2}
Procedure C_MulV (var Z1: TComplex; const Z2: TComplex);overload; {Z1:=Z1*Z2}
Function C_Mul (const Z1: TComplex;const x: CmxFloat): TComplex;overload; {Z:=Z1*x}
Procedure C_MulV (var Z1: TComplex; const x: CmxFloat);overload; {Z1:=Z1*x}
Function C_Div (const Z1: TComplex;const Z2:TComplex): TComplex;overload; {Z:=Z1/Z2}
Procedure C_DivV (var Z1: TComplex; const Z2: TComplex);overload; {Z1:=Z1/Z2}
Function C_Div (const Z1: TComplex;const x: CmxFloat): TComplex;overload; {Z:=Z1/x}
Procedure C_DivV (var Z1: TComplex; const x: CmxFloat);overload; {Z1:=Z1/x}
{复数绝对值、取整、距离函数}
Function C_Abs (const Z1: TComplex): TComplex; {Z:=|Z1| 绝对值}
Procedure C_AbsV (var Z1: TComplex); {Z1:=|Z1|}
function C_AbsSqr (const Z:TComplex):TComplex; {Z:=|Z1|^2}
Procedure C_AbsSqrV (var Z:TComplex); {Z1:=|Z1|^2}
Function C_AbsA (const Z1: TComplex): TComplex; {Z.x:=abs(Z1.x);Z.y:=abs(Z1.y)}
Procedure C_AbsAV (var Z1: TComplex); {Z1.x:=abs(Z1.x);Z1.y:=abs(Z1.y)}
function C_Distance (const Z1:TComplex;const Z2: TComplex):TComplex;overload; {Z.x:=|Z1-Z2|,Z.y:=0}
Procedure C_DistanceV (var Z1:TComplex;const Z2: TComplex);overload; {Z1.x:=|Z1-Z2|,Z1.y:=0}
Function C_Floor (const Z1: TComplex): TComplex; {Z:=Floor(Z1)} {取整，小于x的最大整数}
Procedure C_FloorV (var Z1: TComplex); {Z1:=Floor(Z1)} {取整，小于x的最大整数}
Function C_Ceil (const Z1: TComplex): TComplex; {Z:=Ceil(Z1)} {取整，大于x的最小整数}
Procedure C_CeilV (var Z1: TComplex); {Z1:=Ceil(Z1)} {取整，大于x的最小整数}
Function C_Trunc (const Z1: TComplex): TComplex; {Z:=Trunc(Z1)} {向零取整，即截断}
Procedure C_TruncV (var Z1: TComplex); {Z1:=Trunc(Z1)} {向零取整，即截断}
Function C_Round (const Z1: TComplex): TComplex; {Z:=Round(Z1)} {四舍五入到整数}
Procedure C_RoundV (var Z1: TComplex); {Z1:=Round(Z1)} {四舍五入到整数}
Function C_IsEqual (const Z1,Z2: TComplex):boolean;Overload; {是否相等}
Function C_IsEqual (const Z1,Z2:TComplex;const Error:CmxFloat=0):boolean;Overload; {是否相等}
Function C_IsImag (const Z1: TComplex ):boolean;Overload; {是否是纯虚数}
Function C_IsImag (const Z1: TComplex;const Error:CmxFloat=0):boolean;Overload; {是否是纯虚数} {是否是纯虚数}
Function C_IsZero (const Z1: TComplex ):boolean;Overload; {是否是零}
Function C_IsZero (const Z1: TComplex;const Error:CmxFloat=0):boolean;Overload; {是否是零} {是否是纯虚数}
{得零、单位虚数、归一化、共轭、虚实交换、倒数 、求符号、交换值}
Function C_Zero ():TComplex; {Z:=0} {得零}
Procedure C_ZeroV (var Z1: TComplex); {Z1:=0} {得零}
Function C_Imag1 ():TComplex; {Z.y:=1,Z.x:=0} {得1}
Procedure C_Imag1V (var Z1: TComplex); {Z1.y:=1,Z1.x:=0} {得1}
Function C_Unity (const Z1: TComplex): TComplex; {Z:=Z1/|Z1|} {归一化 }
Procedure C_UnityV (var Z1: TComplex); {Z1:=Z1/|Z1|} {归一化 }
Function C_Conj (const Z1: TComplex): TComplex; {Z.x:=Z1.x; Z.y:=-Z1.y} {共轭}
Procedure C_ConjV (var Z1: TComplex); {Z1.y:=-Z1.y} {共轭}
Function C_Flip (const Z1: TComplex): TComplex; {Z.x:=Z1.y; Z.y:=Z1.x} {虚实交换}
Procedure C_FlipV (var Z1: TComplex); {Z1.x:=Z1.y; Z1.y:=Z1.x} {虚实交换}
Function C_Rev (const Z1: TComplex): TComplex; {Z:=1/Z1} {倒数}
Procedure C_RevV (var Z1: TComplex); {Z1:=1/Z1} {倒数}
Function C_Chs (const Z1: TComplex): TComplex; {Z:=-Z1} {求负}
Procedure C_ChsV (var Z1: TComplex); {Z1:=-Z1} {求负}
Function C_Rev2 (const Z1: TComplex;const Z2: TComplex): TComplex; {Z:=1/(Z1-Z2)} {倒数}
Procedure C_Rev2V (var Z1: TComplex; const Z2: TComplex); {Z1:=1/(Z1-Z2)} {倒数}
function C_Sgn (const Z1: TComplex):TComplex; {Z:=Sgn(Z1)} {求符号}
Procedure C_SgnV (var Z1: TComplex); {Z1:=Sgn(Z1)} {求符号}
Procedure C_Xchg (var Z1: TComplex;var Z2: TComplex);Overload; {Z1<=>Z2)} {交换值}
Procedure C_Xchg (var Z1: TComplex);Overload; {Z1.x<=>Z1.y)} {交换值}
function C_Max (const Z1:TComplex;const Z2:TComplex):TComplex; overload; {返回复数绝对值最大的复数}
function C_Min (const Z1:TComplex;const Z2:TComplex):TComplex; overload; {返回复数绝对值最小的复数}
function C_MaxX (const Z1:TComplex;const Z2:TComplex):TComplex; overload; {返回实部值最大的复数}
function C_MinX (const Z1:TComplex;const Z2:TComplex):TComplex; overload; {返回实部值最小的复数}
{复数次方}
Function C_Sqr (const Z1: TComplex): TComplex; {Z:=Z1*Z1} {平方}
Procedure C_SqrV (var Z1: TComplex); {Z1:=Z1*Z1} {平方}
Function C_Sqr3 (const Z1: TComplex): TComplex; {Z:=Z1^3} {立方}
Procedure C_Sqr3V (var Z1: TComplex); {Z1:=Z1^3} {立方}
Function C_Sqr4 (const Z1: TComplex): TComplex; {Z:=Z1^4} {四次方}
Procedure C_Sqr4V (var Z1: TComplex); {Z1:=Z1^4} {四次方}
Function C_Power (const Z1:TComplex;const Z2:TComplex;const K:integer=0):TComplex;overload; {Z:=Z1^Z2}
Procedure C_PowerV (var Z1: TComplex; const Z2: TComplex;const K:integer=0);overload; {Z1:=Z1^Z2}
Function C_Power (const Z1:TComplex;const x:CmxFloat;const K:integer=0): TComplex;overload; {Z:=Z1^x}
Procedure C_PowerV (var Z1: TComplex; const x: CmxFloat;const K:integer=0);overload; {Z1:=Z1^x}
Function C_Power (const xBase: CmxFloat;const Z1: TComplex): TComplex;overload; {Z:=x^Z1}
Procedure C_PowerV (const xBase: CmxFloat;var Z1: TComplex);overload; {Z1:=x^Z1}
Function C_Exp (const Z1: TComplex): TComplex; {Z:=Exp(Z1)} {e^Z1}
Procedure C_ExpV (var Z1: TComplex); {Z1:=Exp(Z1)}
Function C_Sqrt (const Z1:TComplex;const K:integer=0):TComplex;overload; {Z:=Sqrt(Z1)}
Procedure C_SqrtV (var Z1:TComplex;const K:integer=0); {Z1:=Sqrt(Z1)}
Procedure C_Sqrt (const Z1:TComplex;var Z:array of TComplex);overload; {Z(i):=Sqrt(Z1)}
Function C_SqrtN (const Z1:TComplex;const N:CmxFloat;const K:integer=0):TComplex;overload; {Z:=Z1^(1/N)}
Procedure C_SqrtNV (var Z1:TComplex;const N:CmxFloat;const K:integer=0); {Z1:=Z1^(1/N)}
Procedure C_SqrtN (const Z1:TComplex;const N:integer;var Z:array of TComplex);overload; {Z(i):=Z1^(1/N)}
{复数对数}
Function C_Ln (const Z1: TComplex;const K:integer=0): TComplex; {Z:=Ln(Z1)}
Procedure C_LnV (var Z1: TComplex;const K:integer=0); {Z1:=Ln(Z1)}
Function C_Log2 (const Z1: TComplex;const K:integer=0): TComplex; {Z:=Log2(Z1)}
Procedure C_Log2V (var Z1: TComplex;const K:integer=0); {Z1:=Log2(Z1)}
Function C_Log10 (const Z1: TComplex;const K:integer=0): TComplex; {Z:=Log10(Z1)}
Procedure C_Log10V (var Z1: TComplex;const K:integer=0); {Z1:=Log10(Z1)}
Function C_LogN (const NBase:CmxFloat;const Z1:TComplex;const K:integer=0):TComplex; {Z:=LogN(Z1)=Ln(Z1)/Ln(N)}
Procedure C_LogNV (const NBase:CmxFloat;var Z1: TComplex;const K:integer=0); {Z1:=LogN(Z1)}
{复数三角函数}
Function C_Sin (const Z1: TComplex): TComplex; {Z:=Sin(Z1)}
Procedure C_SinV (var Z1: TComplex); {Z1:=Sin(Z1)}
Function C_Cos (const Z1: TComplex): TComplex; {Z:=Cos(Z1)}
Procedure C_CosV (var Z1: TComplex); {Z1:=Cos(Z1)}
Function C_Tan (const Z1: TComplex): TComplex; {Z:=Tan(Z1)}
Procedure C_TanV (var Z1: TComplex); {Z1:=Tan(Z1)}
Function C_Cot (const Z1: TComplex): TComplex; {Z:=Cotan(Z1) => 1/tan(Z1)}
Procedure C_CotV (var Z1: TComplex); {Z1:=Cotan(Z1)}
Function C_Csc (const Z1: TComplex): TComplex; {Z:=Csc(Z1) => 1/sin(Z1)}
Procedure C_CscV (var Z1: TComplex); {Z1:=Csc(Z1)}
Function C_Sec (const Z1: TComplex): TComplex; {Z:=Sec(Z1) => 1/Cos(Z1)}
Procedure C_SecV (var Z1: TComplex); {Z1:=Sec(Z1)}
Function C_SinH (const Z1: TComplex): TComplex; {Z:=SinH(Z1)}
Procedure C_SinHV (var Z1: TComplex); {Z1:=SinH(Z1)}
Function C_CosH (const Z1: TComplex): TComplex; {Z:=CosH(Z1)}
Procedure C_CosHV (var Z1: TComplex); {Z1:=CosH(Z1)}
Function C_TanH (const Z1: TComplex): TComplex; {Z:=TanH(Z1)}
Procedure C_TanHV (var Z1: TComplex); {Z1:=TanH(Z1)}
Function C_CotH (const Z1: TComplex): TComplex; {Z:=CotanH(Z1)}
Procedure C_CotHV (var Z1: TComplex); {Z1:=CotanH(Z1)}
Function C_CscH (const Z1: TComplex): TComplex; {Z:=CscH(Z1) => 1/sinH(Z1)}
Procedure C_CscHV (var Z1: TComplex); {Z1:=CscH(Z1)}
Function C_SecH (const Z1: TComplex): TComplex; {Z:=SecH(Z1) => 1/CosH(Z1)}
Procedure C_SecHV (var Z1: TComplex); {Z1:=SecH(Z1)}
Function C_ArcSin (const Z1: TComplex): TComplex; {Z:=ArcSin(Z1)}
Procedure C_ArcSinV (var Z1: TComplex); {Z1:=ArcSin(Z1)}
Function C_ArcCos (const Z1: TComplex): TComplex; {Z:=ArcCos(Z1)}
Procedure C_ArcCosV (var Z1: TComplex); {Z1:=ArcCos(Z1)}
Function C_ArcTan (const Z1: TComplex): TComplex; {Z:=ArcTan(Z1)}
Procedure C_ArcTanV (var Z1: TComplex); {Z1:=ArcTan(Z1)}
Function C_ArcCsc (const Z1: TComplex): TComplex; {Z:=ArcCsc(Z1)}
Procedure C_ArcCscV (var Z1: TComplex); {Z1:=ArcCsc(Z1)}
Function C_ArcSec (const Z1: TComplex): TComplex; {Z:=ArcSec(Z1)}
Procedure C_ArcSecV (var Z1: TComplex); {Z1:=ArcSec(Z1)}
Function C_ArcCot (const Z1: TComplex): TComplex; {Z:=ArcCot(Z1)}
Procedure C_ArcCotV (var Z1: TComplex); {Z1:=ArcCot(Z1)}
Function C_ArcSinH (const Z1: TComplex): TComplex; {Z:=ArcSinH(Z1)}
Procedure C_ArcSinHV (var Z1: TComplex); {Z1:=ArcSinH(Z1)}
Function C_ArcCosH (const Z1: TComplex): TComplex; {Z:=ArcCosH(Z1)}
Procedure C_ArcCosHV (var Z1: TComplex); {Z1:=ArcCosH(Z1)}
Function C_ArcTanH (const Z1: TComplex): TComplex; {Z:=ArcTanH(Z1)}
Procedure C_ArcTanHV (var Z1: TComplex); {Z1:=ArcTanH(Z1)}
Function C_ArcCscH (const Z1: TComplex): TComplex; {Z:=ArcCscH(Z1)}
Procedure C_ArcCscHV (var Z1: TComplex); {Z1:=ArcCscH(Z1)}
Function C_ArcSecH (const Z1: TComplex): TComplex; {Z:=ArcSecH(Z1)}
Procedure C_ArcSecHV (var Z1: TComplex); {Z1:=ArcSecH(Z1)}
Function C_ArcCotH (const Z1: TComplex): TComplex; {Z:=ArcCotH(Z1)}
Procedure C_ArcCotHV (var Z1: TComplex); {Z1:=ArcCotH(Z1)}
//////////////////////////////////////////////////////////////////////////////
{中间调用函数} {也可以用包含Math单元的方式，去掉部分函数}
//(*
function CosH (const x:CmxFloat):CmxFloat; {实数双曲余弦函数: y:=[e^x + e^(-x)]/2}
function SinH (const x:CmxFloat):CmxFloat; {实数双曲正弦函数: y:=[e^x - e^(-x)]/2}
function ArcTan2 (const y:CmxFloat;const x:CmxFloat):CmxFloat register; {ArcTan(Y/X) (值域-PI到PI)}
function Floor (const x:CmxFloat):CmxFloat; {取整，小于x的最大整数}
function Ceil (const x:CmxFloat):CmxFloat; {取整，大于x的最小整数}
procedure SinCos (const x: CmxFloat; var Sin , Cos : CmxFloat); {同时计算正弦和余弦: Sin:=sin(Theta); Cos:=cos(Theta) }
procedure SinHCosH(const x: CmxFloat; var SinH, CosH: CmxFloat); {同时计算双曲正弦和双曲余弦: SinH:=sinH(Theta); CosH:=cosH(Theta) }
//*)
//////////////////////////////////////////////////////////////////////////////
implementation
{定义常量}
{$IFDEF Cmx_Extended}
Const SmallLimit: CmxFloat = 1E-2000; {无穷小}
Const LargeLimit: CmxFloat = 1E+2000; {无穷大}
{$ENDIF}
{$IFDEF Cmx_Double}
Const SmallLimit: CmxFloat = 1E-200; {无穷小}
Const LargeLimit: CmxFloat = 1E+200; {无穷大}
{$ENDIF}
{$IFDEF Cmx_Single}
Const SmallLimit: CmxFloat = 1E-20; {无穷小}
Const LargeLimit: CmxFloat = 1E+20; {无穷大}
{$ENDIF}
const PI : CmxFloat =3.1415926535897932384626433832795 ; {圆周率PI}
const SYS_e: CmxFloat =2.7182818284590452353602874713527 ; {自然数e}
const Ln2P : CmxFloat =1.4426950408889634073599246810019 ; {1/Ln(2)}
const Ln10P: CmxFloat =0.43429448190325182765112891891661 ; {1/Ln(10)}
const Half : CmxFloat =0.5;
const HalfHalf : CmxFloat =0.25;
//==============================================================================
{中间调用函数}
procedure SinCos(const x: CmxFloat; var Sin, Cos: CmxFloat); register;assembler
asm
FLD x
FSINCOS
FSTP CmxFloat [cos]//[edx]
FSTP CmxFloat [sin]//[eax]
//FWAIT
end;
procedure SinHCosH(const x: CmxFloat; var SinH, CosH: CmxFloat); register;assembler
{var
xTemp :CmxFloat;
invxTemp :CmxFloat;
begin
xTemp:=0.5*exp(Theta);
invxTemp:=0.25/xTemp;
SinH := (xTemp - invxTemp);
CosH := (xTemp + invxTemp); }
asm
fld x
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)
fld Half
fmulp st(1),st
fld HalfHalf
fxch st(1)
fdiv st(1),st
fld st(0)
fsub st,st(2)
fstp CmxFloat [SinH]//[eax]
faddp st(1),st
fstp CmxFloat [CosH]//[edx]
end;
{双曲函数}
function cosh(const x : CmxFloat) : CmxFloat;register;assembler{cosh(x)} {实数双曲余弦函数: y:= [e^x + e^(-x)]/2}
{var
xTemp :CmxFloat;
begin
xTemp:=exp(x);
result := 0.5*(xTemp + 1/xTemp) ;
}
asm
fld x
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)
fld1
fdiv st,st(1)
faddp st(1),st
fld Half //0.5
fmulp st(1),st
end;
function sinh(const x : CmxFloat) : CmxFloat;register;assembler{sinh(x)} {实数双曲正弦函数: y:= [e^x - e^(-x)]/2}
{
var
xTemp :CmxFloat;
begin
xTemp:=exp(x);
result := 0.5*(xTemp - 1/xTemp) ;
//}
//{
asm
fld x
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)
fld1
fdiv st,st(1)
fsubp st(1),st
fld Half
fmulp st(1),st
//}
end;
function ArcTan2(const Y:CmxFloat;const X: CmxFloat): CmxFloat; register;assembler; {ArcTan(Y/X) (值域-PI到PI)}
asm
FLD Y
FLD X
FPATAN
end;
function Floor(const X: CmxFloat): CmxFloat; register;assembler {取整，小于x的最大整数}
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -