public void Subsum_Random()
{
for (int k = 0; k < 10; k++)
{
for (int n = 0; n < 10; n++)
{
Test(n);
}
for (int n = 250; n < 260; n++)
{
Test(n);
}
}
void Test(int n)
{
var a = RandomHelper.CreateData(n);
var s = new int[n + 1];
var st = new ST_Subsum(n);
for (int i = 0; i < n; i++)
{
s[i + 1] = s[i] + a[i];
st.Add(i, a[i]);
}
for (int i = 0; i < n; i++)
{
for (int j = i; j <= n; j++)
{
Assert.AreEqual(s[j] - s[i], st.Subsum(i, j));
}
}
}
}
public void LastGt_Random()
{
for (int k = 0; k < 10; k++)
{
for (int n = 0; n < 10; n++)
{
Test(n);
}
for (int n = 1000; n < 1010; n++)
{
Test(n);
}
}
void Test(int n)
{
var a = RandomHelper.CreateData(n).OrderBy(x => - x).ToArray();
for (int x = -2; x < n + 2; x++)
{
var actual = BinarySearch.LastGt(a, x);
Assert.IsTrue(actual == -1 || a[actual] > x);
Assert.IsTrue(actual == n - 1 || a[actual + 1] <= x);
}
}
}
public void Bst()
{
var n = 100000;
var a = RandomHelper.CreateData(n);
var expected = (int[])a.Clone();
var actual = new List <int>();
var q = new BstPriorityQueue <int>();
foreach (var x in a)
{
q.Push(x);
}
while (q.Count > 0)
{
actual.Add(q.Pop());
}
Array.Sort(expected);
CollectionAssert.AreEqual(expected, actual);
actual.Clear();
q = new BstPriorityQueue <int>(ComparerHelper <int> .Create(true));
foreach (var x in a)
{
q.Push(x);
}
while (q.Count > 0)
{
actual.Add(q.Pop());
}
Array.Reverse(expected);
CollectionAssert.AreEqual(expected, actual);
}
public void FirstGt_Random()
{
for (int k = 0; k < 10; k++)
{
for (int n = 0; n < 10; n++)
{
Test(n);
}
for (int n = 1000; n < 1010; n++)
{
Test(n);
}
}
void Test(int n)
{
var a = RandomHelper.CreateData(n).OrderBy(x => x).ToArray();
for (int x = -2; x < n + 2; x++)
{
var actual = BinarySearch.First(0, n, i => a[i] > x);
Assert.IsTrue(actual == n || a[actual] > x);
Assert.IsTrue(actual == 0 || a[actual - 1] <= x);
}
}
}
public void Keyed_1()
{
var n = 100000;
var a = RandomHelper.CreateData(n);
var actual = new List <int>();
var q = new KeyedPriorityQueue <int, int>(x => x / 10);
foreach (var x in a)
{
q.Push(x);
}
while (q.Count > 0)
{
actual.Add(q.Pop());
}
var expected = a.OrderBy(x => x / 10).ToArray();
CollectionAssert.AreEqual(expected, actual);
actual.Clear();
q = new KeyedPriorityQueue <int, int>(x => x / 10, ComparerHelper <int> .Create(true));
foreach (var x in a)
{
q.Push(x);
}
while (q.Count > 0)
{
actual.Add(q.Pop());
}
expected = a.OrderByDescending(x => x / 10).ToArray();
CollectionAssert.AreEqual(expected, actual);
}
public void HeapSort_Key_Desc()
{
var values = RandomHelper.CreateData(300000);
var actual = TimeHelper.Measure(() => values.HeapSort(x => x.ToString(), true).Take(1000).ToArray());
var expected = TimeHelper.Measure(() => values.OrderByDescending(x => x.ToString()).Take(1000).ToArray());
CollectionAssert.AreEqual(expected, actual);
}
public void HeapSort_Asc()
{
var values = RandomHelper.CreateData(300000);
var actual = TimeHelper.Measure(() => values.HeapSort().Take(1000).ToArray());
var expected = TimeHelper.Measure(() => values.OrderBy(x => x).Take(1000).ToArray());
CollectionAssert.AreEqual(expected, actual);
}
public void AddForOrder_Key()
{
var values = RandomHelper.CreateData(10000).ToArray();
var actual = new OrderedList<int, int>(x => x / 10);
foreach (var v in values)
actual.AddForOrder(v);
CollectionAssert.AreEqual(values.OrderBy(x => x / 10).ToArray(), actual.Select(p => p.Value).ToArray());
}
public void AddForOrder()
{
var values = RandomHelper.CreateData(100000).ToArray();
var actual = new OrderedList();
foreach (var v in values)
actual.AddForOrder(v);
CollectionAssert.AreEqual(values.OrderBy(x => x).ToArray(), actual);
}
public void CreateData()
{
var actual1 = RandomHelper.CreateData(100);
var actual2 = RandomHelper.CreateData(100, -520, -500);
var actual3 = RandomHelper.CreateData(50, 300, 800);
var actual4 = RandomHelper.CreateData(50, Math.PI / 2, Math.PI);
Assert.Inconclusive("Start debugging and check actual data.");
}
public void Dequeue()
{
var values = RandomHelper.CreateData(100000).ToArray();
var actual = new OrderedList(values);
for (int v1 = actual.Dequeue(), v2; actual.Count > 0; v1 = v2)
{
v2 = actual.Dequeue();
Assert.IsTrue(v1 <= v2);
}
}
public void Sort0()
{
var values = RandomHelper.CreateData(100000).ToArray();
var actual = new List<int>();
foreach (var v in values)
{
var i = actual.BinarySearch(v);
actual.Insert(i < 0 ? ~i : i, v);
}
CollectionAssert.AreEqual(values.OrderBy(x => x).ToArray(), actual);
}
public void BucketSort_Int()
{
var n = 300000;
var a = RandomHelper.CreateData(n);
var a1 = (int[])a.Clone();
var e1 = (int[])a.Clone();
TimeHelper.Measure(() => BucketSortHelper.BucketSort(a1, n));
TimeHelper.Measure(() => Array.Sort(e1));
CollectionAssert.AreEqual(e1, a1);
}
public void RadixSort_Int32()
{
var n = 300000;
var a = RandomHelper.CreateData(n, int.MinValue, int.MaxValue);
var a1 = (int[])a.Clone();
var e1 = (int[])a.Clone();
TimeHelper.Measure(() => RadixSortHelper.RadixSort(a1));
TimeHelper.Measure(() => Array.Sort(e1));
CollectionAssert.AreEqual(e1, a1);
}
public void Create()
{
var n = 100000;
var expected = RandomHelper.CreateData(n);
var actual = (int[])expected.Clone();
Array.Sort(expected);
Array.Sort(actual, ComparerHelper <int> .Create());
CollectionAssert.AreEqual(expected, actual);
Array.Reverse(expected);
Array.Sort(actual, ComparerHelper <int> .Create(true));
CollectionAssert.AreEqual(expected, actual);
}
public void SortDescending_String()
{
var values = RandomHelper.CreateData(100000).ToArray();
var actual = TimeHelper.Measure(() => PQ1 <int> .Create(x => x.ToString(), values, true));
var a = new List <int>();
TimeHelper.Measure(() => { while (actual.Any)
{
a.Add(actual.Pop());
}
});
var e = TimeHelper.Measure(() => values.OrderByDescending(x => x.ToString()).ToArray());
CollectionAssert.AreEqual(e, a);
}
public void SortDescending()
{
var values = RandomHelper.CreateData(100000).ToArray();
var actual = TimeHelper.Measure(() => PQ1 <int> .Create(values, true));
var a = new int[values.Length];
TimeHelper.Measure(() => { for (var i = 0; i < a.Length; i++, actual.Pop())
{
a[i] = actual.First;
}
});
var e = TimeHelper.Measure(() => values.OrderByDescending(x => x).ToArray());
CollectionAssert.AreEqual(e, a);
}
public void Create_Key1()
{
var n = 100000;
var a = RandomHelper.CreateData(n);
var actual = (int[])a.Clone();
var expected = a.OrderBy(x => x.ToString()).ToArray();
Array.Sort(actual, ComparerHelper <int> .Create(x => x.ToString()));
CollectionAssert.AreEqual(expected, actual);
Array.Reverse(expected);
Array.Sort(actual, ComparerHelper <int> .Create(x => x.ToString(), true));
CollectionAssert.AreEqual(expected, actual);
}
public void Create_Key2()
{
var n = 100000;
var a = RandomHelper.CreateData(n);
var actual = (int[])a.Clone();
var expected = a.OrderBy(x => x.ToString().Length).ThenByDescending(x => x).ToArray();
Array.Sort(actual, ComparerHelper <int> .Create(x => x.ToString().Length, false, x => x, true));
CollectionAssert.AreEqual(expected, actual);
Array.Reverse(expected);
Array.Sort(actual, ComparerHelper <int> .Create(x => x.ToString().Length, true, x => x, false));
CollectionAssert.AreEqual(expected, actual);
}
public void Sort()
{
var values = RandomHelper.CreateData(100000).ToArray();
var actual = TimeHelper.Measure(() => PQ1 <int> .Create(values));
var a = new int[values.Length];
TimeHelper.Measure(() => { for (var i = 0; i < a.Length; i++)
{
a[i] = actual.Pop();
}
});
var e = (int[])values.Clone();
TimeHelper.Measure(() => Array.Sort(e));
CollectionAssert.AreEqual(e, a);
}
public void SortTake()
{
var values = RandomHelper.CreateData(100000).ToArray();
var actual = TimeHelper.Measure(() =>
{
var pq = PQ1 <int> .Create(values);
var a = new int[100];
for (var i = 0; i < a.Length; i++)
{
a[i] = pq.Pop();
}
return(a);
});
var expected = TimeHelper.Measure(() => values.OrderBy(x => x).Take(100).ToArray());
CollectionAssert.AreEqual(expected, actual);
}
static void IndexForInsert_Random(int n)
{
var a = RandomHelper.CreateData(n).OrderBy(x => x).ToArray();
for (int i = -2; i < n + 2; i++)
{
var expected = Array.BinarySearch(a, i);
var actual = BinarySearch.IndexForInsert(a, i);
if (expected >= 0)
{
Assert.AreEqual(i, a[actual - 1]);
Assert.IsTrue(actual == n || a[actual] > i);
}
else
{
Assert.AreEqual(~expected, actual);
}
}
}
public void IndexForInsert_Time()
{
var n = 300000;
var a = RandomHelper.CreateData(n).OrderBy(x => x).ToArray();
var r = TimeHelper.Measure(() => Enumerable.Range(0, n).Select(x => BinarySearch.IndexForInsert(a, x)).ToArray());
}
public void Ctor()
{
var values = RandomHelper.CreateData(100000).ToArray();
var actual = new OrderedList(values);
CollectionAssert.AreEqual(values.OrderBy(x => x).ToArray(), actual);
}