I am trying to get a difference of 1 list of pairs from another in Groovy language. Pairs are just (x,y) coordinates and they are unique. Below is a small example for simplicity. Note that lists can have dozens of pairs.
def l1 = [[x:1, y:1]]
def l2 = [[x:0, y:0]]
println l1 - l2
will get [], that is an empty list but should be this: [[x:1,y:1]]
Update:
for(n in l2) {
l1 = l1 - n
}
It works, but it's a black magic and is not optimized
As stated in the comments, the pairs in l1
are unique (or rather: it's ok to have unique results), then you can use l1/l2 as sets:
l1 = [[x:1, y:1]]
l2 = [[x:0, y:0]]
println l1.toSet()-l2.toSet()
//; [[x:1, y:1]]
The problem originally is the [x:0,y:0]
vs [x:1,y:1]
part. The reason is in public static <T> Collection<T> minus(Collection<T> self, Collection<?> removeMe)
. The n*n branchs is chosen and the NumberAwareComperator
thinks both maps are equal:
def cmp = new org.codehaus.groovy.runtime.NumberAwareComparator()
println cmp.compare(l1[0], l2[0])
//; 0 (equal!)
Which simply boils down to:
assert [x:1, y:1].hashCode() == [x:0, y:0].hashCode()
// 120^1 + 121^1 == 120^0 + 121^0
Edit Alternative (if you can get rid of the map)
As this does not look that good of a base for, you might be better off using a save and sound comparable class for your data. e.g.:
@groovy.transform.Immutable
class Pair {
long x,y
}
def p00 = new Pair(0,0)
def p11 = new Pair(1,1)
def p11o = new Pair(1,1)
assert [p00]-[p11] == [p00]
assert [p11]-[p00] == [p11]
assert [p00].intersect([p11]) == []
assert [p11].intersect([p00]) == []
assert [p11].intersect([p11o]) == [p11]
assert [p11].intersect([p11o]) == [p11o]
Even turning the maps into Expando
s works better.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With