public IntSet Union(IntSet r, bool cloneWhenOneIsEmpty = false)
{
// Union of inverted sets is accomplished via intersection code: ~a | ~b => ~(a & b)
IntSet l = this;
if (l.IsInverted || r.IsInverted)
{
if (!l.IsInverted)
{
l = l.EquivalentInverted();
}
if (!r.IsInverted)
{
r = r.EquivalentInverted();
}
return(New(l.IsInverted ? r : l, true, IntersectCore(l, r)));
}
else
{
if (cloneWhenOneIsEmpty)
{
if (l._ranges.Count == 0)
{
return(r.Clone());
}
if (r._ranges.Count == 0)
{
return(l.Clone());
}
}
return(New(this, false, UnionCore(l, r)));
}
}
public void RandomTests()
{
int seed = Environment.TickCount;
for (int test = 0; test < 100; test++)
{
var r = new Random(seed + test);
IntSet a = RandomIntSet(r), b = RandomIntSet(r);
IsFalse(a.IsEmptySet);
IsFalse(b.IsEmptySet);
var union = a.Union(b);
var intsc = a.Intersection(b);
var dif = a.Subtract(b);
AreEqual(union.Equals(intsc), a.Equals(b));
for (int i = -10; i < 20; i++)
{
bool ina = a.Contains(i), inb = b.Contains(i);
AreEqual(ina || inb, union.Contains(i));
AreEqual(ina && inb, intsc.Contains(i));
AreEqual(ina && !inb, dif.Contains(i));
}
var eInv = a.EquivalentInverted();
IsTrue(a.Equals(eInv, IntSet.S_Equivalent));
IsFalse(a.Equals(eInv, IntSet.S_Identical));
IsFalse(a.Equals(eInv, IntSet.S_SameRangeList));
var inv = eInv.Clone();
inv = inv.Inverted();
IsFalse(inv.Equals(eInv));
IsTrue(inv.Equals(eInv, IntSet.S_SameRangeList));
IntSet all = a.Union(inv), none = a.Intersection(inv);
IsFalse(all.IsEmptySet);
IsTrue(none.IsEmptySet);
IsFalse(all.Equals(none));
AreEqual(all.IsInverted ? 0 : 1, all.Count);
AreEqual(none.IsInverted ? 1 : 0, none.Count);
AreEqual(all, all.Union(none));
AreEqual(all, all.Union(a));
AreEqual(none, all.Intersection(none));
AreEqual(a, all.Intersection(a));
AreEqual(a, a.Subtract(none));
all = all.Inverted();
IsTrue(all.Equals(none));
}
}
public bool Equals(IntSet other, Symbol mode)
{
if (IsInverted == other.IsInverted)
{
return(_ranges.AllEqual(other._ranges));
}
if (mode == S_Equivalent)
{
int dif = _ranges.Count - other._ranges.Count;
return(dif >= -1 && dif <= 1 && _ranges.AllEqual(other.EquivalentInverted()._ranges));
}
else
{
return(mode == S_SameRangeList && _ranges.AllEqual(other._ranges));
}
}
public IntSet Intersection(IntSet r, bool subtract = false, bool subtractThis = false)
{
IntSet l = this, oldr = r;
bool lInv = l.IsInverted ^ subtractThis, rInv = r.IsInverted ^ subtract;
if (lInv && rInv)
{
IntSet cl = null;
if (l._ranges.Count == 0)
{
cl = r;
}
if (r._ranges.Count == 0)
{
cl = l;
}
if (cl != null)
{
if (!cl.IsInverted)
{
cl = cl.Inverted();
}
return(cl);
}
else
{
return(New(this, true, UnionCore(l, r)));
}
}
else
{
if (lInv)
{
l = l.EquivalentInverted();
}
if (rInv)
{
r = r.EquivalentInverted();
}
return(New(lInv ? r : l, false, IntersectCore(l, r)));
}
}
