Support multiple distance algorithms

Author: ollydev

Source/script/imports/simba.import_math.pas

@@ -26,24 +26,38 @@ implementation
 Distance
 --------
 ```
-function Distance(const X1, Y1, X2, Y2: Double): Double;
-```
+function Distance(X1, Y1, X2, Y2: Double; Algo: EDistanceAlgo = EDistanceAlgo.Euclidean): Double;
+```
+Calculates the distance between X1,Y1 and X2,Y2.
+If not provided the `Algo` parameter defaults to Euclidean.
+But can be any of these:
+ - `EDistanceAlgo.Euclidean`
+ - `EDistanceAlgo.EuclideanSq`
+ - `EDistanceAlgo.Manhattan`
+ - `EDistanceAlgo.Chebyshev`
 *)
-procedure _LapeDistance(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
+procedure _LapeDistance1(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
-  PDouble(Result)^ := Distance(PDouble(Params^[0])^, PDouble(Params^[1])^, PDouble(Params^[2])^, PDouble(Params^[3])^);
+  PDouble(Result)^ := Distance(PDouble(Params^[0])^, PDouble(Params^[1])^, PDouble(Params^[2])^, PDouble(Params^[3])^, EDistanceAlgo(Params^[4]^));
 end;
 
 (*
 Distance
 --------
 ```
-function Distance(const P1, P2: TPoint): Double;
+function Distance(P1, P2: TPoint; Algo: EDistanceAlgo = EDistanceAlgo.Euclidean): Double;
 ```
+Calculates the distance between two points.
+If not provided the `Algo` parameter defaults to Euclidean.
+But can be any of these:
+ - `EDistanceAlgo.Euclidean`
+ - `EDistanceAlgo.EuclideanSq`
+ - `EDistanceAlgo.Manhattan`
+ - `EDistanceAlgo.Chebyshev`
 *)
-procedure _LapeDistanceEx(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
+procedure _LapeDistance2(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
 begin
-  PDouble(Result)^ := Distance(PPoint(Params^[0])^, PPoint(Params^[1])^);
+  PDouble(Result)^ := Distance(PPoint(Params^[0])^, PPoint(Params^[1])^, EDistanceAlgo(Params^[2]^));
 end;
 
 (*
@@ -170,7 +184,7 @@ procedure _LapeLog10(const Params: PParamArray; const Result: Pointer); LAPE_WRA
 NextPower2
 ----------
 ```
-function NextPower2(const n: Integer): Integer;
+function NextPower2(n: Integer): Integer;
 ```
 *)
 procedure _LapeNextPower2(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -182,7 +196,7 @@ procedure _LapeNextPower2(const Params: PParamArray; const Result: Pointer); LAP
 Modulo
 ------
 ```
-function Modulo(const X, Y: Integer): Integer;
+function Modulo(X, Y: Integer): Integer;
 ```
 *)
 procedure _LapeModulo(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -194,7 +208,7 @@ procedure _LapeModulo(const Params: PParamArray; const Result: Pointer); LAPE_WR
 Modulo
 ------
 ```
-function Modulo(const X, Y: Double): Double;
+function Modulo(X, Y: Double): Double;
 ```
 *)
 procedure _LapeModuloF(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -206,7 +220,7 @@ procedure _LapeModuloF(const Params: PParamArray; const Result: Pointer); LAPE_W
 DeltaAngle
 ----------
 ```
-function DeltaAngle(const DegreesA, DegreesB: Double; R: Double = 360): Double;
+function DeltaAngle(DegreesA, DegreesB: Double; R: Double = 360): Double;
 ```
 *)
 procedure _LapeDeltaAngle(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -219,7 +233,7 @@ procedure _LapeDeltaAngle(const Params: PParamArray; const Result: Pointer); LAP
 CrossProduct
 ------------
 ```
