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; }