Merge pull request JuliaLang#32826 from JuliaLang/sk/issetequal

fix JuliaLang#32550: issetequal with duplicate values

base/abstractset.jl

@@ -5,6 +5,8 @@ sizehint!(s::AbstractSet, n) = nothing
 
 copy!(dst::AbstractSet, src::AbstractSet) = union!(empty!(dst), src)
 
+## set operations (union, intersection, symmetric difference)
+
 """
  union(s, itrs...)
  ∪(s, itrs...)
@@ -77,11 +79,11 @@ max_values(::Type{Nothing}) = 1
 
 function union!(s::AbstractSet{T}, itr) where T
  haslength(itr) && sizehint!(s, length(s) + length(itr))
- for x=itr
+ for x in itr
  push!(s, x)
  length(s) == max_values(T) && break
  end
- s
+ return s
 end
 
 """
@@ -220,41 +222,16 @@ function symdiff!(s::AbstractSet, itr)
  for x in itr
  x in s ? delete!(s, x) : push!(s, x)
  end
- s
+ return s
 end
 
-==(l::AbstractSet, r::AbstractSet) = length(l) == length(r) && l ⊆ r
-# convenience functions for AbstractSet
-# (if needed, only their synonyms ⊊ and ⊆ must be specialized)
-<( l::AbstractSet, r::AbstractSet) = l ⊊ r
-<=(l::AbstractSet, r::AbstractSet) = l ⊆ r
+## non-strict subset comparison
 
-function issubset(l, r)
- if haslength(r)
- rlen = length(r)
- #This threshold was empirically determined by repeatedly
- #sampling using these two methods (see #26198)
- lenthresh = 70
-
- if rlen > lenthresh && !isa(r, AbstractSet)
- return issubset(l, Set(r))
- end
- end
-
- for elt in l
- if !in(elt, r)
- return false
- end
- end
- return true
-end
-# use the implementation below when it becomes as efficient
-# issubset(l, r) = all(_in(r), l)
 const ⊆ = issubset
-⊇(l, r) = r ⊆ l
+function ⊇ end
 """
- issubset(a, b)
- ⊆(a,b)  -> Bool
+ issubset(a, b) -> Bool
+ ⊆(a, b) -> Bool
  ⊇(b, a) -> Bool
 
 Determine whether every element of `a` is also in `b`, using [`in`](@ref).
@@ -273,29 +250,35 @@ true
 """
 issubset, ⊆, ⊇
 
-"""
- issetequal(a, b)
-
-Determine whether `a` and `b` have the same elements. Equivalent
-to `a ⊆ b && b ⊆ a`.
+function issubset(l, r)
+ if haslength(r)
+ rlen = length(r)
+ if isa(l, AbstractSet)
+ # check l for too many unique elements
+ length(l) > rlen && return false
+ end
+ # if r is big enough, convert it to a Set
+ # threshold empirically determined by repeatedly
+ # sampling using these two methods (see #26198)
+ if rlen > 70 && !isa(r, AbstractSet)
+ return issubset(l, Set(r))
+ end
+ end
+ for elt in l
+ elt in r || return false
+ end
+ return true
+end
 
-# Examples
-```jldoctest
-julia> issetequal([1, 2], [1, 2, 3])
-false
+⊇(l, r) = r ⊆ l
 
-julia> issetequal([1, 2], [2, 1])
-true
-```
-"""
-issetequal(l, r) = length(l) == length(r) && l ⊆ r
-issetequal(l::AbstractSet, r::AbstractSet) = l == r
+## strict subset comparison
 
-⊊(l, r) = length(l) < length(r) && l ⊆ r
-⊋(l, r) = r ⊊ l
+function ⊊ end
+function ⊋ end
 """
- ⊊(a, b)
- ⊋(b, a)
+ ⊊(a, b) -> Bool
+ ⊋(b, a) -> Bool
 
 Determines if `a` is a subset of, but not equal to, `b`.
 
@@ -310,11 +293,15 @@ false
 """
 ⊊, ⊋
 