-function CrossProduct(const r, p, q: TPoint): Int64;
+function CrossProduct(r, p, q: TPoint): Int64;
 ```
 *)
 procedure _LapeCrossProduct1(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -231,7 +245,7 @@ procedure _LapeCrossProduct1(const Params: PParamArray; const Result: Pointer);
 CrossProduct
 ------------
 ```
-function CrossProduct(const rx,ry, px,py, qx,qy: Double): Double;
+function CrossProduct(rx,ry, px,py, qx,qy: Double): Double;
 ```
 *)
 procedure _LapeCrossProduct2(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -243,7 +257,7 @@ procedure _LapeCrossProduct2(const Params: PParamArray; const Result: Pointer);
 LinesIntersect
 --------------
 ```
-function LinesIntersect(const P1, P2, Q1, Q2: TPoint): Boolean;
+function LinesIntersect(P1, P2, Q1, Q2: TPoint): Boolean;
 ```
 *)
 procedure _LapeLinesIntersect1(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -255,7 +269,7 @@ procedure _LapeLinesIntersect1(const Params: PParamArray; const Result: Pointer)
 LinesIntersect
 --------------
 ```
-function LinesIntersect(const P1, P2, Q1, Q2: TPoint; out Where: TPoint): Boolean;
+function LinesIntersect(P1, P2, Q1, Q2: TPoint; out Where: TPoint): Boolean;
 ```
 *)
 procedure _LapeLinesIntersect2(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -267,7 +281,7 @@ procedure _LapeLinesIntersect2(const Params: PParamArray; const Result: Pointer)
 DistToLine
 ----------
 ```
-function DistToLine(const P, P1, P2: TPoint; out Nearest: TPoint): Double;
+function DistToLine(P, P1, P2: TPoint; out Nearest: TPoint): Double;
 ```
 *)
 procedure _LapeDistToLine1(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -279,7 +293,7 @@ procedure _LapeDistToLine1(const Params: PParamArray; const Result: Pointer); LA
 DistToLine
 ----------
 ```
-function DistToLine(const P, P1, P2: TPoint): Double;
+function DistToLine(P, P1, P2: TPoint): Double;
 ```
 *)
 procedure _LapeDistToLine2(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -291,7 +305,7 @@ procedure _LapeDistToLine2(const Params: PParamArray; const Result: Pointer); LA
 IsNumber
 --------
 ```
