public void Count()
{
AndersonTree <int, int> tree = new AndersonTree <int, int>();
tree.Add(0, 0);
Assert.AreEqual(tree.Count, 1);
}
public void Remove()
{
AndersonTree <int, int> tree = new AndersonTree <int, int>();
tree.Add(0, 0);
tree.Add(1, 1);
tree.Add(2, 2);
tree.Add(3, 3);
tree.Add(4, 4);
tree.Add(5, 5);
tree.Add(6, 6);
tree.Add(7, 7);
// removing zero will cause a break in the levels between 1 and nil,
// so the level of 1 is decreased to 1. Then break is between 1 and 3,
// so the level of 3 is decreased to 2.
tree.Remove(0);
AndersonTreeNode <int, int> node = tree.FindNode(3);
// levels
Assert.AreEqual(node.Level, 2);
Assert.AreEqual(node.Left.Level, 1);
Assert.AreEqual(node.Left.Right.Level, 1);
Assert.AreEqual(node.Right.Level, 2);
Assert.AreEqual(node.Right.Left.Level, 1);
Assert.AreEqual(node.Right.Right.Level, 1);
// values
Assert.AreEqual(node.Value, 3);
Assert.AreEqual(node.Left.Value, 1);
Assert.AreEqual(node.Left.Right.Value, 2);
Assert.AreEqual(node.Right.Value, 5);
Assert.AreEqual(node.Right.Left.Value, 4);
Assert.AreEqual(node.Right.Right.Value, 6);
Assert.IsTrue(tree.Remove(1));
Assert.IsFalse(tree.ContainsKey(1));
Assert.Throws(typeof(KeyNotFoundException), delegate() { int val = tree[1]; });
// the real remove test
node = tree.FindNode(3);
// levels
Assert.AreEqual(node.Level, 2);
Assert.AreEqual(node.Left.Level, 1);
Assert.AreEqual(node.Right.Level, 2);
Assert.AreEqual(node.Right.Left.Level, 1);
Assert.AreEqual(node.Right.Right.Level, 1);
Assert.AreEqual(node.Right.Right.Right.Level, 1);
// values
Assert.AreEqual(node.Value, 3);
Assert.AreEqual(node.Left.Value, 2);
Assert.AreEqual(node.Right.Value, 5);
Assert.AreEqual(node.Right.Left.Value, 4);
Assert.AreEqual(node.Right.Right.Value, 6);
Assert.AreEqual(node.Right.Right.Right.Value, 7);
}
public void ShouldClearTheTree() {
AndersonTree<int, int> tree = new AndersonTree<int, int>();
tree.Add(10, 10);
tree.Add(12, 32);
tree.Add(56, 56);
tree.Add(89, 89);
Assert.AreNotEqual(0, tree.Count);
tree.Clear();
Assert.AreEqual(0, tree.Count);
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="ExponentiallyDecayingResevoir"/> class by using the specified
/// resevoir size and exponential decay factor.
/// </summary>
/// <param name="resevoir_size">
/// The number of samples to keep in the sampling resevoir.
/// </param>
/// <param name="alpha">
/// The exponential decay factor; the higher this is, the more biased the
/// sample will be towards newer values.
/// </param>
/// <param name="clock">
/// A <see cref="Clock"/> that can be used to mark the passage of time.
/// </param>
/// <remarks>
/// The use of the executor returned by the method
/// <see cref="Executors.SameThreadExecutor"/> is not encouraged, because
/// the executor does not returns until the execution list is empty and,
/// this can cause significant pauses in the thread that is executing the
/// sample update.
/// </remarks>
internal ExponentiallyDecayingResevoir(int resevoir_size, double alpha,
Clock clock)
{
count_ = 0;
clock_ = clock;
rand_ = new Random();
next_scale_time_ = 0;
alpha_ = alpha;
resevoir_size_ = resevoir_size;
priorities_ = new AndersonTree <double, long>();
//resevoir_ = new long[resevoir_size];
start_time_ = TimeInSeconds(clock_.Tick);
next_scale_time_ = clock_.Tick + kRescaleThreshold;
}
public void Clear()
{
AndersonTree <int, int> tree = new AndersonTree <int, int>();
tree.Add(0, 0);
tree.Add(1, 1);
tree.Add(2, 2);
tree.Add(3, 3);
tree.Add(4, 4);
tree.Add(5, 5);
tree.Add(6, 6);
tree.Clear();
Assert.AreEqual(tree.Count, 0);
}
public void Add()
{
AndersonTree <int, int> tree = new AndersonTree <int, int>();
tree.Add(0, 0);
tree.Add(1, 1);
// split must perform a left rotation and increase
// the level of the node with key 1.
tree.Add(2, 2);
AndersonTreeNode <int, int> node = tree.FindNode(1);
Assert.AreEqual(node.Level, 2);
Assert.AreEqual(node.Left.Level, 1);
Assert.AreEqual(node.Right.Level, 1);
Assert.AreEqual(node.Left.Value, 0);
Assert.AreEqual(node.Right.Value, 2);
tree.Add(3, 3);
tree.Add(4, 4);
tree.Add(5, 5);
tree.Add(6, 6);
// must be balanced
node = tree.FindNode(3);
Assert.AreEqual(node.Value, 3);
Assert.AreEqual(node.Left.Value, 1);
Assert.AreEqual(node.Left.Left.Value, 0);
Assert.AreEqual(node.Left.Right.Value, 2);
Assert.AreEqual(node.Right.Value, 5);
Assert.AreEqual(node.Right.Left.Value, 4);
Assert.AreEqual(node.Right.Right.Value, 6);
Assert.IsTrue(tree.ContainsKey(0));
Assert.IsTrue(tree.ContainsKey(1));
Assert.IsFalse(tree.ContainsKey(10));
Assert.IsNotNull(tree[4]);
Assert.Throws(typeof(KeyNotFoundException), delegate() { int v = tree[10]; });
Assert.Throws(typeof(ArgumentException), delegate() { tree.Add(0, 0); });
// set value
Assert.DoesNotThrow(delegate() { tree[0] = 20; });
int i = tree[0];
Assert.AreEqual(i, 20);
}
public void InOrderTraversal()
{
AndersonTree <int, int> tree = new AndersonTree <int, int>();
tree.Add(0, 0);
tree.Add(1, 1);
tree.Add(2, 2);
tree.Add(3, 3);
tree.Add(4, 4);
tree.Add(5, 5);
tree.Add(6, 6);
List <AndersonTreeNode <int, int> > array = new List <AndersonTreeNode <int, int> >(6);
tree.InOrderTreeWalk(delegate(AndersonTreeNode <int, int> node) {
array.Add(node);
return(true);
});
Assert.AreEqual(array[0].Value, 0);
Assert.AreEqual(array[1].Value, 1);
Assert.AreEqual(array[2].Value, 2);
Assert.AreEqual(array[3].Value, 3);
Assert.AreEqual(array[4].Value, 4);
Assert.AreEqual(array[5].Value, 5);
Assert.AreEqual(array[6].Value, 6);
// unordered inert
tree.Clear();
tree.Add(4, 4);
tree.Add(0, 0);
tree.Add(1, 1);
tree.Add(6, 6);
tree.Add(2, 2);
tree.Add(5, 5);
tree.Add(3, 3);
Assert.AreEqual(array[0].Value, 0);
Assert.AreEqual(array[1].Value, 1);
Assert.AreEqual(array[2].Value, 2);
Assert.AreEqual(array[3].Value, 3);
Assert.AreEqual(array[4].Value, 4);
Assert.AreEqual(array[5].Value, 5);
Assert.AreEqual(array[6].Value, 6);
}
public void ShouldGetTheFirstNode() {
AndersonTree<int, string> tree = new AndersonTree<int, string>();
Assert.AreEqual(0, tree.First.Key);
tree.Add(10, "10");
Assert.AreEqual(10, tree.First.Key);
tree.Add(11, "11");
Assert.AreEqual(10, tree.First.Key);
tree.Add(28, "28");
Assert.AreEqual(10, tree.First.Key);
tree.Add(5, "5");
Assert.AreEqual(5, tree.First.Key);
tree.Add(50, "50");
Assert.AreEqual(5, tree.First.Key);
}
public void ReverseInOrderAccept()
{
AndersonTree <int, int> tree = new AndersonTree <int, int>();
tree.Add(0, 0);
tree.Add(1, 1);
tree.Add(2, 2);
tree.Add(3, 3);
tree.Add(4, 4);
tree.Add(5, 5);
tree.Add(6, 6);
TreeOrderedVisitor visitor = new TreeOrderedVisitor();
tree.Accept(new InOrderVisitor <int>(visitor), null, true);
Assert.AreEqual(7, visitor.Values.Count);
for (int i = 0, j = visitor.Values.Count; i < j; i++)
{
Assert.AreEqual(tree[tree.Count - i - 1], visitor.Values[i]);
}
}
public void CopyTo()
{
AndersonTree <int, int> tree = new AndersonTree <int, int>();
tree.Add(0, 0);
tree.Add(1, 1);
tree.Add(2, 2);
tree.Add(3, 3);
tree.Add(4, 4);
tree.Add(5, 5);
tree.Add(6, 6);
KeyValuePair <int, int>[] array = new KeyValuePair <int, int> [7];
Assert.DoesNotThrow(delegate() { tree.CopyTo(array, 0); });
Assert.AreEqual(array[0].Value, 0);
Assert.AreEqual(array[2].Value, 2);
Assert.AreEqual(array[3].Value, 3);
Assert.AreEqual(array[6].Value, 6);
Assert.Throws <ArgumentOutOfRangeException>(delegate() { tree.CopyTo(array, -1); });
Assert.Throws <ArgumentException>(delegate() { tree.CopyTo(array, 3); });
KeyValuePair <int, int>[] array2 = new KeyValuePair <int, int> [10];
Array.Copy(array, array2, array.Length);
tree[0] = 20;
tree[1] = 20;
Assert.DoesNotThrow(delegate() { tree.CopyTo(array2, 3); });
Assert.AreEqual(array2[0].Value, 0);
Assert.AreEqual(array2[1].Value, 1);
Assert.AreEqual(array2[2].Value, 2);
Assert.AreEqual(array2[3].Key, 0);
Assert.AreEqual(array2[3].Value, 20);
Assert.AreEqual(array2[4].Key, 1);
Assert.AreEqual(array2[4].Value, 20);
}
public void ShouldCopyTheTreeToArray() {
AndersonTree<int, int> tree = new AndersonTree<int, int>();
int[] data = new int[10];
for (int i = 0; i < data.Length; i++) {
data[i] = i*10;
tree.Add(data[i], data[i]);
}
KeyValuePair<int, int>[] copy = new KeyValuePair<int, int>[tree.Count];
tree.CopyTo(copy, 0);
for (int i = 0; i < data.Length; i++) {
Assert.AreEqual(data[i], copy[i].Value);
}
KeyValuePair<int, int>[] middle_copy =
new KeyValuePair<int, int>[tree.Count*2];
tree.CopyTo(middle_copy, tree.Count);
for (int i = 0; i < data.Length; i++) {
Assert.AreEqual(data[i], middle_copy[i + data.Length].Value);
}
}
public void ShouldAcceptNullValues() {
AndersonTree<string, string> tree = new AndersonTree<string, string>();
Assert.DoesNotThrow(() => tree.Add("", null));
}
public void ShouldNotAllowDuplicates() {
AndersonTree<int, int> tree = new AndersonTree<int, int>();
tree.Add(10, 10);
Assert.Throws<ArgumentException>(() => tree.Add(10, 10));
}
public void ShouldVisitEachNodeInDescendingOrder() {
AndersonTree<int, int> tree = new AndersonTree<int, int>();
Stack<int> data = new Stack<int>(10);
for (int i = 0; i < 10; i++) {
data.Push(i*10);
tree.Add(i*10, i*10);
}
var visitor =
new InOrderVisitor<int, int>(
new Visitor<int, int>(
(key, value, state) => Assert.AreEqual(data.Pop(), value)));
tree.Accept(visitor, true);
}
public void ShouldVisitEachNodeInAscendingOrder() {
AndersonTree<int, int> tree = new AndersonTree<int, int>();
Queue<int> data = new Queue<int>(10);
for (int i = 0; i < 10; i++) {
data.Enqueue(i*10);
tree.Add(i*10, i*10);
}
var visitor =
new InOrderVisitor<int, int>(
new Visitor<int, int>(
(key, value, state) => Assert.AreEqual(data.Dequeue(), value)));
tree.Accept(visitor, false);
}
public void ShouldNotAcceptNullKeys() {
AndersonTree<string, string> tree = new AndersonTree<string, string>();
Assert.Throws<ArgumentNullException>(() => tree.Add(null, ""));
}
/// <summary>
/// Initializes a new instance of the
/// <see cref="ExponentiallyDecayingResevoir"/> class by using the specified
/// resevoir size and exponential decay factor.
/// </summary>
/// <param name="resevoir_size">
/// The number of samples to keep in the sampling resevoir.
/// </param>
/// <param name="alpha">
/// The exponential decay factor; the higher this is, the more biased the
/// sample will be towards newer values.
/// </param>
/// <param name="clock">
/// A <see cref="Clock"/> that can be used to mark the passage of time.
/// </param>
/// <remarks>
/// The use of the executor returned by the method
/// <see cref="Executors.SameThreadExecutor"/> is not encouraged, because
/// the executor does not returns until the execution list is empty and,
/// this can cause significant pauses in the thread that is executing the
/// sample update.
/// </remarks>
internal ExponentiallyDecayingResevoir(int resevoir_size, double alpha,
Clock clock) {
count_ = 0;
clock_ = clock;
rand_ = new Random();
next_scale_time_ = 0;
alpha_ = alpha;
resevoir_size_ = resevoir_size;
priorities_ = new AndersonTree<double, long>();
//resevoir_ = new long[resevoir_size];
start_time_ = TimeInSeconds(clock_.Tick);
next_scale_time_ = clock_.Tick + kRescaleThreshold;
}