-⊈(l, r) = !⊆(l, r)
-⊉(l, r) = r ⊈ l
+⊊(l::AbstractSet, r) = length(l) < length(r) && l ⊆ r
+⊊(l, r) = Set(l) ⊊ r
+⊋(l, r) = r ⊊ l
+
+function ⊈ end
+function ⊉ end
 """
- ⊈(a, b)
- ⊉(b, a)
+ ⊈(a, b) -> Bool
+ ⊉(b, a) -> Bool
 
 Negation of `⊆` and `⊇`, i.e. checks that `a` is not a subset of `b`.
 
@@ -329,6 +316,53 @@ false
 """
 ⊈, ⊉
 
+⊈(l, r) = !⊆(l, r)
+⊉(l, r) = r ⊈ l
+
+## set equality comparison
+
+"""
+ issetequal(a, b) -> Bool
+
+Determine whether `a` and `b` have the same elements. Equivalent
+to `a ⊆ b && b ⊆ a` but more efficient when possible.
+
+# Examples
+```jldoctest
+julia> issetequal([1, 2], [1, 2, 3])
+false
+
+julia> issetequal([1, 2], [2, 1])
+true
+```
+"""
+issetequal(l::AbstractSet, r::AbstractSet) = l == r
+issetequal(l::AbstractSet, r) = issetequal(l, Set(r))
+
+function issetequal(l, r::AbstractSet)
+ if haslength(l)
+ # check r for too many unique elements
+ length(l) < length(r) && return false
+ end
+ return issetequal(Set(l), r)
+end
+
+function issetequal(l, r)
+ haslength(l) && return issetequal(l, Set(r))
+ haslength(r) && return issetequal(r, Set(l))
+ return issetequal(Set(l), Set(r))
+end
+
+## partial ordering of sets by containment
+
+==(l::AbstractSet, r::AbstractSet) = length(l) == length(r) && l ⊆ r
+# convenience functions for AbstractSet
+# (if needed, only their synonyms ⊊ and ⊆ must be specialized)
+<( l::AbstractSet, r::AbstractSet) = l ⊊ r
+<=(l::AbstractSet, r::AbstractSet) = l ⊆ r
+
+## filtering sets
+
 filter(pred, s::AbstractSet) = mapfilter(pred, push!, s, emptymutable(s))
 
 # it must be safe to delete the current element while iterating over s:

test/sets.jl

@@ -592,11 +592,16 @@ end
 end
 
 @testset "⊆, ⊊, ⊈, ⊇, ⊋, ⊉, <, <=, issetequal" begin
- a = [1, 2]
- b = [2, 1, 3]
- for C = (Tuple, identity, Set, BitSet, Base.IdSet{Int})
- A = C(a)
- B = C(b)
+ a = [2, 1, 2]
+ b = [2, 3, 1, 3]
+ ua = unique(a)
+ ub = unique(b)
+ for TA in (Tuple, identity, Set, BitSet, Base.IdSet{Int}),
+ TB in (Tuple, identity, Set, BitSet, Base.IdSet{Int}),
+ uA = false:true,
+ uB = false:true
+ A = TA(uA ? ua : a)
+ B = TB(uB ? ub : b)
  @test A ⊆ B
  @test A ⊊ B
  @test !(A ⊈ B)
@@ -611,6 +616,10 @@ end
  @test !(B ⊉ A)
  @test !issetequal(A, B)
  @test !issetequal(B, A)
+ for T = (Tuple, identity, Set, BitSet, Base.IdSet{Int})
+ @test issetequal(A, T(A))
+ @test issetequal(B, T(B))
+ end
  if A isa AbstractSet && B isa AbstractSet
  @test A <= B
  @test A < B
@@ -621,10 +630,6 @@ end
  @test B >= A
  @test B > A
  end
- for D = (Tuple, identity, Set, BitSet)
- @test issetequal(A, D(A))
- @test !issetequal(A, D(B))
- end
  end
 end