Michael Schimmel
595 lines
20 KiB
ObjectPascal
595 lines
20 KiB
ObjectPascal
unit Myc.Ast.RTL.Math;
|
|
|
|
interface
|
|
|
|
uses
|
|
System.SysUtils,
|
|
System.Math,
|
|
Myc.Data.Scalar,
|
|
Myc.Data.Value,
|
|
Myc.Ast.Attributes;
|
|
|
|
type
|
|
TRtlMathFunctions = record
|
|
public
|
|
// --- Constants ---
|
|
|
|
[TRtlConst('Pi')]
|
|
[AstDoc('Pi.')]
|
|
class function CPi: Double; static;
|
|
|
|
[TRtlConst('e')]
|
|
[AstDoc('Euler''s number.')]
|
|
class function CE: Double; static;
|
|
|
|
// --- Basic Math ---
|
|
|
|
[TRtlExport('abs', Pure)]
|
|
[AstDoc('Returns the absolute value of a number.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Abs(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('round', Pure)]
|
|
[AstDoc('Rounds a float to the nearest integer.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Round(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('trunc', Pure)]
|
|
[AstDoc('Returns the integer part of a float.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Trunc(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('ceil', Pure)]
|
|
[AstDoc('Returns the smallest integer >= the argument.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Ceil(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('floor', Pure)]
|
|
[AstDoc('Returns the largest integer <= the argument.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Floor(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('sign', Pure)]
|
|
[AstDoc('Returns -1 for negative, 1 for positive, 0 for zero.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Sign(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('min', Pure)]
|
|
[AstDoc('Returns the smaller of two numbers.')]
|
|
[AstSignature('(number, number) -> number')]
|
|
class function Min(const Args: TArray<TDataValue>): TDataValue; static;
|
|
|
|
[TRtlExport('max', Pure)]
|
|
[AstDoc('Returns the larger of two numbers.')]
|
|
[AstSignature('(number, number) -> number')]
|
|
class function Max(const Args: TArray<TDataValue>): TDataValue; static;
|
|
|
|
[TRtlExport('sqrt', Pure)]
|
|
[AstDoc('Returns the square root of a number.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Sqrt(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('pow', Pure)]
|
|
[AstDoc('Returns Base raised to the power of Exponent.')]
|
|
[AstSignature('(number, number) -> number')]
|
|
class function Pow(const Args: TArray<TDataValue>): TDataValue; static;
|
|
|
|
[TRtlExport('exp', Pure)]
|
|
[AstDoc('Returns e raised to the power of X.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Exp(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('log', Pure)]
|
|
[AstDoc('Returns the natural logarithm (Base e).')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Log(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('log10', Pure)]
|
|
[AstDoc('Returns the base-10 logarithm.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Log10(const Arg: TScalar): TScalar; static;
|
|
|
|
// --- Trigonometry ---
|
|
|
|
[TRtlExport('sin', Pure)]
|
|
[AstDoc('Returns the sine of the angle (in radians).')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Sin(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('cos', Pure)]
|
|
[AstDoc('Returns the cosine of the angle (in radians).')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Cos(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('tan', Pure)]
|
|
[AstDoc('Returns the tangent of the angle (in radians).')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Tan(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('asin', Pure)]
|
|
[AstDoc('Returns the arc sine.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function ArcSin(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('acos', Pure)]
|
|
[AstDoc('Returns the arc cosine.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function ArcCos(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('atan', Pure)]
|
|
[AstDoc('Returns the arc tangent.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function ArcTan(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('atan2', Pure)]
|
|
[AstDoc('Returns the angle whose tangent is Y / X.')]
|
|
[AstSignature('(y, x) -> number')]
|
|
class function ArcTan2(const Args: TArray<TDataValue>): TDataValue; static;
|
|
|
|
[TRtlExport('sinh', Pure)]
|
|
[AstDoc('Returns the hyperbolic sine.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Sinh(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('cosh', Pure)]
|
|
[AstDoc('Returns the hyperbolic cosine.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Cosh(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('tanh', Pure)]
|
|
[AstDoc('Returns the hyperbolic tangent.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Tanh(const Arg: TScalar): TScalar; static;
|
|
|
|
// --- Conversion ---
|
|
|
|
[TRtlExport('deg2rad', Pure)]
|
|
[AstDoc('Converts degrees to radians.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function DegToRad(const Arg: TScalar): TScalar; static;
|
|
|
|
[TRtlExport('rad2deg', Pure)]
|
|
[AstDoc('Converts radians to degrees.')]
|
|
[AstSignature('(number) -> number')]
|
|
class function RadToDeg(const Arg: TScalar): TScalar; static;
|
|
|
|
// --- Utils ---
|
|
|
|
[TRtlExport('random', Impure)]
|
|
[AstDoc('Returns a random number. No args: [0..1). Arg N: Integer [0..N).')]
|
|
[AstSignature('() -> float')]
|
|
[AstSignature('(number) -> number')]
|
|
class function Random(const Args: TArray<TDataValue>): TDataValue; static;
|
|
|
|
[TRtlExport('is-NaN', Pure)]
|
|
[AstDoc('Returns true if the value is Not-a-Number (NaN).')]
|
|
[AstSignature('(number) -> boolean')]
|
|
class function IsNaN(const Arg: TScalar): TScalar; static;
|
|
|
|
// --- Static Specializations ---
|
|
|
|
[TRtlExport('abs', Pure)]
|
|
class function Abs_Ordinal_Ordinal(A: Int64): Int64; static;
|
|
[TRtlExport('abs', Pure)]
|
|
class function Abs_Float_Float(A: Double): Double; static;
|
|
|
|
[TRtlExport('round', Pure)]
|
|
class function Round_Ordinal_Ordinal(A: Int64): Int64; static;
|
|
[TRtlExport('round', Pure)]
|
|
class function Round_Float_Ordinal(A: Double): Int64; static;
|
|
|
|
[TRtlExport('trunc', Pure)]
|
|
class function Trunc_Ordinal_Ordinal(A: Int64): Int64; static;
|
|
[TRtlExport('trunc', Pure)]
|
|
class function Trunc_Float_Ordinal(A: Double): Int64; static;
|
|
|
|
[TRtlExport('sqrt', Pure)]
|
|
class function Sqrt_Ordinal_Float(A: Int64): Double; static;
|
|
[TRtlExport('sqrt', Pure)]
|
|
class function Sqrt_Float_Float(A: Double): Double; static;
|
|
|
|
[TRtlExport('pow', Pure)]
|
|
class function Pow_Ordinal_Ordinal_Float(A, B: Int64): Double; static;
|
|
[TRtlExport('pow', Pure)]
|
|
class function Pow_Float_Float_Float(A, B: Double): Double; static;
|
|
[TRtlExport('pow', Pure)]
|
|
class function Pow_Ordinal_Float_Float(A: Int64; B: Double): Double; static;
|
|
[TRtlExport('pow', Pure)]
|
|
class function Pow_Float_Ordinal_Float(A: Double; B: Int64): Double; static;
|
|
|
|
[TRtlExport('min', Pure)]
|
|
class function Min_Ordinal_Ordinal_Ordinal(A, B: Int64): Int64; static;
|
|
[TRtlExport('min', Pure)]
|
|
class function Min_Float_Float_Float(A, B: Double): Double; static;
|
|
|
|
[TRtlExport('max', Pure)]
|
|
class function Max_Ordinal_Ordinal_Ordinal(A, B: Int64): Int64; static;
|
|
[TRtlExport('max', Pure)]
|
|
class function Max_Float_Float_Float(A, B: Double): Double; static;
|
|
|
|
[TRtlExport('exp', Pure)]
|
|
class function Exp_Float_Float(A: Double): Double; static;
|
|
[TRtlExport('log', Pure)]
|
|
class function Log_Float_Float(A: Double): Double; static;
|
|
[TRtlExport('log10', Pure)]
|
|
class function Log10_Float_Float(A: Double): Double; static;
|
|
|
|
[TRtlExport('sin', Pure)]
|
|
class function Sin_Float_Float(A: Double): Double; static;
|
|
[TRtlExport('cos', Pure)]
|
|
class function Cos_Float_Float(A: Double): Double; static;
|
|
[TRtlExport('tan', Pure)]
|
|
class function Tan_Float_Float(A: Double): Double; static;
|
|
|
|
[TRtlExport('random', Impure)]
|
|
class function Random_Void_Float: Double; static;
|
|
[TRtlExport('random', Impure)]
|
|
class function Random_Ordinal_Ordinal(Limit: Int64): Int64; static;
|
|
|
|
[TRtlExport('is-NaN', Pure)]
|
|
class function IsNaN_Float_Ordinal(A: Double): Int64; static;
|
|
end;
|
|
|
|
implementation
|
|
|
|
{ TRtlMathFunctions }
|
|
|
|
// --- Constants ---
|
|
|
|
class function TRtlMathFunctions.CPi: Double;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Pi);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.CE: Double;
|
|
begin
|
|
Result := TScalar.FromDouble(2.71828182845904523536);
|
|
end;
|
|
|
|
// --- Basic Math ---
|
|
|
|
class function TRtlMathFunctions.Abs(const Arg: TScalar): TScalar;
|
|
begin
|
|
case Arg.Kind of
|
|
TScalar.TKind.Ordinal: Result := TScalar.FromInt64(System.Abs(Arg.Value.AsInt64));
|
|
TScalar.TKind.Float, TScalar.TKind.DateTime: Result := TScalar.FromDouble(System.Abs(Arg.Value.AsDouble));
|
|
else
|
|
raise EArgumentException.Create('Abs requires a numeric argument.');
|
|
end;
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Round(const Arg: TScalar): TScalar;
|
|
begin
|
|
case Arg.Kind of
|
|
TScalar.TKind.Ordinal: Result := Arg;
|
|
TScalar.TKind.Float, TScalar.TKind.DateTime:
|
|
begin
|
|
var val: Double := Arg.Value.AsDouble;
|
|
Result := TScalar.FromInt64(System.Round(val));
|
|
end;
|
|
else
|
|
raise EArgumentException.Create('Round requires a numeric argument.');
|
|
end;
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Trunc(const Arg: TScalar): TScalar;
|
|
begin
|
|
case Arg.Kind of
|
|
TScalar.TKind.Ordinal: Result := Arg;
|
|
TScalar.TKind.Float, TScalar.TKind.DateTime:
|
|
begin
|
|
var val: Double := Arg.Value.AsDouble;
|
|
Result := TScalar.FromInt64(System.Trunc(val));
|
|
end;
|
|
else
|
|
raise EArgumentException.Create('Trunc requires a numeric argument.');
|
|
end;
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Ceil(const Arg: TScalar): TScalar;
|
|
begin
|
|
case Arg.Kind of
|
|
TScalar.TKind.Ordinal: Result := Arg;
|
|
TScalar.TKind.Float, TScalar.TKind.DateTime: Result := TScalar.FromInt64(System.Math.Ceil(Arg.Value.AsDouble));
|
|
else
|
|
raise EArgumentException.Create('Ceil requires a numeric argument.');
|
|
end;
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Floor(const Arg: TScalar): TScalar;
|
|
begin
|
|
case Arg.Kind of
|
|
TScalar.TKind.Ordinal: Result := Arg;
|
|
TScalar.TKind.Float, TScalar.TKind.DateTime: Result := TScalar.FromInt64(System.Math.Floor(Arg.Value.AsDouble));
|
|
else
|
|
raise EArgumentException.Create('Floor requires a numeric argument.');
|
|
end;
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Sign(const Arg: TScalar): TScalar;
|
|
begin
|
|
case Arg.Kind of
|
|
TScalar.TKind.Ordinal: Result := TScalar.FromInt64(System.Math.Sign(Arg.Value.AsInt64));
|
|
TScalar.TKind.Float, TScalar.TKind.DateTime: Result := TScalar.FromInt64(System.Math.Sign(Arg.Value.AsDouble));
|
|
else
|
|
raise EArgumentException.Create('Sign requires a numeric argument.');
|
|
end;
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Min(const Args: TArray<TDataValue>): TDataValue;
|
|
begin
|
|
if Length(Args) <> 2 then
|
|
raise EArgumentException.Create('Min requires 2 arguments.');
|
|
|
|
var a: TScalar := Args[0].AsScalar;
|
|
var b: TScalar := Args[1].AsScalar;
|
|
|
|
if (a.Kind = TScalar.TKind.Ordinal) and (b.Kind = TScalar.TKind.Ordinal) then
|
|
Result := TScalar.FromInt64(System.Math.Min(a.Value.AsInt64, b.Value.AsInt64))
|
|
else
|
|
Result := TScalar.FromDouble(System.Math.Min(Double(a), Double(b)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Max(const Args: TArray<TDataValue>): TDataValue;
|
|
begin
|
|
if Length(Args) <> 2 then
|
|
raise EArgumentException.Create('Max requires 2 arguments.');
|
|
|
|
var a: TScalar := Args[0].AsScalar;
|
|
var b: TScalar := Args[1].AsScalar;
|
|
|
|
if (a.Kind = TScalar.TKind.Ordinal) and (b.Kind = TScalar.TKind.Ordinal) then
|
|
Result := TScalar.FromInt64(System.Math.Max(a.Value.AsInt64, b.Value.AsInt64))
|
|
else
|
|
Result := TScalar.FromDouble(System.Math.Max(Double(a), Double(b)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Sqrt(const Arg: TScalar): TScalar;
|
|
begin
|
|
var val: Double := Arg; // Implicit cast handles Ordinal and Float
|
|
Result := TScalar.FromDouble(System.Sqrt(val));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Pow(const Args: TArray<TDataValue>): TDataValue;
|
|
begin
|
|
if Length(Args) <> 2 then
|
|
raise EArgumentException.Create('Pow requires 2 arguments (Base, Exponent).');
|
|
|
|
var baseVal: Double := Args[0].AsScalar;
|
|
var expVal: Double := Args[1].AsScalar;
|
|
Result := TScalar.FromDouble(System.Math.Power(baseVal, expVal));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Exp(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Exp(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Log(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Ln(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Log10(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Math.Log10(Double(Arg)));
|
|
end;
|
|
|
|
// --- Trigonometry ---
|
|
|
|
class function TRtlMathFunctions.Sin(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Sin(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Cos(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Cos(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Tan(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Math.Tan(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.ArcSin(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Math.ArcSin(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.ArcCos(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Math.ArcCos(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.ArcTan(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.ArcTan(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.ArcTan2(const Args: TArray<TDataValue>): TDataValue;
|
|
begin
|
|
if Length(Args) <> 2 then
|
|
raise EArgumentException.Create('Atan2 requires 2 arguments (Y, X).');
|
|
|
|
var y: Double := Args[0].AsScalar;
|
|
var x: Double := Args[1].AsScalar;
|
|
Result := TScalar.FromDouble(System.Math.ArcTan2(y, x));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Sinh(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Math.Sinh(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Cosh(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Math.Cosh(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Tanh(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Math.Tanh(Double(Arg)));
|
|
end;
|
|
|
|
// --- Conversion ---
|
|
|
|
class function TRtlMathFunctions.DegToRad(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Math.DegToRad(Double(Arg)));
|
|
end;
|
|
|
|
class function TRtlMathFunctions.RadToDeg(const Arg: TScalar): TScalar;
|
|
begin
|
|
Result := TScalar.FromDouble(System.Math.RadToDeg(Double(Arg)));
|
|
end;
|
|
|
|
// --- Utils ---
|
|
|
|
class function TRtlMathFunctions.Random(const Args: TArray<TDataValue>): TDataValue;
|
|
begin
|
|
if Length(Args) = 0 then
|
|
Result := TScalar.FromDouble(System.Random)
|
|
else if (Length(Args) = 1) and (Args[0].AsScalar.Kind = TScalar.TKind.Ordinal) then
|
|
Result := TScalar.FromInt64(System.Random(Integer(Args[0].AsScalar.Value.AsInt64)))
|
|
else
|
|
raise EArgumentException.Create('Random expects 0 arguments or 1 integer argument.');
|
|
end;
|
|
|
|
class function TRtlMathFunctions.IsNaN(const Arg: TScalar): TScalar;
|
|
begin
|
|
if (Arg.Kind = TScalar.TKind.Float) and Arg.Value.AsDouble.IsNaN then
|
|
Result := TScalar.FromBoolean(True)
|
|
else
|
|
Result := TScalar.FromBoolean(False);
|
|
end;
|
|
|
|
// --- Static Specializations ---
|
|
|
|
class function TRtlMathFunctions.Abs_Ordinal_Ordinal(A: Int64): Int64;
|
|
begin
|
|
Result := System.Abs(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Abs_Float_Float(A: Double): Double;
|
|
begin
|
|
Result := System.Abs(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Round_Ordinal_Ordinal(A: Int64): Int64;
|
|
begin
|
|
Result := A;
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Round_Float_Ordinal(A: Double): Int64;
|
|
begin
|
|
Result := System.Round(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Trunc_Ordinal_Ordinal(A: Int64): Int64;
|
|
begin
|
|
Result := A;
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Trunc_Float_Ordinal(A: Double): Int64;
|
|
begin
|
|
Result := System.Trunc(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Sqrt_Ordinal_Float(A: Int64): Double;
|
|
begin
|
|
Result := System.Sqrt(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Sqrt_Float_Float(A: Double): Double;
|
|
begin
|
|
Result := System.Sqrt(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Pow_Ordinal_Ordinal_Float(A, B: Int64): Double;
|
|
begin
|
|
Result := System.Math.Power(A, B);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Pow_Float_Float_Float(A, B: Double): Double;
|
|
begin
|
|
Result := System.Math.Power(A, B);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Pow_Ordinal_Float_Float(A: Int64; B: Double): Double;
|
|
begin
|
|
Result := System.Math.Power(A, B);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Pow_Float_Ordinal_Float(A: Double; B: Int64): Double;
|
|
begin
|
|
Result := System.Math.Power(A, B);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Min_Ordinal_Ordinal_Ordinal(A, B: Int64): Int64;
|
|
begin
|
|
Result := System.Math.Min(A, B);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Min_Float_Float_Float(A, B: Double): Double;
|
|
begin
|
|
Result := System.Math.Min(A, B);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Max_Ordinal_Ordinal_Ordinal(A, B: Int64): Int64;
|
|
begin
|
|
Result := System.Math.Max(A, B);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Max_Float_Float_Float(A, B: Double): Double;
|
|
begin
|
|
Result := System.Math.Max(A, B);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Exp_Float_Float(A: Double): Double;
|
|
begin
|
|
Result := System.Exp(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Log_Float_Float(A: Double): Double;
|
|
begin
|
|
Result := System.Ln(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Log10_Float_Float(A: Double): Double;
|
|
begin
|
|
Result := System.Math.Log10(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Sin_Float_Float(A: Double): Double;
|
|
begin
|
|
Result := System.Sin(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Cos_Float_Float(A: Double): Double;
|
|
begin
|
|
Result := System.Cos(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Tan_Float_Float(A: Double): Double;
|
|
begin
|
|
Result := System.Math.Tan(A);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Random_Void_Float: Double;
|
|
begin
|
|
Result := System.Random;
|
|
end;
|
|
|
|
class function TRtlMathFunctions.Random_Ordinal_Ordinal(Limit: Int64): Int64;
|
|
begin
|
|
Result := System.Random(Limit);
|
|
end;
|
|
|
|
class function TRtlMathFunctions.IsNaN_Float_Ordinal(A: Double): Int64;
|
|
begin
|
|
Result := Ord(A.IsNaN);
|
|
end;
|
|
|
|
end.
|