Same for Difference and SymDifference

Author: ollydev

Source/simba.array_algorithm.pas

@@ -170,11 +170,12 @@ class function TArrayRelationship.Intersection(x, y: TArr): TArr;
     y   := tmp;
   end;
 
-  SetLength(Result, Min(Length(y),Length(x)));
+  SetLength(Result, Length(x)); 
   for i:=0 to High(x) do dict[x[i]] := 1;
   for i:=0 to High(y) do
-    if dict.Contains(y[i]) then
+    if (dict.GetDef(y[i], 0) = 1) then // in x, and not taken yet
     begin
+      dict[y[i]] := 0; // take once
       Result[c] := y[i];
       Inc(c);
     end;
@@ -386,7 +387,12 @@ class function TArrayEquals.Equals(A, B: TArr): Boolean;
   if IsManagedType(_T) then
     SimbaException('Requires EqualsFunc');
 
-  Result := (Length(A) = Length(B)) and ((Length(A) = 0) and (Length(B) = 0)) or CompareMem(@A[0], @B[0], Length(A) * SizeOf(_T))
+  if (Length(A) <> Length(B)) then
+    Exit(False);
+  if (Length(A) = 0) then
+    Exit(True);
+
+  Result := CompareMem(@A[0], @B[0], Length(A) * SizeOf(_T));
 end;
 
 class function TArrayEquals.Equals(A, B: TArr; EqualFunc: TEqualFunc): Boolean;

Source/simba.vartype_pointarray.pas

@@ -2284,64 +2284,51 @@ function TPointArrayHelper.Intersection(Other: TPointArray): TPointArray;
 end;
 
 function TPointArrayHelper.SymmetricDifference(Other: TPointArray): TPointArray;
+var
+  Buffer: TSimbaPointBuffer;
 begin
-  Result := specialize TArrayRelationship<TPoint>.SymmetricDifference(Self, Other);
+  Buffer.Init();
+  Buffer.Add(Self.Difference(Other));
+  Buffer.Add(Other.Difference(Self));
+  Result := Buffer.ToArray(False);
 end;
 
 function TPointArrayHelper.Difference(Other: TPointArray): TPointArray;
 var
-  box: TBox;
-  test: TBooleanArray;
-  x,y: TPointArray;
-  w,h,i,c: Integer;
+  I, Count: Integer;
+  Box: TBox;
+  ScanSet: TPointSet;
+  HashSet: TPointHashSet;
 begin
-  x := Self;
-  y := Other;
-
-  box := y.Bounds(); // bounds of the array we're subtracting
+  SetLength(Result, Length(Self));
+  Count := 0;
 
-  { Fallback to safe dictionary:
-     * Fewer than 1 in area of 5000
-     * Larger than 512MB in memory (approx 25K*25K area)
-  }
-  if (box.Area*SizeOf(TPoint) > $20000000) or
-     (Length(y)/box.Area < 0.0002) then
+  Box := Self.Bounds();
+  if ShouldHashSet(Box, Length(Self) + Length(Other)) then
   begin
-    Exit(specialize TArrayRelationship<TPoint>.Difference(x, y));
-  end;
-
-  SetLength(test, box.Area);
-  w := box.Width;
-  h := box.Height;
-
-  // Mark points of `Other` (y) within the bounds as True in `test`
-  for i := 0 to High(y) do
+    HashSet.Init(Length(Self) + Length(Other));
+    for I := 0 to High(Other) do
+      HashSet.Add(Other[I]);
+    for I := 0 to High(Self) do
+      if HashSet.Add(Self[I]) then
+      begin
+        Result[Count] := Self[I];
+        Inc(Count);
+      end;
+  end else
   begin
-    if InRange(y[i].x - box.x1, 0, w - 1) and InRange(y[i].y - box.y1, 0, h - 1) then
-      test[(y[i].y - box.y1) * w + (y[i].x - box.x1)] := True;
+    ScanSet.Init(Box);
+    for I := 0 to High(Other) do
+      ScanSet.Add(Other[I]);
+    for I := 0 to High(Self) do
+      if ScanSet.Add(Self[I]) then
+      begin
+        Result[Count] := Self[I];
+        Inc(Count);
+      end;
   end;
 
-  SetLength(Result, Length(x));
-  c := 0;
-
-  // Iterate through 'Self' (x)
-  for i := 0 to High(x) do
-  begin
-    // Check if the point is within the bounds of 'Other
-    // if it's outside the bounds we can add this difference
-    if not (InRange(x[i].x - box.x1, 0, w - 1) and InRange(x[i].y - box.y1, 0, h - 1)) then
-    begin
-      Result[c] := x[i];
-      Inc(c);
-    end
-    else if not test[(x[i].y - box.y1) * w + (x[i].x - box.x1)] then
-    begin
-      // If it's INSIDE the bounds but NOT marked in 'test', it's also in the difference
-      Result[c] := x[i];
-      Inc(c);
-    end;
-  end;
-  SetLength(Result, c);
+  SetLength(Result, Count);
 end;
 
 function TPointArrayHelper.DistanceTransform: TSingleMatrix;