-function IsNumber(const Value: Single): Boolean;
+function IsNumber(Value: Single): Boolean;
 ```
 *)
 procedure _LapeIsNumberS(const Params: PParamArray; const Result: Pointer); LAPE_WRAPPER_CALLING_CONV
@@ -322,11 +336,13 @@ procedure ImportMath(Script: TSimbaScript);
     addGlobalVar(SQRT_3, 'SQRT_3').isConstant := True;
     addGlobalVar(SQRT_5, 'SQRT_5').isConstant := True;
 
-    addGlobalFunc('function IsNumber(const Value: Single): Boolean; overload', @_LapeIsNumberS);
-    addGlobalFunc('function IsNumber(const Value: Double): Boolean; overload', @_LapeIsNumberD);
+    addGlobalType('enum(Euclidean, EuclideanSq, Manhattan, Chebyshev)', 'EDistanceAlgo');
+
+    addGlobalFunc('function IsNumber(Value: Single): Boolean; overload', @_LapeIsNumberS);
+    addGlobalFunc('function IsNumber(Value: Double): Boolean; overload', @_LapeIsNumberD);
 
-    addGlobalFunc('function Distance(const X1, Y1, X2, Y2: Double): Double; overload', @_LapeDistance);
-    addGlobalFunc('function Distance(const P1, P2: TPoint): Double; overload', @_LapeDistanceEx);
+    addGlobalFunc('function Distance(X1, Y1, X2, Y2: Double; Algo: EDistanceAlgo = EDistanceAlgo.Euclidean): Double; overload', @_LapeDistance1);
+    addGlobalFunc('function Distance(P1, P2: TPoint; Algo: EDistanceAlgo = EDistanceAlgo.Euclidean): Double; overload', @_LapeDistance2);
 
     addGlobalFunc('function Sar(x: Integer; Shift: Byte): Integer', @_LapeSar);
     addGlobalFunc('function Ror(x: UInt32; Shift: Byte): UInt32', @_LapeRor);
@@ -346,15 +362,15 @@ procedure ImportMath(Script: TSimbaScript);
     addGlobalFunc('function Modulo(const X, Y: Integer): Integer; overload', @_LapeModulo);
     addGlobalFunc('function Modulo(const X, Y: Double): Double; overload', @_LapeModuloF);
 
-    addGlobalFunc('function DeltaAngle(const DegreesA, DegreesB: Double; R: Double = 360): Double', @_LapeDeltaAngle);
+    addGlobalFunc('function DeltaAngle(DegreesA, DegreesB: Double; R: Double = 360): Double', @_LapeDeltaAngle);
 
-    addGlobalFunc('function CrossProduct(const r, p, q: TPoint): Int64; overload', @_LapeCrossProduct1);
-    addGlobalFunc('function CrossProduct(const rx,ry, px,py, qx,qy: Double): Double; overload', @_LapeCrossProduct2);
-    addGlobalFunc('function LinesIntersect(const P1, P2, Q1, Q2: TPoint): Boolean; overload', @_LapeLinesIntersect1);
-    addGlobalFunc('function LinesIntersect(const P1, P2, Q1, Q2: TPoint; out Where: TPoint): Boolean; overload', @_LapeLinesIntersect2);
+    addGlobalFunc('function CrossProduct(r, p, q: TPoint): Int64; overload', @_LapeCrossProduct1);
+    addGlobalFunc('function CrossProduct(rx,ry, px,py, qx,qy: Double): Double; overload', @_LapeCrossProduct2);
+    addGlobalFunc('function LinesIntersect(P1, P2, Q1, Q2: TPoint): Boolean; overload', @_LapeLinesIntersect1);
+    addGlobalFunc('function LinesIntersect(P1, P2, Q1, Q2: TPoint; out Where: TPoint): Boolean; overload', @_LapeLinesIntersect2);
 
-    addGlobalFunc('function DistToLine(const P, P1, P2: TPoint; out Nearest: TPoint): Double; overload', @_LapeDistToLine1);
-    addGlobalFunc('function DistToLine(const P, P1, P2: TPoint): Double; overload', @_LapeDistToLine2);
+    addGlobalFunc('function DistToLine(P, P1, P2: TPoint; out Nearest: TPoint): Double; overload', @_LapeDistToLine1);
+    addGlobalFunc('function DistToLine(P, P1, P2: TPoint): Double; overload', @_LapeDistToLine2);
 
     DumpSection := '';
   end;

Source/simba.math.pas

@@ -19,8 +19,30 @@ interface
   SQRT_3 = Double(1.73205080756888);
   SQRT_5 = Double(2.23606797749979);
 
-function Distance(const P1,P2: TPoint): Double; overload; inline;
-function Distance(const X1,Y1,X2,Y2: Double): Double; overload; inline;
+{$scopedenums on}
+type
+  EDistanceAlgo = (
+    Euclidean,
+    EuclideanSq,
+    Manhattan,
+    Chebyshev
+  );
+{$scopedenums off}
+
+function Distance(const P1,P2: TPoint; Algo: EDistanceAlgo): Single; overload;
+function Distance(const X1,Y1,X2,Y2: Double; Algo: EDistanceAlgo): Single; overload;
+
+function DistEuclidean(const P1,P2: TPoint): Single; inline; overload;
+function DistEuclidean(const X1,Y1,X2,Y2: Double): Single; inline; overload;
+
+function DistEuclideanSq(const P1,P2: TPoint): Single; inline; overload;
+function DistEuclideanSq(const X1,Y1,X2,Y2: Double): Single; inline; overload;
+
+function DistManhattan(const P1,P2: TPoint): Single; inline; overload;
+function DistManhattan(const X1,Y1,X2,Y2: Double): Single; inline; overload;
+
+function DistChebyshev(const P1,P2: TPoint): Single; inline; overload;
+function DistChebyshev(const X1,Y1,X2,Y2: Double): Single; inline; overload;
 
 function NextPower2(const n: Integer): Integer;
 
@@ -38,14 +60,75 @@ implementation
 uses
   Math;
 
+function Distance(const P1, P2: TPoint; Algo: EDistanceAlgo): Single;
+begin
+  case Algo of
+    EDistanceAlgo.Euclidean:   Result := DistEuclidean(P1, P2);
+    EDistanceAlgo.EuclideanSq: Result := DistEuclideanSq(P1, P2);
+    EDistanceAlgo.Chebyshev:   Result := DistChebyshev(P1, P2);
+    EDistanceAlgo.Manhattan:   Result := DistManhattan(P1, P2);
+  end;
+end;
+
+function Distance(const X1, Y1, X2, Y2: Double; Algo: EDistanceAlgo): Single;
+begin
+  case Algo of
+    EDistanceAlgo.Euclidean:   Result := DistEuclidean(X1, Y1, X2, Y2);
+    EDistanceAlgo.EuclideanSq: Result := DistEuclideanSq(X1, Y1, X2, Y2);
+    EDistanceAlgo.Chebyshev:   Result := DistChebyshev(X1, Y1, X2, Y2);
+    EDistanceAlgo.Manhattan:   Result := DistManhattan(X1, Y1, X2, Y2);
+  end;
+end;
+
+function DistEuclidean(const P1,P2: TPoint): Single;
+begin
+  // use Double to prevent integer overflows
+  Result := Sqrt(Sqr(Double(P1.X) - Double(P2.X)) + Sqr(Double(P1.Y) - Double(P2.Y)));
+end;
+
+function DistEuclidean(const X1,Y1,X2,Y2: Double): Single;
+begin
+  Result := Sqrt(Sqr(X2 - X1) + Sqr(Y2 - Y1));
+end;
+
+function DistEuclideanSq(const P1,P2: TPoint): Single;
+begin
+  Result := Sqr(Double(P1.X) - Double(P2.X)) + Sqr(Double(P1.Y) - Double(P2.Y));
+end;
+
+function DistEuclideanSq(const X1,Y1,X2,Y2: Double): Single;
+begin
+  Result := Sqr(X1-X2) + Sqr(Y1-Y2);
+end;
+
+function DistManhattan(const P1,P2: TPoint): Single;
+begin
+  Result := Abs(Double(P1.X) - Double(P2.X)) + Abs(Double(P1.Y) - Double(P2.Y));
+end;
+
+function DistManhattan(const X1,Y1,X2,Y2: Double): Single;
+begin
+  Result := Abs(X1-X2) + Abs(Y1-Y2);
+end;
+
+function DistChebyshev(const P1,P2: TPoint): Single;
+begin
+  Result := Max(Abs(Double(P1.X) - Double(P2.X)), Abs(Double(P1.Y) - Double(P2.Y)));
+end;
+
+function DistChebyshev(const X1,Y1,X2,Y2: Double): Single;
+begin
+  Result := Max(Abs(X1 - X2), Abs(Y1 - Y2));
+end;
+
 function IsNumber(const n: Double): Boolean;
 begin
   Result := (not IsNan(n)) and (not IsInfinite(n));
 end;
 
 function IsNumber(const n: Single): Boolean;
 begin
-  Result := (LongWord(n) and $7fffffff) < $7f800000; // Result := (not IsNan(n)) and (not IsInfinite(n));
+  Result := (LongWord(n) and $7FFFFFFF) < $7F800000; // Result := (not IsNan(n)) and (not IsInfinite(n));
 end;
 
 function Modulo(const X, Y: Double): Double;
@@ -75,16 +158,6 @@ function NextPower2(const n: Integer): Integer;
   Result := Result + 1;
 end;
 
-function Distance(const P1, P2: TPoint): Double;
-begin
-  Result := Sqrt(Sqr(Double(P2.X) - Double(P1.X)) + Sqr(Double(P2.Y) - Double(P1.Y))); // convert to Double to prevent integer overflows
-end;
-
-function Distance(const X1, Y1, X2, Y2: Double): Double;
-begin
-  Result := Sqrt(Sqr(X2 - X1) + Sqr(Y2 - Y1));
-end;
-
 function CeilTo(const n: Double; const Precision: Int8 = 0): Double;
 begin
   if (Precision = 0) then
@@ -94,4 +167,3 @@ function CeilTo(const n: Double; const Precision: Int8 = 0): Double;
 end;
 
 end.
-

Source/simba.vartype_box.pas

@@ -395,7 +395,7 @@ function TBoxArrayHelper.SortFrom(From: TPoint): TBoxArray;
 begin
   SetLength(Weights, Length(Self));
   for I := 0 to High(Weights) do
-    Weights[I] := Distance(From, Self[I].Center);
+    Weights[I] := DistEuclidean(From, Self[I].Center);
 
   Result := Self.Sort(Weights);
 end;

Source/simba.vartype_circle.pas

@@ -108,7 +108,7 @@ class function TCircleHelper.CreateFromPoints(Points: TPointArray): TCircle;
 
 function TCircleHelper.Contains(const P: TPoint): Boolean;
 begin
-  Result := Distance(X, Y, P.X, P.Y) <= Radius;
+  Result := DistEuclidean(X, Y, P.X, P.Y) <= Radius;
 end;
 
 function TCircleHelper.PointAtDegrees(Degrees: Double): TPoint;

Source/simba.vartype_pointarray.pas

@@ -1663,7 +1663,7 @@ function TPointArrayHelper.IsPointNearby(Other: TPoint; MinDist, MaxDist: Double
   I: Integer;
 begin
   for I := 0 to High(Self) do
-    if InRange(Distance(Self[I], Other), MinDist, MaxDist) then
+    if InRange(DistEuclidean(Self[I], Other), MinDist, MaxDist) then
       Exit(True);
 
   Result := False;

Source/simba.vartype_quad.pas

@@ -173,7 +173,7 @@ function TQuadHelper.GetMean: TPoint;
 
 function TQuadHelper.GetArea: Integer;
 begin
-  Result := Round(Distance(Self.Bottom, Self.Right)) * Round(Distance(Self.Bottom, Self.Left));
+  Result := Round(DistEuclidean(Self.Bottom, Self.Right)) * Round(DistEuclidean(Self.Bottom, Self.Left));
 end;
 
 function TQuadHelper.Rotate(Radians: Double): TQuad;
@@ -333,7 +333,7 @@ function TQuadArrayHelper.SortFrom(From: TPoint): TQuadArray;
 begin
   SetLength(Weights, Length(Self));
   for I := 0 to High(Weights) do
-    Weights[I] := Distance(From, Self[I].Mean);
+    Weights[I] := DistEuclidean(From, Self[I].Mean);
 
   Result := Self.Sort(Weights);
 end;

Source/simba.vartype_triangle.pas

@@ -145,9 +145,9 @@ function TTriangleHelper.Incenter(): TPoint;
 var
   ar, br, cr: Single;
 begin
-  ar := Distance(B, C);
-  br := Distance(A, C);
-  cr := Distance(A, B);
+  ar := DistEuclidean(B, C);
+  br := DistEuclidean(A, C);
+  cr := DistEuclidean(A, B);
 
   Result.x := Round((ar * A.x + br * B.x + cr * C.x) / (ar + br + cr));
   Result.y := Round((ar * A.y + br * B.y + cr * C.y) / (ar + br + cr));