private void Push(SetItem <K> node)
{
while (!node.IsEmpty)
{
stack.Push(node);
node = Prev(node);
}
}
public SetEnumerator(SetItem <K> root, bool rev, int start)
{
this.rev = rev;
this.start = start;
map = root;
stack = pool.GetItem();
Reset();
}
/// <summary>
/// Ctor
/// </summary>
internal SetItem(byte height, int count, K key, SetItem <K> left, SetItem <K> right)
{
Count = count;
Height = height;
Key = key;
Left = left;
Right = right;
}
public SetEnumerator(SetItem <K> root, bool rev, int start)
{
this.rev = rev;
this.start = start;
map = root;
stack = Pool <NewStack, SetItem <K>[]> .Pop();
Reset();
}
private void Push(SetItem <K> node)
{
while (!node.IsEmpty)
{
stack[stackDepth] = node;
stackDepth++;
node = Prev(node);
}
}
/// <summary>
/// Ctor that takes an initial (distinct) set of items
/// </summary>
/// <param name="items"></param>
internal SetInternal(IEnumerable <A> items, SetModuleM.AddOpt option)
{
set = SetItem <A> .Empty;
foreach (var item in items)
{
set = SetModuleM.Add <OrdA, A>(set, item, option);
}
}
public static SetItem <K> Balance <K>(SetItem <K> node) =>
node.BalanceFactor >= 2
? node.Right.BalanceFactor < 0
? DblRotLeft(node)
: RotLeft(node)
: node.BalanceFactor <= -2
? node.Left.BalanceFactor > 0
? DblRotRight(node)
: RotRight(node)
: node;
internal Set(IEnumerable <T> items)
{
set = SetItem <T> .Empty;
// TODO: Perf
foreach (var item in items)
{
set = SetModule.Add(set, item, Comparer <T> .Default);
}
}
public SetInternal <OrdA, A> AddOrUpdateRange(IEnumerable <A> xs)
{
var set = this;
foreach (var x in xs)
{
set = set.AddOrUpdate(x);
}
return(set);
}
public SetInternal <OrdA, A> TryAddRange(IEnumerable <A> xs)
{
var set = this;
foreach (var x in xs)
{
set = set.TryAdd(x);
}
return(set);
}
public static S FoldBack <S, K>(SetItem <K> node, S state, Func <S, K, S> folder)
{
if (node.IsEmpty)
{
return(state);
}
state = FoldBack(node.Right, state, folder);
state = folder(state, node.Key);
state = FoldBack(node.Left, state, folder);
return(state);
}
public bool MoveNext()
{
if (left > 0 && stack.Count > 0)
{
NodeCurrent = stack.Pop();
Push(Next(NodeCurrent));
left--;
return(true);
}
NodeCurrent = null;
return(false);
}
public bool MoveNext()
{
if (left > 0 && stackDepth > 0)
{
stackDepth--;
NodeCurrent = stack[stackDepth];
Push(Next(NodeCurrent));
left--;
return(true);
}
NodeCurrent = null;
return(false);
}
public static SetItem <K> Balance <K>(SetItem <K> node)
{
node.Height = (byte)(1 + Math.Max(node.Left.Height, node.Right.Height));
node.Count = 1 + node.Left.Count + node.Right.Count;
return(node.BalanceFactor >= 2
? node.Right.BalanceFactor < 0
? DblRotLeft(node)
: RotLeft(node)
: node.BalanceFactor <= -2
? node.Left.BalanceFactor > 0
? DblRotRight(node)
: RotRight(node)
: node);
}
/// <summary>
/// Ctor that takes an initial (distinct) set of items
/// </summary>
/// <param name="items"></param>
internal Set(IEnumerable <T> items, bool checkUniqueness = false)
{
set = SetItem <T> .Empty;
if (checkUniqueness)
{
foreach (var item in items)
{
set = SetModule.TryAdd(set, item, Comparer <T> .Default);
}
}
else
{
foreach (var item in items)
{
set = SetModule.Add(set, item, Comparer <T> .Default);
}
}
}
/// <summary>
/// Ctor that takes an initial (distinct) set of items
/// </summary>
/// <param name="items"></param>
internal SetInternal(IEnumerable <A> items, bool tryAdd)
{
set = SetItem <A> .Empty;
if (tryAdd)
{
foreach (var item in items)
{
set = SetModule.TryAdd <OrdA, A>(set, item);
}
}
else
{
foreach (var item in items)
{
set = SetModule.Add <OrdA, A>(set, item);
}
}
}
public static SetItem <K> RotLeft <K>(SetItem <K> node)
{
if (node.IsEmpty || node.Right.IsEmpty)
{
return(node);
}
var x = node;
var y = x.Right;
var t2 = y.Left;
y.Left = x;
x.Right = t2;
x.Height = (byte)(1 + Math.Max(x.Left.Height, x.Right.Height));
y.Height = (byte)(1 + Math.Max(y.Left.Height, y.Right.Height));
x.Count = 1 + x.Left.Count + x.Right.Count;
y.Count = 1 + y.Left.Count + y.Right.Count;
return(y);
}
public SetInternal <OrdA, A> AddOrUpdateRange(IEnumerable <A> xs)
{
if (xs == null)
{
return(this);
}
if (Count == 0)
{
return(new SetInternal <OrdA, A>(xs, SetModuleM.AddOpt.TryUpdate));
}
var set = this;
foreach (var x in xs)
{
set = set.AddOrUpdate(x);
}
return(set);
}
public static bool Contains <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K>
{
if (node.IsEmpty)
{
return(false);
}
var cmp = default(OrdK).Compare(key, node.Key);
if (cmp < 0)
{
return(Contains <OrdK, K>(node.Left, key));
}
else if (cmp > 0)
{
return(Contains <OrdK, K>(node.Right, key));
}
else
{
return(true);
}
}
public static SetItem <K> Remove <K>(SetItem <K> node, K key, Comparer <K> comparer)
{
if (node.IsEmpty)
{
return(node);
}
var cmp = comparer.Compare(key, node.Key);
if (cmp < 0)
{
return(Balance(Make(node.Key, Remove(node.Left, key, comparer), node.Right)));
}
else if (cmp > 0)
{
return(Balance(Make(node.Key, node.Left, Remove(node.Right, key, comparer))));
}
else
{
return(Balance(AddTreeToRight(node.Left, node.Right)));
}
}
public static Option <K> TryFind <K>(SetItem <K> node, K key, Comparer <K> comparer)
{
if (node.IsEmpty)
{
return(None);
}
var cmp = comparer.Compare(key, node.Key);
if (cmp < 0)
{
return(TryFind(node.Left, key, comparer));
}
else if (cmp > 0)
{
return(TryFind(node.Right, key, comparer));
}
else
{
return(Some(node.Key));
}
}
public static SetItem <K> TryAdd <K>(SetItem <K> node, K key, Comparer <K> comparer)
{
if (node.IsEmpty)
{
return(new SetItem <K>(1, 1, key, SetItem <K> .Empty, SetItem <K> .Empty));
}
var cmp = comparer.Compare(key, node.Key);
if (cmp < 0)
{
return(Balance(Make(node.Key, TryAdd(node.Left, key, comparer), node.Right)));
}
else if (cmp > 0)
{
return(Balance(Make(node.Key, node.Left, TryAdd(node.Right, key, comparer))));
}
else
{
return(node);
}
}
public static SetItem <K> Add <K>(SetItem <K> node, K key, Comparer <K> comparer)
{
if (node.IsEmpty)
{
return(new SetItem <K>(1, 1, key, SetItem <K> .Empty, SetItem <K> .Empty));
}
var cmp = comparer.Compare(key, node.Key);
if (cmp < 0)
{
return(Balance(Make(node.Key, Add(node.Left, key, comparer), node.Right)));
}
else if (cmp > 0)
{
return(Balance(Make(node.Key, node.Left, Add(node.Right, key, comparer))));
}
else
{
throw new ArgumentException("An element with the same key already exists in the set");
}
}
public static Option <K> TryFind <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K>
{
if (node.IsEmpty)
{
return(None);
}
var cmp = default(OrdK).Compare(key, node.Key);
if (cmp < 0)
{
return(TryFind <OrdK, K>(node.Left, key));
}
else if (cmp > 0)
{
return(TryFind <OrdK, K>(node.Right, key));
}
else
{
return(Some(node.Key));
}
}
public static K Find <K>(SetItem <K> node, K key, Comparer <K> comparer)
{
if (node.IsEmpty)
{
throw new ArgumentException("Key not found in set");
}
var cmp = comparer.Compare(key, node.Key);
if (cmp < 0)
{
return(Find(node.Left, key, comparer));
}
else if (cmp > 0)
{
return(Find(node.Right, key, comparer));
}
else
{
return(node.Key);
}
}
public static SetItem <K> Add <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K>
{
if (node.IsEmpty)
{
return(new SetItem <K>(1, 1, key, SetItem <K> .Empty, SetItem <K> .Empty));
}
var cmp = default(OrdK).Compare(key, node.Key);
if (cmp < 0)
{
return(Balance(Make(node.Key, Add <OrdK, K>(node.Left, key), node.Right)));
}
else if (cmp > 0)
{
return(Balance(Make(node.Key, node.Left, Add <OrdK, K>(node.Right, key))));
}
else
{
throw new ArgumentException("An element with the same key already exists in the set");
}
}
public static SetItem <K> Remove <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K>
{
if (node.IsEmpty)
{
return(node);
}
var cmp = default(OrdK).Compare(key, node.Key);
if (cmp < 0)
{
return(Balance(Make(node.Key, Remove <OrdK, K>(node.Left, key), node.Right)));
}
else if (cmp > 0)
{
return(Balance(Make(node.Key, node.Left, Remove <OrdK, K>(node.Right, key))));
}
else
{
return(Balance(AddTreeToRight(node.Left, node.Right)));
}
}
public static SetItem <K> AddOrUpdate <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K>
{
if (node.IsEmpty)
{
return(new SetItem <K>(1, 1, key, SetItem <K> .Empty, SetItem <K> .Empty));
}
var cmp = default(OrdK).Compare(key, node.Key);
if (cmp < 0)
{
return(Balance(Make(node.Key, TryAdd <OrdK, K>(node.Left, key), node.Right)));
}
else if (cmp > 0)
{
return(Balance(Make(node.Key, node.Left, TryAdd <OrdK, K>(node.Right, key))));
}
else
{
return(new SetItem <K>(node.Height, node.Count, key, node.Left, node.Right));
}
}
public static K Find <OrdK, K>(SetItem <K> node, K key) where OrdK : struct, Ord <K>
{
if (node.IsEmpty)
{
throw new ArgumentException("Key not found in set");
}
var cmp = default(OrdK).Compare(key, node.Key);
if (cmp < 0)
{
return(Find <OrdK, K>(node.Left, key));
}
else if (cmp > 0)
{
return(Find <OrdK, K>(node.Right, key));
}
else
{
return(node.Key);
}
}
public static bool Contains <K>(SetItem <K> node, K key, Comparer <K> comparer)
{
if (node.IsEmpty)
{
return(false);
}
var cmp = comparer.Compare(key, node.Key);
if (cmp < 0)
{
return(Contains(node.Left, key, comparer));
}
else if (cmp > 0)
{
return(Contains(node.Right, key, comparer));
}
else
{
return(true);
}
}