Tests/array_relationship.simba

@@ -61,9 +61,9 @@ begin
   Assert(Success(a.Intersection(b), [3, 4]));
 end;
 
-procedure TestPointArray;
+procedure TestBoxArray;
 
-  function Success(a,b: TPointArray): Boolean;
+  function Success(a,b: TBoxArray): Boolean;
   var i: Int32;
   begin
     if (Length(a) <> Length(b)) then
@@ -75,22 +75,27 @@ procedure TestPointArray;
   end;
 
 var
-  a,b: TPointArray;
+  a,b: TBoxArray;
 begin
-  a := [[1,1],[2,2],[3,3]];
-  b := [[3,3],[2,2],[1,1]];
+  a := [[1,1,1,1],[2,2,2,2],[3,3,3,3]];
+  b := [[3,3,3,3],[2,2,2,2],[1,1,1,1]];
+
   Assert(Success(a.Difference(b), []));
   Assert(Success(a.SymDifference(b), []));
+  Assert(Success(a.Intersection(b), [[3,3,3,3],[2,2,2,2],[1,1,1,1]]));
+
+  a := [[1,1,1,1],[2,2,2,2],[3,3,3,3]];
+  b := [[1,1,1,1],[2,2,2,2]];
 
-  a := [[1,2],[2,3],[3,4]];
-  b := [[1,2],[2,3]];
-  Assert(Success(a.Difference(b), [[3,4]]));
-  Assert(Success(a.SymDifference(b), [[3,4]]));
+  Assert(Success(a.Difference(b), [[3,3,3,3]]));
+  Assert(Success(a.SymDifference(b), [[3,3,3,3]]));
+  Assert(Success(a.Intersection(b), [[1,1,1,1],[2,2,2,2]]));
 end;
 
-procedure TestBoxArray;
 
-  function Success(a,b: TBoxArray): Boolean;
+procedure TestDuplicates;
+
+  function Success(a,b: TIntegerArray): Boolean;
   var i: Int32;
   begin
     if (Length(a) <> Length(b)) then
@@ -102,27 +107,22 @@ procedure TestBoxArray;
   end;
 
 var
-  a,b: TBoxArray;
+  a,b: TIntegerArray;
 begin
-  a := [[1,1,1,1],[2,2,2,2],[3,3,3,3]];
-  b := [[3,3,3,3],[2,2,2,2],[1,1,1,1]];
-
-  Assert(Success(a.Difference(b), []));
-  Assert(Success(a.SymDifference(b), []));
-  Assert(Success(a.Intersection(b), [[3,3,3,3],[2,2,2,2],[1,1,1,1]]));
-
-  a := [[1,1,1,1],[2,2,2,2],[3,3,3,3]];
-  b := [[1,1,1,1],[2,2,2,2]];
-
-  Assert(Success(a.Difference(b), [[3,3,3,3]]));
-  Assert(Success(a.SymDifference(b), [[3,3,3,3]]));
-  Assert(Success(a.Intersection(b), [[1,1,1,1],[2,2,2,2]]));
+  a := [1,2,2,3];
+  b := [2,2,3,3,4];
+  Assert(Success(a.Intersection(b), [2,3]), 'intersection dups');
+  Assert(Success(a.Difference(b), [1]), 'difference dups');
+  Assert(Success(a.SymDifference(b), [1,4]), 'symdifference dups');
+
+  Assert(Success(TIntegerArray([1]).Intersection([1,1,1]), [1]), 'intersection overflow');
+  Assert(Success(TIntegerArray([5,5]).Intersection([5,5,5,5]), [5]), 'intersection overflow 2');
 end;
 
 
 begin
   TestIntegerArray();
   TestInt64Array();
-  TestPointArray();
   TestBoxArray();
+  TestDuplicates();
 end;

Tests/tpa_difference.simba

