// Find (strict) predecessor of y in coll, or return false
public static bool Predecessor <T>(ISorted <T> coll, T y, out T yPred)
where T : IComparable <T>
{
coll.Cut(y, out yPred, out var hasPred, out _, out _);
return(hasPred);
}
public void KeysISortedPred()
{
ISorted <string> keys = dict.Keys;
String res;
Assert.IsTrue(keys.TryPredecessor("S", out res));
Assert.AreEqual("R", res);
Assert.IsTrue(keys.TryWeakPredecessor("R", out res));
Assert.AreEqual("R", res);
Assert.IsTrue(keys.TrySuccessor("S", out res));
Assert.AreEqual("T", res);
Assert.IsTrue(keys.TryWeakSuccessor("T", out res));
Assert.AreEqual("T", res);
Assert.IsFalse(keys.TryPredecessor("R", out res));
Assert.AreEqual(null, res);
Assert.IsFalse(keys.TryWeakPredecessor("P", out res));
Assert.AreEqual(null, res);
Assert.IsFalse(keys.TrySuccessor("T", out res));
Assert.AreEqual(null, res);
Assert.IsFalse(keys.TryWeakSuccessor("U", out res));
Assert.AreEqual(null, res);
Assert.AreEqual("R", keys.Predecessor("S"));
Assert.AreEqual("R", keys.WeakPredecessor("R"));
Assert.AreEqual("T", keys.Successor("S"));
Assert.AreEqual("T", keys.WeakSuccessor("T"));
}
internal SortedKeysCollection(ISortedDictionary <K, V> sorteddict, ISorted <KeyValuePair <K, V> > sortedpairs, SCG.IComparer <K> comparer, SCG.IEqualityComparer <K> itemequalityComparer)
: base(itemequalityComparer)
{
this.sorteddict = sorteddict;
this.sortedpairs = sortedpairs;
this.comparer = comparer;
}
// Find (strict) successor of y in coll, or return false
public static bool Successor <T>(ISorted <T> coll, T y, out T ySucc)
where T : IComparable <T>
{
coll.Cut(y, out _, out _, out ySucc, out var hasSucc);
return(hasSucc);
}
public void KeysISorted()
{
ISorted <string> keys = dict.Keys;
Assert.IsTrue(keys.IsReadOnly);
Assert.AreEqual("R", keys.FindMin());
Assert.AreEqual("T", keys.FindMax());
Assert.IsTrue(keys.Contains("S"));
Assert.AreEqual(3, keys.Count);
// This doesn't hold, maybe because the dict uses a special key comparer?
// Assert.IsTrue(keys.SequencedEquals(new WrappedArray<string>(new string[] { "R", "S", "T" })));
Assert.IsTrue(keys.UniqueItems().All(delegate(String s) {
return(s == "R" || s == "S" || s == "T");
}));
Assert.IsTrue(keys.All(delegate(String s) {
return(s == "R" || s == "S" || s == "T");
}));
Assert.IsFalse(keys.Exists(delegate(String s) {
return(s != "R" && s != "S" && s != "T");
}));
String res;
Assert.IsTrue(keys.Find(delegate(String s) {
return(s == "R");
}, out res));
Assert.AreEqual("R", res);
Assert.IsFalse(keys.Find(delegate(String s) {
return(s == "Q");
}, out res));
Assert.AreEqual(null, res);
}
// Iterate over ]x1...x2[
public static void IterExcExc <T>(ISorted <T> coll, T x1, T x2)
where T : IComparable <T>
{
bool x1HasSucc = Successor(coll, x1, out T x1Succ);
IDirectedEnumerable <T> range = x1HasSucc ? coll.RangeFromTo(x1Succ, x2) : new ArrayList <T>();
Print(range);
}
// Iterate over ]x1...]
public static void IterExcEnd <T>(ISorted <T> coll, T x1)
where T : IComparable <T>
{
var x1HasSucc = Successor(coll, x1, out var x1Succ);
IDirectedEnumerable <T> range = x1HasSucc ? coll.RangeFrom(x1Succ) : new ArrayList <T>();
Print(range);
}
// Iterate over [...x2[
public static void IterBeginExc <T>(ISorted <T> coll, T x2)
{
foreach (T x in coll.RangeTo(x2))
{
Console.Write("{0} ", x);
}
Console.WriteLine();
}
// Iterate over [x1...]
public static void IterIncEnd <T>(ISorted <T> coll, T x1)
{
foreach (T x in coll.RangeFrom(x1))
{
Console.Write("{0} ", x);
}
Console.WriteLine();
}
// Iterate over [x1,x2[, backwards
public static void IterIncExcBackwards <T>(ISorted <T> coll, T x1, T x2)
{
foreach (T x in coll.RangeFromTo(x1, x2).Backwards())
{
Console.Write("{0} ", x);
}
Console.WriteLine();
}
// Iterate over all items, backwards
public static void IterBeginEndBackwards <T>(ISorted <T> coll)
{
foreach (T x in coll.Backwards())
{
Console.Write("{0} ", x);
}
Console.WriteLine();
}
// Iterate over [...x2]
public static void IterBeginInc <T>(ISorted <T> coll, T x2)
where T : IComparable <T>
{
var x2HasSucc = Successor(coll, x2, out var x2Succ);
IDirectedEnumerable <T> range = x2HasSucc ? coll.RangeTo(x2Succ) : coll.RangeAll();
Print(range);
}
// Find (strict) predecessor of y in coll, or return false
public static bool Predecessor <T>(ISorted <T> coll, T y, out T yPred)
where T : IComparable <T>
{
bool hasPred, hasSucc;
T ySucc;
coll.Cut(y, out yPred, out hasPred, out ySucc, out hasSucc);
return(hasPred);
}
// Find weak predecessor of y in coll, or return false
public static bool WeakPredecessor <T>(ISorted <T> coll, T y, out T yPred)
where T : IComparable <T>
{
bool hasPred, hasY = coll.Cut(y, out yPred, out hasPred, out _, out _);
if (hasY)
{
yPred = y;
}
return(hasY || hasPred);
}
// --- Predecessor and successor patterns --------------------
// Find weak successor of y in coll, or return false
public static bool WeakSuccessor <T>(ISorted <T> coll, T y, out T ySucc)
where T : IComparable <T>
{
var hasY = coll.Cut(y, out _, out _, out ySucc, out var hasSucc);
if (hasY)
{
ySucc = y;
}
return(hasY || hasSucc);
}
// Iterate over [...x2]
public static void IterBeginInc <T>(ISorted <T> coll, T x2)
where T : IComparable <T>
{
bool x2HasSucc = Successor(coll, x2, out T x2Succ);
IDirectedEnumerable <T> range =
x2HasSucc ? coll.RangeTo(x2Succ) : coll.RangeAll();
foreach (T x in range)
{
Console.Write("{0} ", x);
}
Console.WriteLine();
}
// --- Predecessor and successor patterns --------------------
// Find weak successor of y in coll, or return false
public static bool WeakSuccessor <T>(ISorted <T> coll, T y, out T ySucc)
where T : IComparable <T>
{
T yPred;
bool hasPred, hasSucc,
hasY = coll.Cut(y, out yPred, out hasPred, out ySucc, out hasSucc);
if (hasY)
{
ySucc = y;
}
return(hasY || hasSucc);
}
// Iterate over ]x1...]
public static void IterExcEnd <T>(ISorted <T> coll, T x1)
where T : IComparable <T>
{
bool x1HasSucc = Successor(coll, x1, out T x1Succ);
IDirectedEnumerable <T> range =
x1HasSucc ? coll.RangeFrom(x1Succ) : new ArrayList <T>();
foreach (T x in range)
{
Console.Write("{0} ", x);
}
Console.WriteLine();
}
// Iterate over [x1...x2]
public static void IterIncInc <T>(ISorted <T> coll, T x1, T x2)
where T : IComparable <T>
{
T x2Succ;
bool x2HasSucc = Successor(coll, x2, out x2Succ);
IDirectedEnumerable <T> range =
x2HasSucc ? coll.RangeFromTo(x1, x2Succ) : coll.RangeFrom(x1);
foreach (T x in range)
{
Console.Write("{0} ", x);
}
Console.WriteLine();
}
// --- Sorted iteration patterns -----------------------------
// Iterate over all items
public static void IterBeginEnd <T>(ISorted <T> coll)
{
Print(coll);
}
public void Test(ISorted <int> sorted)
{
sorted.AddSorted(new int[] { 31, 62, 63, 93 });
}
/// <summary>
/// Wrap a sorted collection in a read-only wrapper
/// </summary>
/// <param name="sorted"></param>
public GuardedSorted(ISorted <T> sorted) : base(sorted)
{
this.sorted = sorted;
}
// Iterate over all items, backwards
public static void IterBeginEndBackwards <T>(ISorted <T> coll)
{
var range = coll.Backwards();
Print(range);
}
// Iterate over [x1,x2[, backwards
public static void IterIncExcBackwards <T>(ISorted <T> coll, T x1, T x2)
{
var range = coll.RangeFromTo(x1, x2).Backwards();
Print(range);
}
// Iterate over [x1...]
public static void IterIncEnd <T>(ISorted <T> coll, T x1)
{
var range = coll.RangeFrom(x1);
Print(range);
}
// Iterate over [...x2[
public static void IterBeginExc <T>(ISorted <T> coll, T x2)
{
var range = coll.RangeTo(x2);
Print(range);
}
