/// <summary>
/// adds a pair of key-value to the dictionary
/// </summary>
/// <param name="key"></param>
/// <param name="value"></param>
public void Add(TKey key, TValue value)
{
if (key == null)
{
throw new ArgumentNullException();
}
tree.Insert(new KeyValuePair <TKey, TValue>(key, value));
}
internal CdtSweeper(List <CdtSite> listOfSites, CdtSite p_1, CdtSite p_2,
Func <CdtSite, CdtSite, CdtEdge> createEdgeDelegate)
{
this.listOfSites = listOfSites;
var firstTriangle = new CdtTriangle(p_1, p_2, listOfSites[0], createEdgeDelegate);
Triangles.Insert(firstTriangle);
front.Insert(new CdtFrontElement(p_1, firstTriangle.Edges[2]));
front.Insert(new CdtFrontElement(listOfSites[0], firstTriangle.Edges[1]));
this.p_1 = p_1;
this.p_2 = p_2;
this.createEdgeDelegate = createEdgeDelegate;
//ShowFront();
}
public void Delete_TryDeleteNoExistElement_Exception()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("kgj", 45);
map.Insert("a", 21);
map.Insert("vba", 90);
Assert.Throws <Exception>(() => map.Delete("b"));
}
public void Find_TryFindNoExistElement_Exception()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("ffg", 45);
map.Insert("acb", 21);
map.Insert("hyred", 90);
map.Delete("acb");
Assert.Throws <Exception>(() => map.Find("acb"));
}
Dictionary <VisibilityEdge, VisibilityVertex> GetEdgeSnapAtVertexMap(LgNodeInfo nodeInfo)
{
var ret = new Dictionary <VisibilityEdge, VisibilityVertex>();
var center = nodeInfo.Center;
RbTree <VisibilityVertex> nodeBoundaryRbTree =
new RbTree <VisibilityVertex>((a, b) => CompareByAngleFromNodeCenter(a, b, center));
foreach (var p in nodeInfo.BoundaryOnLayer)
{
nodeBoundaryRbTree.Insert(_visGraph.AddVertex(p));
}
var nodeInfoCenterV = VisGraph.FindVertex(center);
if (nodeInfoCenterV == null)
{
return(ret);
}
foreach (var e in nodeInfoCenterV.OutEdges)
{
SnapToAfterBefore(e.Target, nodeBoundaryRbTree, center, ret, e);
}
foreach (var e in nodeInfoCenterV.InEdges)
{
SnapToAfterBefore(e.Source, nodeBoundaryRbTree, center, ret, e);
}
return(ret);
}
public void Print_InsertThreeElements_CorrectPrint()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("tt", 145);
map.Insert("bb", 323);
map.Insert("gg", 476);
var actualOutput = map.ToString();
var expectedOutput = "key = bb value = 323\nkey = gg value = 476\nkey = tt value = 145\n";
Assert.AreEqual(expectedOutput, actualOutput);
}
public void Insert_InsertThreeElements_CorrectInsert()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("dog", 44);
map.Insert("cat", 63);
map.Insert("sun", 81);
var actualCount = map.Count;
var expectedCount = 3;
Assert.AreEqual(expectedCount, actualCount);
}
public void Clear_InsertTwoElementsAndClear_EmptyMap()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("me", 55);
map.Insert("you", 43);
map.Clear();
var actualCount = map.Count;
var expectedCount = 0;
Assert.AreEqual(expectedCount, actualCount);
}
public void GetKeys_InsertThreeElements_GetThreeKeys()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("ss", 55);
map.Insert("aaa", -723);
map.Insert("zzz", 797);
var actualKeys = map.GetKeys();
var expectedKeys = new List <string> {
"aaa", "ss", "zzz"
};
Assert.IsTrue(AreEqual(expectedKeys, actualKeys, comparer));
}
public void GetValues_InsertThreeElements_GetTheeValues()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("Fgd", 453);
map.Insert("ddd", 123);
map.Insert("czh", 532);
var actualValues = map.GetValues();
var expectedValues = new List <int> {
532, 123, 453
};
Assert.IsTrue(IsEqual(actualValues, expectedValues));
}
private static void Main()
{
var rbtree = new RbTree <int>();
rbtree.Insert(3);
rbtree.Insert(2);
rbtree.Insert(5);
rbtree.Insert(7);
rbtree.Insert(6);
rbtree.Insert(11);
rbtree.Insert(13);
rbtree.Insert(1);
rbtree.Insert(4);
rbtree.Preorder();
Console.WriteLine(rbtree.Find(2));
Console.ReadLine();
}
public void Delete_InsertThreeElementsAndDeleteTwoElements_FindOneElement()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("vga", 5);
map.Insert("hj", 1);
map.Insert("vbz", 9);
map.Delete("vga");
map.Delete("vbz");
var actual = map.Find("hj");
var expected = 1;
Assert.AreEqual(expected, actual);
}
// #if TEST_MSAGL
// // ReSharper disable UnusedMember.Local
// [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// void ShowPointAndEdge(Point point, AxisEdge edge) {
// // ReSharper restore UnusedMember.Local
// List<ICurve> curves = GetCurves(point, edge);
//
// LayoutAlgorithmSettings.Show(curves.ToArray());
// }
//
// // ReSharper disable UnusedMember.Local
// [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// void ShowPointAndEdgeWithSweepline(Point point, AxisEdge edge) {
// // ReSharper restore UnusedMember.Local
// List<ICurve> curves = GetCurves(point, edge);
//
// curves.Add(new LineSegment(SweepDirection * Z + 10 * DirectionPerp, SweepDirection * Z - 10 * DirectionPerp));
//
// LayoutAlgorithmSettings.Show(curves.ToArray());
// }
//
// [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// List<ICurve> GetCurves(Point point, AxisEdge edge) {
// var ellipse = CurveFactory.CreateEllipse(3, 3, point);
// var curves = new List<ICurve>(Obstacles.Select(o => o as ICurve)){ellipse,
// new LineSegment(edge.Source.Point, edge.Target.Point
// )};
//
// if (edge.RightBound < double.PositiveInfinity) {
// double rightOffset = edge.RightBound;
// var del = DirectionPerp * rightOffset;
// curves.Add(new LineSegment(edge.Source.Point + del, edge.Target.Point + del));
// }
// if (edge.LeftBound > double.NegativeInfinity) {
// double leftOffset = edge.LeftBound;
// var del = DirectionPerp * leftOffset;
// curves.Add(new LineSegment(edge.Source.Point + del, edge.Target.Point + del));
// }
//
// curves.AddRange((from e in PathOrders.Keys
// let a = e.SourcePoint
// let b = e.TargetPoint
// select new CubicBezierSegment(a, a*0.8 + b*0.2, a*0.2 + b*0.8, b)).Cast<ICurve>());
//
// return curves;
// }
//
// [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// List<DebugCurve> GetCurvesTest(Point point){
// var ellipse = CurveFactory.CreateEllipse(3, 3, point);
// var curves = new List<DebugCurve>(Obstacles.Select(o => new DebugCurve(100, 1, "black", o)))
// {new DebugCurve(100, 1, "red", ellipse)};
// curves.AddRange(from e in edgeContainersTree
// from axisEdge in e
// let a = axisEdge.Source.Point
// let b = axisEdge.Target.Point
// select new DebugCurve(100, 1, "green", new LineSegment(a, b)));
//
//
// curves.AddRange(RightNeighborsCurvesTest(edgeContainersTree));
//
// return curves;
// }
//
// [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static IEnumerable<DebugCurve> RightNeighborsCurvesTest(IEnumerable<AxisEdgesContainer> rbTree) {
// foreach (var container in rbTree) {
// foreach (var edge in container) {
// foreach (var rn in edge.RightNeighbors) {
// yield return new DebugCurve(100,1,"brown",new LineSegment(EdgeMidPoint(edge), EdgeMidPoint(rn)));
// }
// }
// }
// }
//
// static Point EdgeMidPoint(AxisEdge edge) {
// return 0.5*(edge.SourcePoint + edge.TargetPoint);
// }
//
// // ReSharper disable UnusedMember.Local
// [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// void ShowAxisEdges() {
// // ReSharper restore UnusedMember.Local
// var dd = new List<DebugCurve>(GetObstacleBoundaries("black"));
// int i = 0;
// foreach (var axisEdge in AxisEdges) {
// var color = DebugCurve.Colors[i];
// dd.Add(new DebugCurve(200, 1, color,
// new LineSegment(axisEdge.Source.Point, axisEdge.Target.Point)));
// Point perp = axisEdge.Direction == Directions.East ? new Point(0, 1) : new Point(-1, 0);
// if (axisEdge.LeftBound != double.NegativeInfinity) {
// dd.Add(new DebugCurve(200, 0.5, color,
// new LineSegment(axisEdge.Source.Point + axisEdge.LeftBound * perp, axisEdge.Target.Point + axisEdge.LeftBound * perp)));
// }
// if (axisEdge.RightBound != double.PositiveInfinity) {
// dd.Add(new DebugCurve(200, 0.5, color,
// new LineSegment(axisEdge.Source.Point - axisEdge.RightBound * perp, axisEdge.Target.Point - axisEdge.RightBound * perp)));
// }
// i = (i + 1) % DebugCurve.Colors.Length;
// }
// DebugCurveCollection.WriteToFile(dd, "c:/tmp/ae");
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(dd);
// }
//
// // ReSharper disable UnusedMember.Local
// [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// void ShowAtPoint(Point point) {
// // ReSharper restore UnusedMember.Local
// var curves = GetCurvesTest(point);
// LayoutAlgorithmSettings.ShowDebugCurves(curves.ToArray());
// }
// #endif
#endregion
RBNode <AxisEdgesContainer> GetOrCreateAxisEdgesContainer(AxisEdge edge)
{
var source = edge.Source.Point;
var ret = GetAxisEdgesContainerNode(source);
if (ret != null)
{
return(ret);
}
return(edgeContainersTree.Insert(new AxisEdgesContainer(source)));
}
public void Find_InsertFiveElements_CorrectValue()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("Me", 51);
map.Insert("You", 651);
map.Insert("Her", 89);
map.Insert("Him", 612);
map.Insert("zero", -7);
var actual = map.Find("Him");
var expected = 612;
Assert.AreEqual(expected, actual);
}
public void Test_RBTREE_ENUMERATE()
{
RbTree rbTree = new RbTree();
System.Collections.Generic.IList <IDirectoryEntry> repo = GetDirectoryRepository(10000);
foreach (var item in repo)
{
rbTree.Insert(item);
}
VerifyProperties(rbTree);
//rbTree.Print();
}
internal RBNode <BasicObstacleSide> Insert(BasicObstacleSide side, Point scanPos)
{
DevTraceInfo(1, "prev LinePos = {0}, new LinePos = {1}, inserting side = {2}", this.linePositionAtLastInsertOrRemove, scanPos, side.ToString());
Assert(!scanDirection.IsFlat(side), "Flat sides are not allowed in the scanline");
Assert(null == Find(side), "side already exists in the ScanLine");
this.linePositionAtLastInsertOrRemove = scanPos;
// RBTree's internal operations on insert/remove etc. mean the node can't cache the
// RBNode returned by insert(); instead we must do find() on each call. But we can
// use the returned node to get predecessor/successor.
var node = SideTree.Insert(side);
DevTraceDump(2);
return(node);
}
public void Test_RBTREE_INSERT()
{
RbTree rbTree = new RbTree();
System.Collections.Generic.IList <IDirectoryEntry> repo = GetDirectoryRepository(25);
foreach (var item in repo)
{
rbTree.Insert(item);
}
for (int i = 0; i < repo.Count; i++)
{
IRbNode c;
rbTree.TryLookup(DirectoryEntry.Mock(i.ToString(), StgType.StgInvalid), out c);
Assert.IsTrue(c is IDirectoryEntry);
Assert.IsTrue(((IDirectoryEntry)c).Name == i.ToString());
//Assert.IsTrue(c.IsStream);
}
}
public void Test_RBTREE_DELETE()
{
RbTree rbTree = new RbTree();
System.Collections.Generic.IList <IDirectoryEntry> repo = GetDirectoryRepository(25);
foreach (var item in repo)
{
rbTree.Insert(item);
}
try
{
IRbNode n;
rbTree.Delete(DirectoryEntry.Mock("5", StgType.StgInvalid), out n);
rbTree.Delete(DirectoryEntry.Mock("24", StgType.StgInvalid), out n);
rbTree.Delete(DirectoryEntry.Mock("7", StgType.StgInvalid), out n);
}
catch (Exception ex)
{
Assert.Fail("Item removal failed: " + ex.Message);
}
// CFItem c;
// bool s = rbTree.TryLookup(new CFMock("7", StgType.StgStream), out c);
// Assert.IsFalse(s);
// c = null;
// Assert.IsTrue(rbTree.TryLookup(new CFMock("6", StgType.StgStream), out c));
// Assert.IsTrue(c.IsStream);
// Assert.IsTrue(rbTree.TryLookup(new CFMock("12", StgType.StgStream), out c));
// Assert.IsTrue(c.Name == "12");
//}
}
static void Test2()
{
var tree = new RbTree(null, null);
var t1 = DateTime.Now;
for (int i = 0; i < 1000000; i++)
{
RbKey key = new IntKey(i);
tree.Insert(key, 10 + i);
}
Console.WriteLine(String.Format("Insert time: {0} sec",
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
t1 = DateTime.Now;
bool found;
object value;
for (int i = 0; i < 1000000; i++)
{
RbKey key = new IntKey(i);
tree.Get(key, out value, out found);
}
Console.WriteLine(String.Format("Search time: {0} sec",
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
for (int i = 0; i < 1000000; i++)
{
RbKey key = new IntKey(i);
tree.Delete(key);
}
Console.WriteLine(String.Format("Delete time: {0} sec",
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
}
public void Delete_InsertSevenElementsAndDeleteFourElements_FindAllElement()
{
var comparer = new StringComparator();
var map = new RbTree <string, int>(comparer);
map.Insert("aa", 5);
map.Insert("ab", 1);
map.Insert("zzz", 9);
map.Insert("4ga", 189);
map.Insert("11", 22);
map.Insert("bn", 56);
map.Insert("az", 88);
map.Delete("aa");
map.Delete("ab");
map.Delete("zzz");
map.Delete("bn");
var actual = map.GetKeys();
var expected = new List <string> {
"11", "4ga", "az"
};
Assert.IsTrue(AreEqual(actual, expected, comparer));
}
Dictionary<VisibilityEdge, VisibilityVertex> GetEdgeSnapAtVertexMap(LgNodeInfo nodeInfo) {
var ret = new Dictionary<VisibilityEdge, VisibilityVertex>();
var center = nodeInfo.Center;
RbTree<VisibilityVertex> nodeBoundaryRbTree =
new RbTree<VisibilityVertex>((a, b) => CompareByAngleFromNodeCenter(a, b, center));
foreach (var p in nodeInfo.BoundaryOnLayer)
nodeBoundaryRbTree.Insert(_visGraph.AddVertex(p));
var nodeInfoCenterV = VisGraph.FindVertex(center);
if (nodeInfoCenterV == null) return ret;
foreach (var e in nodeInfoCenterV.OutEdges)
SnapToAfterBefore(e.Target, nodeBoundaryRbTree, center, ret, e);
foreach (var e in nodeInfoCenterV.InEdges)
SnapToAfterBefore(e.Source, nodeBoundaryRbTree, center, ret, e);
return ret;
}
RBNode <ConeSide> InsertToTree(RbTree <ConeSide> tree, ConeSide coneSide)
{
Debug.Assert(coneSide.Direction * SweepDirection > ApproximateComparer.DistanceEpsilon);
coneSideComparer.SetOperand(coneSide);
return(tree.Insert(coneSide));
}
RBNode<ConeSide> InsertToTree(RbTree<ConeSide> tree, ConeSide coneSide) {
Debug.Assert(coneSide.Direction*SweepDirection > ApproximateComparer.DistanceEpsilon);
coneSideComparer.SetOperand(coneSide);
return tree.Insert(coneSide);
}
static void Test1()
{
var tree = new RbTree(null, null);
var t1 = DateTime.Now;
for (int i = 1; i <= 1000000; i++)
{
RbKey key = new IntKey(i);
tree.Insert(key, 10 + i);
}
Console.WriteLine(String.Format("Insert time: {0} sec",
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
error err;
var count = 0;
var iterator = tree.NewRbIterator((itr, key, value) => {
count++;
}, out err);
if (err != null)
{
return;
}
count = 0;
t1 = DateTime.Now;
iterator.All(out count, out err);
Console.WriteLine(String.Format("All completed in: {1} sec with count {0}", count,
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
count = 0;
t1 = DateTime.Now;
RbKey loKey = new IntKey(0);
RbKey hiKey = new IntKey(2000000);
iterator.Between(loKey, hiKey, out count, out err);
Console.WriteLine(String.Format("Between completed in: {1} sec with count {0}", count,
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
count = 0;
t1 = DateTime.Now;
RbKey lessThanKey = new IntKey(900001);
iterator.LessThan(lessThanKey, out count, out err);
Console.WriteLine(String.Format("LessThan completed in: {1} sec with count {0}", count,
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
count = 0;
t1 = DateTime.Now;
RbKey greaterThanKey = new IntKey(100000);
iterator.GreaterThan(greaterThanKey, out count, out err);
Console.WriteLine(String.Format("GreaterThan completed in: {1} sec with count {0}", count,
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
count = 0;
t1 = DateTime.Now;
RbKey lessOrEqualKey = new IntKey(100000);
iterator.LessOrEqual(lessOrEqualKey, out count, out err);
Console.WriteLine(String.Format("LessOrEqual completed in: {1} sec with count {0}", count,
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
count = 0;
t1 = DateTime.Now;
RbKey greaterOrEqualKey = new IntKey(0);
iterator.GreaterOrEqual(greaterOrEqualKey, out count, out err);
Console.WriteLine(String.Format("GreaterOrEqual completed in: {1} sec with count {0}", count,
Convert.ToDecimal(DateTime.Now.Subtract(t1).TotalMilliseconds) / 1000));
}
void RegisterActiveSide(PolylinePoint side)
{
activeEdgeComparer.IntersectionOfTheRayAndInsertedEdge = activeEdgeComparer.IntersectEdgeWithRay(side, new Point(1, 0));
sideNodes[side] = activeSidesTree.Insert(side);
}
void AddEdgeToFront(CdtEdge e)
{
var leftSite = e.upperSite.Point.X < e.lowerSite.Point.X?e.upperSite:e.lowerSite;
front.Insert(new CdtFrontElement(leftSite, e));
}
private void InsertActiveDiagonal(Diagonal diagonal)
{
diagonal.RbNode = activeDiagonalTree.Insert(diagonal);
MarkDiagonalAsActiveInTangents(diagonal);
}
RBNode<ConeSide> InsertToTree(RbTree<ConeSide> tree, ConeSide coneSide) {
Debug.Assert(coneSide.Direction * SweepDirection > 0);
coneSideComparer.SetOperand(coneSide);
return tree.Insert(coneSide);
}
void ProcessLowLinkedPointEvent(LinkedPoint linkedPoint)
{
tree.Insert(linkedPoint);
}
internal void Add(BasicReflectionEvent initialSite)
{
// Assert we can't find it - subsumption should have taken care of that.
Debug.Assert(null == Find(initialSite.Site), "Should not add the same Lookahead coordinate twice");
eventTree.Insert(initialSite);
}