@@ -0,0 +1,65 @@
+{$assertions on}
+
+{ TPointArray.Difference(Other) = the distinct points of Self that are not in
+  Other. It is a set difference, so Self's own duplicates collapse to one.
+
+  The backend is chosen from Self: small coordinates keep its bounds dense for a
+  scanline presence set; coordinates spread by D force the hash set. }
+
+// Compared as a set - order is not part of the contract.
+function SameSet(Got, Want: TPointArray): Boolean;
+begin
+  Result := Got.SortByColumn().Equals(Want.SortByColumn());
+end;
+
+// dense bounds -> scanline backend
+procedure ScanLine;
+var
+  A, B: TPointArray;
+begin
+  A := [Point(1, 1), Point(2, 2), Point(3, 3), Point(4, 4)];
+  B := [Point(2, 2), Point(4, 4), Point(9, 9)];
+
+  Assert(SameSet(TPointArray([]).Difference([]), []), 'both empty');
+  Assert(SameSet(A.Difference([]), A), 'minus nothing');
+  Assert(SameSet(TPointArray([]).Difference(A), []), 'empty self');
+  Assert(SameSet(A.Difference(B), [Point(1, 1), Point(3, 3)]), 'some removed');
+  Assert(SameSet(A.Difference(A), []), 'minus self');
+
+  // set semantics: Self's duplicates collapse to one
+  Assert(SameSet(TPointArray([Point(1, 1), Point(1, 1), Point(2, 2)]).Difference([Point(2, 2)]), [Point(1, 1)]), 'dedups self');
+  // a Self point outside Other's bounds survives
+  Assert(SameSet(TPointArray([Point(-9, -9), Point(2, 2)]).Difference([Point(2, 2)]), [Point(-9, -9)]), 'kept when outside other');
+end;
+
+// huge bounds -> hash fallback backend
+procedure Hashing;
+const
+  D = 1000000;
+var
+  A, B, Big, Sub, Want: TPointArray;
+  I: Int32;
+begin
+  A := [Point(1*D, 1*D), Point(2*D, 2*D), Point(3*D, 3*D), Point(4*D, 4*D)];
+  B := [Point(2*D, 2*D), Point(4*D, 4*D)];
+
+  Assert(SameSet(A.Difference(B), [Point(1*D, 1*D), Point(3*D, 3*D)]), 'some removed');
+  Assert(SameSet(A.Difference(A), []), 'minus self');
+  Assert(SameSet(A.Difference([]), A), 'minus nothing');
+
+  // larger: subtract the odd-indexed points, keep the even ones
+  for I := 0 to 4999 do
+  begin
+    Big += Point(I * D, I * D);
+    if (I mod 2 = 0) then
+      Want += Point(I * D, I * D)
+    else
+      Sub += Point(I * D, I * D);
+  end;
+  Assert(SameSet(Big.Difference(Sub), Want), 'large difference');
+end;
+
+begin
+  ScanLine();
+  Hashing();
+end.

Tests/tpa_symmetricdifference.simba

@@ -0,0 +1,45 @@
+{$assertions on}
+
+// SymDifference: the distinct points in exactly one of the two arrays
+
+function SameSet(Got, Want: TPointArray): Boolean;
+begin
+  Result := Got.SortByColumn().Equals(Want.SortByColumn());
+end;
+
+// scanline backend
+procedure ScanLine;
+var
+  A, B: TPointArray;
+begin
+  A := [Point(1, 1), Point(2, 2), Point(3, 3)];
+  B := [Point(2, 2), Point(3, 3), Point(4, 4)];
+
+  Assert(SameSet(TPointArray([]).SymDifference([]), []), 'both empty');
+  Assert(SameSet(A.SymDifference([]), A), 'other empty');
+  Assert(SameSet(TPointArray([]).SymDifference(A), A), 'self empty');
+  Assert(SameSet(A.SymDifference(B), [Point(1, 1), Point(4, 4)]), 'symmetric');
+  Assert(SameSet(A.SymDifference(A), []), 'same');
+  Assert(SameSet(TPointArray([Point(1, 1), Point(1, 1)]).SymDifference([Point(2, 2)]), [Point(1, 1), Point(2, 2)]), 'dedups');
+  Assert(SameSet(TPointArray([Point(1, 1), Point(2, 2), Point(2, 2)]).SymDifference([Point(2, 2)]), [Point(1, 1)]), 'common dropped');
+end;
+
+// hash backend
+procedure Hashing;
+const
+  D = 1000000;
+var
+  A, B: TPointArray;
+begin
+  A := [Point(1*D, 1*D), Point(2*D, 2*D), Point(3*D, 3*D)];
+  B := [Point(2*D, 2*D), Point(3*D, 3*D), Point(4*D, 4*D)];
+
+  Assert(SameSet(A.SymDifference(B), [Point(1*D, 1*D), Point(4*D, 4*D)]), 'symmetric');
+  Assert(SameSet(A.SymDifference(A), []), 'same');
+  Assert(SameSet(A.SymDifference([]), A), 'other empty');
+end;
+
+begin
+  ScanLine();
+  Hashing();
+end.