public void IsSorted_CustomComparerWithNullEnumerable_ViolatesPrecondition()
{
// Arrange
SCG.IEnumerable <int> enumerable = null;
var comparer = ComparerFactory.CreateComparer <int>((x, y) => x.CompareTo(y));
// Act & Assert
// ReSharper disable once ExpressionIsAlwaysNull
Assert.That(() => enumerable.IsSorted(comparer), Violates.PreconditionSaying(ArgumentMustBeNonNull));
}
public void IsSorted_ReversedComparer_IsSortedInReverse(int[] array)
{
// Arrange
var comparer = ComparerFactory.CreateComparer <int>((x, y) => y.CompareTo(x));
// Act
var isSorted = array.IsSorted(comparer);
// Assert
Assert.That(isSorted, Is.True);
}
public void IsSorted_CustomComparer_IsNotSorted(int[] array)
{
// Arrange
var comparer = ComparerFactory.CreateComparer <int>((x, y) => x.CompareTo(y));
// Act
var isSorted = array.IsSorted(comparer);
// Assert
Assert.That(isSorted, Is.False);
}
// Fast for array lists and similar, but not stable; slow for linked lists
public static ArrayList <int> GetPermutation1 <T>(IList <T> lst)
where T : IComparable <T>
{
ArrayList <int> res = new ArrayList <int>(lst.Count);
for (int i = 0; i < lst.Count; i++)
{
res.Add(i);
}
res.Sort(ComparerFactory <int> .CreateComparer((i, j) => lst[i].CompareTo(lst[j])));
return(res);
}
public void Keys_returns_GuardedSorted()
{
var reverse = ComparerFactory <int> .CreateComparer((a, b) => a > b? -1 : 1);
var source = new SortedArrayDictionary <int, string>(reverse)
{
[1] = "one",
[2] = "two",
[3] = "three"
};
var guarded = new GuardedSortedDictionary <int, string>(source);
Assert.IsAssignableFrom <GuardedSorted <int> >(guarded.Keys);
}
public void Values_returns_Values()
{
var reverse = ComparerFactory <int> .CreateComparer((a, b) => a > b? -1 : 1);
var source = new SortedArrayDictionary <int, string>(reverse)
{
[1] = "one",
[2] = "two",
[3] = "three"
};
var guarded = new GuardedSortedDictionary <int, string>(source);
CollectionAssert.AreEquivalent(new[] { "one", "two", "three" }, guarded.Values);
}
private IPriorityQueue <int> InitializePriorityQueue()
{
IComparer <int> weightComparer = ComparerFactory <int> .CreateComparer(
(a, b) => _distance[a].CompareTo(_distance[b]));
IPriorityQueue <int> priorityQueue =
new IntervalHeap <int>(weightComparer);
_queueItemHandles = new IPriorityQueueHandle <int> [_nodes.Count];
for (var i = 0; i < _nodes.Count; i++)
{
IPriorityQueueHandle <int> itemHandle = null;
priorityQueue.Add(ref itemHandle, i);
_queueItemHandles[i] = itemHandle;
}
return(priorityQueue);
}
public static void Main(String[] args)
{
// SortedArray<Object> sarr = new SortedArray<Object>();
var lexico = ComparerFactory <Rec <string, int> > .CreateComparer(
(r1, r2) =>
{
int order = r1.X1.CompareTo(r2.X1);
return(order == 0 ? r1.X2.CompareTo(r2.X2) : order);
}
);
SortedArray <Rec <string, int> > sarr = new SortedArray <Rec <string, int> >(lexico);
sarr.Add(new Rec <string, int>("ole", 32));
sarr.Add(new Rec <string, int>("hans", 77));
sarr.Add(new Rec <string, int>("ole", 63));
foreach (Rec <string, int> r in sarr)
{
Console.WriteLine(r);
}
}
public static void Main()
{
var lexico = ComparerFactory <Rec <string, int> > .CreateComparer(
(r1, r2) =>
{
int order = r1.X1.CompareTo(r2.X1);
return(order == 0 ? r1.X2.CompareTo(r2.X2) : order);
}
);
SortedArray <Rec <string, int> > sarr = new SortedArray <Rec <string, int> >(lexico)
{
new Rec <string, int>("ole", 32),
new Rec <string, int>("hans", 77),
new Rec <string, int>("ole", 63)
};
foreach (var r in sarr)
{
Console.WriteLine(r);
}
}
static void PrintMostCommon(int maxWords, string filename)
{
var wordbag = new HashBag <string>();
var delimiter = new Regex("[^a-zA-Z0-9]+");
using (var reader = File.OpenText(filename))
{
for (var line = reader.ReadLine(); line != null; line = reader.ReadLine())
{
foreach (var s in delimiter.Split(line))
{
if (s != "")
{
wordbag.Add(s);
}
}
}
}
var frequency = wordbag.ItemMultiplicities().ToArray();
Sorting.IntroSort(frequency, 0, frequency.Length,
// Lexicographic ordering: decreasing frequency, then increasing string
ComparerFactory <KeyValuePair <string, int> > .CreateComparer(
(p1, p2) =>
{
int major = p2.Value.CompareTo(p1.Value);
return(major != 0 ? major : p1.Key.CompareTo(p2.Key));
}));
var stop = Math.Min(frequency.Length, maxWords);
for (var i = 0; i < stop; i++)
{
var p = frequency[i];
Console.WriteLine("{0,4} occurrences of {1}", p.Value, p.Key);
}
}
private static SCG.IComparer <T> ReverseComparer <T>(SCG.IComparer <T> cmp)
{
return(ComparerFactory <T> .CreateComparer((item1, item2) => cmp.Compare(item2, item1)));
}
public static void Main()
{
//var eq = new C6.ComparerFactory.EqualityComparer<string>(ReferenceEquals,
// SCG.EqualityComparer<string>.Default.GetHashCode);
//var items = new[] { "-8", "Ab", "6", "-4", "5", "-2", "-1", "1", "10", "8" };
//var al = new ArrayList<string>(items);
//var v1 = al.View(al.Count - 2, 2);
//var v2 = al.View(al.Count - 2, 2);
var items = new[] { "-8", "Ab", "6", "-4", "5", "-2", "-1", "1", "10", "8" };
var collection = new HashedArrayList <string>(items);
Console.WriteLine(collection.Contains("10"));
Console.WriteLine(collection.Add("10"));
// BUG: Sorting
//var items = new[] { "-8", "Ab", "6", "-4", "5", "-2", "-1", "1", "10", "8" };
//var collection = new HashedLinkedList<string>(items);
//var v0 = collection.View(0, 2);
//var v2 = collection.View(1, 2);
//var v4 = collection.View(4, 2);
//var v6 = collection.View(7, 1);
//var vCount2 = collection.View(collection.Count - 2, 2);
//Console.WriteLine("Views before calling Sort()");
//Console.WriteLine($"v0 = {v0}");
//Console.WriteLine($"v2 = {v2}");
//Console.WriteLine($"v4 = {v4}");
//Console.WriteLine($"v6 = {v6}");
//Console.WriteLine($"vCount2 = {vCount2}");
//v4.Sort();
//Console.WriteLine("Views after calling Sort()");
//Console.WriteLine($"v0 = {v0}");
//Console.WriteLine($"v2 = {v2}");
//Console.WriteLine($"v4 = {v4}");
//Console.WriteLine($"v6 = {v6}");
//Console.WriteLine($"vCount2 = {vCount2}");
// ==============================
// RemoveRange
//var items = new[] { "8", "Ab", "3", "4", "5", "6", "7", "9" };
//var collection = new ArrayList<string>(items);
//var view1 = collection.View(0, 1); // longer
//var view2 = collection.View(0, 2);
//var item = view1.Choose();
//var itms = new ArrayList<string>(new[] { item });
//view1.RemoveRange(itms);
//Console.WriteLine(view2);
//var items = new[] { "8", "Ab", "3", "4", "5", "6", "7", "9" };
// HLL.Reverse
//var items = new[] { "a", "b", "c", "d", "e" };
//var linkedList = new ArrayList<string>(items);
//var v1 = linkedList.View(0, linkedList.Count);
//var v2 = linkedList.View(0, 2);
//v1.Reverse();
//v1.Reverse();
//Console.WriteLine(v2);
// HLL.Sort
//var items = new[] { "b", "a", "c", "e", "d" };
//var linkedList = new HashedLinkedList<string>(items);
//var v1 = linkedList.View(0, 3);
//var v2 = linkedList.View(3, 2);
//v1.Sort();
//Console.WriteLine(v1);
//Console.WriteLine(v2);
// HAL.Add()
//var items = new[] { "8", "Ab", "3", "4", "5", "6", "7", "9" };
//var arrayList = new LinkedList<string>(items);
//var v1 = arrayList.View(0, 7);
//var v2 = arrayList.View(0, 7);
//v1.Add("333333333");
//Console.WriteLine(v1);
//Console.WriteLine(v2);
//Console.WriteLine(view1.IsValid);
//Console.WriteLine(view);
//Console.WriteLine(collection);
return;
// Construct list using collection initializer
//var list = new ArrayList<int>() { 2, 3, 5, 5, 7, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31, 33};
var list = new ArrayList <int>()
{
2, 3
};
var backList = list.Backwards();
backList.ToList().ForEach(x => Console.Write(x + ", "));
Console.WriteLine(backList.IsValid);
list.Add(10);
Console.WriteLine(backList.IsValid);
//backList.ToList().ForEach(x => Console.Write(x));
//var list = list1.View(2, list1.Count-2);
//var v = list.View(3,4);
//var v2 = v.View(1, 2);
//var items = new ArrayList<int>() { 3, 13, 7, 17};
//Console.WriteLine(ArrayList<int>.EmptyArray);
var dupl = list.FindDuplicates(5);
Console.WriteLine(dupl);
list.Add(-100);
var arr = dupl.ToArray();
list.Dispose();
//en.ToList().ForEach(x => Console.WriteLine(x));
//Console.WriteLine(v);
//Console.WriteLine(v2);
//Console.WriteLine(list);
return;
// Get index of item
var index = list.IndexOf(23);
// Get an index range
var range = list.GetIndexRange(index, 4);
// Print range in reverse order
foreach (var prime in range.Backwards())
{
Console.WriteLine(prime);
}
// Remove items within index range
list.RemoveIndexRange(10, 3);
// Remove item at index
var second = list.RemoveAt(1);
// Remove first item
var first = list.RemoveFirst();
// Remove last item
var last = list.RemoveLast();
// Create array with items in list
var array = list.ToArray();
// Clear list
list.Clear();
// Check if list is empty
var isEmpty = list.IsEmpty;
// Add item
list.Add(first);
// Add items from enumerable
list.AddRange(array);
// Insert item into list
list.Insert(1, second);
// Add item to the end
list.Add(last);
// Check if list is sorted
var isSorted = list.IsSorted();
// Reverse list
list.Reverse();
// Check if list is sorted
var reverseComparer = ComparerFactory.CreateComparer <int>((x, y) => y.CompareTo(x));
isSorted = list.IsSorted(reverseComparer);
// Shuffle list
var random = new Random(0);
list.Shuffle(random);
// Print list using indexer
for (var i = 0; i < list.Count; i++)
{
Console.WriteLine($"{i,2}: {list[i],2}");
}
// Check if list contains all items in enumerable
var containsRange = list.ContainsRange(array);
// Construct list using enumerable
var otherList = new ArrayList <int>(array);
// Add every third items from list
otherList.AddRange(list.Where((x, i) => i % 3 == 0));
containsRange = list.ContainsRange(otherList);
// Remove all items not in enumerable
otherList.RetainRange(list);
// Remove all items in enumerable from list
list.RemoveRange(array);
// Sort list
list.Sort();
// Copy to array
list.CopyTo(array, 2);
return;
}
public IPath AStar(Graph graph, INode start, INode destination)
{
// this is more or less copy pasted from wikipedia, this is definitely not optimized
//
// now there's actually a PriorityQueue used, however I doubt it to be actually performant.
//
// reference:
// https://en.wikipedia.org/wiki/A*_search_algorithm#Pseudocode
var closedList = new List <INode>();
// var openList = new List<INode> {start};
// openList.Comparer = null;
var cameFrom = new Dictionary <INode, INode>();
var gScore = new Dictionary <INode, float>();
var fScore = new Dictionary <INode, float>();
// ReSharper disable once ConvertToLocalFunction
// converting to local function does not work
Func <INode, INode, int> compareFunc = (a, b) => (int)fScore[a] > (int)fScore[b] ? 1 : (int)fScore[a] < (int)fScore[b] ? -1 : 0;
var openList = new IntervalHeap <INode>(ComparerFactory <INode> .CreateComparer(compareFunc))
{
start
};
foreach (var node in graph.GetNodes())
{
gScore[node] = int.MaxValue;
fScore[node] = int.MaxValue;
}
gScore[start] = 0f;
fScore[start] = HeuristicCostEstimate(start, destination);
while (openList.Count > 0)
{
var current = openList.DeleteMin();
// current can never be null from my short amount of thinking about it (if actual arguments are given)
Debug.Assert(current != null, "pathFinding failed.");
if (current.Equals(destination))
{
return(ReconstructPath(cameFrom, current));
}
closedList.Add(current);
foreach (var outgoing in current.GetOutwardsEdges())
{
var neighbor = outgoing.GetChild();
if (neighbor == null || ((Road)outgoing).Blueprint)
{
continue;
}
if (closedList.Contains(neighbor))
{
continue;
}
if (!openList.Contains(neighbor))
{
openList.Add(neighbor);
}
var tentativeGScore = gScore[current] + outgoing.GetCost();
if (tentativeGScore >= gScore[neighbor])
{
continue;
}
cameFrom[neighbor] = current;
gScore[neighbor] = tentativeGScore;
fScore[neighbor] = gScore[neighbor] + HeuristicCostEstimate(neighbor, destination);
}
foreach (var outgoing in current.GetInwardsEdges())
{
var neighbor = outgoing.GetParent();
if (neighbor == null || ((PlatformBlank)neighbor).mBlueprint)
{
continue;
}
if (closedList.Contains(neighbor))
{
continue;
}
if (!openList.Contains(neighbor))
{
openList.Add(neighbor);
}
var tentativeGScore = gScore[current] + outgoing.GetCost();
if (tentativeGScore >= gScore[neighbor])
{
continue;
}
cameFrom[neighbor] = current;
gScore[neighbor] = tentativeGScore;
fScore[neighbor] = gScore[neighbor] + HeuristicCostEstimate(neighbor, destination);
}
}
return(null);
}
public bool Satisfies(Task task)
{
return(ComparerFactory.CreateComparer(OperatorType).Compare(Value, ValueSelector(task)));
}
static SCG.IComparer <Rec <string, int> > Lexico2() => ComparerFactory <Rec <string, int> > .CreateComparer((item1, item2) =>
{
var major = item1.X1.CompareTo(item2.X1);
return(major != 0 ? major : item1.X2.CompareTo(item2.X2));
});
static SCG.IComparer <T> ReverseComparer <T>(SCG.IComparer <T> cmp) => ComparerFactory <T> .CreateComparer((item1, item2) => cmp.Compare(item2, item1));
public void Main()
{
// Construct list using collection initializer
var list = new ArrayList <int> {
2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47
};
// Get index of item
var index = list.IndexOf(23);
// Get an index range
var range = list.GetIndexRange(index, 4);
// Print range in reverse order
foreach (var prime in range.Backwards())
{
Console.WriteLine(prime);
}
// Remove items within index range
list.RemoveIndexRange(10, 3);
// Remove item at index
var second = list.RemoveAt(1);
// Remove first item
var first = list.RemoveFirst();
// Remove last item
var last = list.RemoveLast();
// Create array with items in list
var array = list.ToArray();
// Clear list
list.Clear();
// Check if list is empty
var isEmpty = list.IsEmpty;
// Add item
list.Add(first);
// Add items from enumerable
list.AddRange(array);
// Insert item into list
list.Insert(1, second);
// Add item to the end
list.Add(last);
// Check if list is sorted
var isSorted = list.IsSorted();
// Reverse list
list.Reverse();
// Check if list is sorted
var reverseComparer = ComparerFactory.CreateComparer <int>((x, y) => y.CompareTo(x));
isSorted = list.IsSorted(reverseComparer);
// Shuffle list
var random = new Random(0);
list.Shuffle(random);
// Print list using indexer
for (var i = 0; i < list.Count; i++)
{
Console.WriteLine($"{i,2}: {list[i],2}");
}
// Check if list contains all items in enumerable
var containsRange = list.ContainsRange(array);
// Construct list using enumerable
var otherList = new ArrayList <int>(array);
// Add every third items from list
otherList.AddRange(list.Where((x, i) => i % 3 == 0));
containsRange = list.ContainsRange(otherList);
// Remove all items not in enumerable
otherList.RetainRange(list);
// Remove all items in enumerable from list
list.RemoveRange(array);
// Sort list
list.Sort();
// Copy to array
list.CopyTo(array, 2);
return;
}
