public bool IsProperSupersetOf(UintSet other)
{
bool atLeastOneProperSuperset = false;
int i = 0;
for (; i < sets.Length && i < other.sets.Length; i++)
{
if (!atLeastOneProperSuperset && sets[i].IsProperSupersetOf(other.sets[i]))
{
atLeastOneProperSuperset = true;
}
else if (!sets[i].IsSupersetOf(other.sets[i]))
{
return(false);
}
}
if (atLeastOneProperSuperset)
{
return(true);
}
for (; i < other.sets.Length; i++)
{
if (other.sets[i].Any())
{
return(true);
}
}
return(false);
}
public UintSet SymmetricExcept(UintSet other)
{
var(self, except) = (this, other);
IEnumerable <ImmutableSet64> exceptWith()
{
int i = 0;
for (; i < self.sets.Length && i < except.sets.Length; i++)
{
yield return(self.sets[i].SymmetricExcept(except.sets[i]));
}
if (self.sets.Length > except.sets.Length)
{
for (; i < self.sets.Length; i++)
{
yield return(self.sets[i]);
}
}
else
{
for (; i < except.sets.Length; i++)
{
yield return(except.sets[i]);
}
}
}
return(new UintSet(exceptWith()));
}
public bool Overlaps(UintSet other)
{
for (int i = 0; i < sets.Length && i < other.sets.Length; i++)
{
if (sets[i].Overlaps(other.sets[i]))
{
return(true);
}
}
return(false);
}
public bool IsSupersetOf(UintSet other)
{
var(small, large) = sets.Length < other.sets.Length ? (this, other) : (other, this);
for (int i = 0; i < small.sets.Length; i++)
{
if (!small.sets[i].IsSupersetOf(large.sets[i]))
{
return(false);
}
}
return(true);
}
public bool SetEquals(UintSet other)
{
if (sets.Length != other.sets.Length)
{
return(false);
}
for (int i = 0; i < sets.Length; i++)
{
if (!sets[i].SetEquals(other.sets[i]))
{
return(false);
}
}
return(true);
}
public UintSet Intersect(UintSet other)
{
var(self, intersect) = (this, other);
IEnumerable <ImmutableSet64> intersectWith()
{
int i = 0;
for (; i < self.sets.Length && i < intersect.sets.Length; i++)
{
yield return(self.sets[i].Intersect(intersect.sets[i]));
}
}
return(new UintSet(intersectWith()));
}
private static UintSet shiftDown(UintSet set)
{
var s = set;
IEnumerable <ImmutableSet64> shifted()
{
for (int i = 0; i < s.sets.Length - 1; i++)
{
yield return((s.sets[i] << 1).Union(s.sets[i + 1] >> 63));
}
if (s.sets.Length > 0)
{
yield return(s.sets[s.sets.Length - 1] << 1);
}
}
return(new UintSet(shifted()));
}
public UintSet Union(UintSet other)
{
var(small, large) = sets.Length < other.sets.Length ? (this, other) : (other, this);
IEnumerable <ImmutableSet64> union()
{
int i = 0;
for (; i < small.sets.Length; i++)
{
yield return(small.sets[i].Union(large.sets[i]));
}
for (; i < large.sets.Length; i++)
{
yield return(large.sets[i]);
}
}
return(new UintSet(union()));
}
private static UintSet shiftUp(UintSet set)
{
var s = set;
IEnumerable <ImmutableSet64> shifted()
{
if (s.sets.Length == 0)
{
yield break;
}
yield return(s.sets[0] >> 1);
for (int i = 1; i < s.sets.Length; i++)
{
yield return((s.sets[i] >> 1).Union(s.sets[i - 1] << 63));
}
}
return(new UintSet(shifted()));
}
public SomeSet(uint max, UintSet included) => (Included, _max) = (included, max);
internal UintSet(UintSet copy)
{
sets = copy.sets;
_count = copy._count;
}
