private IntSet CreateTestHashSet() { var hashSet = new IntSet(); for (var i = 0; i < 25; i++) { hashSet.Add(i); } return(hashSet); }
public void CodeIntSet(ref IntSet set) { int count = CodeCount(ref set, n => new IntSet(n)); if (count < 1) { return; } while (count-- > 0) { set.Add(m_reader.ReadInt32()); } }
public void SetTest() { var a = new IntSet(); a.Add(1); a.Add(3, 6); a.Add(2); var b = new IntSet(); b.Add(1, 6); Assert.AreEqual(b, a); a.Add(-2, -1); a.Add(0, 1); var c = new IntSet(); c.Add(0, 6); c.Add(-2); Assert.AreEqual(c, a); a.Add(-1, 9); var d = new IntSet(); d.Add(-2, 9); Assert.AreEqual(d, a); Assert.AreEqual(-3, c.LowestFree(-3)); Assert.AreEqual(-1, c.LowestFree(-2)); Assert.AreEqual(-1, c.LowestFree(-1)); Assert.AreEqual(6, c.LowestFree(0)); Assert.AreEqual(6, c.LowestFree(5)); Assert.AreEqual(12, c.LowestFree(12)); }
static void Main(string[] args) { IntSet mySet = new IntSet(); HashSet<int> systemSet = new HashSet<int>(); for (int i = 0; i < 10000000; i++) { int a = rand.Next(0, 100); mySet.Add(a); systemSet.Add(a); int b = rand.Next(0, 100); mySet.Remove(b); systemSet.Remove(b); } int[] systemSetArray = systemSet.ToArray(); Array.Sort(systemSetArray); int[] mySetArray = mySet.ToArray(); Console.WriteLine(systemSetArray.SequenceEqual(mySetArray) ? "test passed" : "test failed"); }
static void Main() { StringSet ss = new StringSet(); // Check the interface methods first. ISet <string> s = ss; checkThat(s.Count == 0, "is initially empty"); checkThat(!s.Contains("key"), "doesn't contain inexistent element"); checkThat(!s.Remove("key"), "returns false when removing inexistent element"); checkThat(s.Add("key"), "returns true when adding a new element"); checkThat(!s.Add("key"), "returns false when adding an existing element"); checkThat(s.Contains("key"), "contains the just added element"); checkThat(s.Remove("key"), "returns true when removing an existing element"); checkThat(s.Count == 0, "is empty again"); checkThat(s.Add("key1"), "Add(key1) returns true"); checkThat(s.Add("key2"), "Add(key2) returns true"); checkThat(s.Add("key3"), "Add(key3) returns true"); // Also check a different interface, providing a different Add() (sic!). ICollection <string> coll = ss; coll.Add("key"); checkThat(ss.Count == 4, "contains 4 elements"); // Now use object-specific methods, mimicking HashSet<>. string val; checkThat(ss.TryGetValue("key1", out val), "could retrieve existing item"); checkThat(val.Equals("key1"), "value was returned correctly by TryGetValue()"); checkThat(!ss.TryGetValue("no-such-key", out val), "couldn't retrieve inexistent item"); checkThat(val == null, "value was reset after failed TryGetValue()"); IList <string> list = new List <string>(); foreach (string str in ss) { list.Add(str); } checkThat(list.Count == 4, "copy contains 4 elements"); ss.Clear(); checkThat(ss.Count == 0, "is empty after Clear()"); // Check set-theoretic methods. checkThat(new StringSet().SetEquals(new StringSet()), "SetEquals() works for empty sets"); checkThat(new StringSet { "foo" }.SetEquals(new StringSet { "foo" }), "SetEquals() works for non-empty sets"); checkThat(!new StringSet { "foo" }.SetEquals(new[] { "bar" }), "SetEquals() doesn't always return true"); ss = new StringSet { "foo", "bar", "baz" }; ss.ExceptWith(new[] { "baz", "quux" }); checkThat(ss.SetEquals(new[] { "foo", "bar" }), "ExceptWith works"); ss = new StringSet { "foo", "bar", "baz" }; ss.IntersectWith(new[] { "baz", "quux" }); checkThat(ss.SetEquals(new[] { "baz" }), "IntersectWith works"); checkThat(ss.IsProperSubsetOf(new[] { "bar", "baz" }), "IsProperSubsetOf works"); checkThat(!ss.IsProperSubsetOf(new[] { "baz" }), "!IsProperSubsetOf works"); checkThat(ss.IsSubsetOf(new[] { "bar", "baz" }), "IsSubsetOf works"); checkThat(!ss.IsSubsetOf(new[] { "bar" }), "!IsSubsetOf works"); ss = new StringSet { "foo", "bar", "baz" }; checkThat(ss.IsProperSupersetOf(new[] { "bar" }), "IsProperSupersetOf works"); checkThat(!ss.IsProperSupersetOf(new[] { "quux" }), "IsProperSupersetOf works"); checkThat(ss.IsSupersetOf(new[] { "foo", "bar", "baz" }), "IsProperSupersetOf works"); checkThat(!ss.IsSupersetOf(new[] { "foo", "bar", "baz", "quux" }), "IsProperSupersetOf works"); checkThat(ss.Overlaps(new[] { "foo" }), "Overlaps works"); checkThat(!ss.Overlaps(new[] { "moo" }), "!Overlaps works"); ss.SymmetricExceptWith(new[] { "baz", "quux" }); checkThat(ss.SetEquals(new[] { "foo", "bar", "quux" }), "SymmetricExceptWith works"); ss = new StringSet { "foo", "bar", "baz" }; ss.UnionWith(new[] { "baz", "quux" }); checkThat(ss.SetEquals(new[] { "foo", "bar", "baz", "quux" }), "UnionWith works"); // Check a set of another type. FooSet fooSet = new FooSet(); ISet <Foo> fooISet = fooSet; checkThat(fooISet.Count == 0, "is initially empty"); checkThat(fooISet.Add(new Foo(17)), "added successfully"); checkThat(fooISet.Count == 1, "is not empty any more"); // And a set of primitive type. IntSet intSet = new IntSet(); checkThat(intSet.Count == 0, "is initially empty"); checkThat(intSet.Add(17), "17 added successfully"); checkThat(!intSet.Add(17), "17 not added again"); checkThat(intSet.Count == 1, "not empty any more"); checkThat(intSet.Add(289), "289 added successfully"); checkThat(intSet.Count == 2, "even less empty now"); }
/// <summary> /// Clips the mesh with the given plane. /// The part on the positive hals will remain. /// Will return null when everything is clipped. /// Cap-faces will be built on everything that is cut open by the plane (non-convex cap faces are not handled properly). /// Only works for meshes without Face-/FaceVertexAttributes -> attributes will be invalid for generated faces. /// </summary> public PolyMesh ClipByPlane(Plane3d plane, double epsilon = 1e-7) { var clippedMesh = SplitOnPlane(plane, epsilon).Item2; // in case everything is clipped away if (clippedMesh == null) { return(null); } // 1. go trough all edges // 2. if edge on plane -> test if there is an open face along the plane (border edges) var vertexOnPlane = clippedMesh.PositionArray.Map(clippedMesh.VertexCount, p => plane.Height(p).Abs() <= epsilon); clippedMesh.BuildTopology(); // use indices so an edge can be removed no matter what "ref" var edges = new IntSet(clippedMesh.EdgeCount); foreach (var e in clippedMesh.Edges) { if (e.IsValid) { edges.Add(e.Index); } } var capFaceEdges = new List <PolyMesh.Edge>(); var capFaceEdgeSet = new IntSet(); while (edges.Count > 0) { var e = clippedMesh.GetEdge(edges.First()); edges.Remove(e.Index); if (e.IsAnyBorder && vertexOnPlane[e.FromVertexIndex] && vertexOnPlane[e.ToVertexIndex]) { // try to find other edges along the plane // keep set of all edges so in case there the loop runs into a degenerated case an exit is possible (will generate degenerated face) capFaceEdges.Clear(); capFaceEdgeSet.Clear(); var currEdge = e; do { if (currEdge.IsValid) { capFaceEdges.Add(currEdge); capFaceEdgeSet.Add(currEdge.Index); } // find next edge at start-vertex along plane // the new cap face should have winding order start<-to becaues it is on the opposite of the current face-edge currEdge = currEdge.FromVertex.Edges .Select(x => x.FromVertexIndex == currEdge.FromVertexIndex ? x.Opposite : x) .FirstOrDefault(x => x.IsAnyBorder && x.Index != currEdge.Index && vertexOnPlane[x.FromVertexIndex], PolyMesh.Edge.Invalid); } while (currEdge.IsValid && currEdge.Index != e.Index && !capFaceEdgeSet.Contains(currEdge.Index)); if (capFaceEdges.Count > 2) { // add cap-face foreach (var fe in capFaceEdges.Skip(1)) { edges.Remove(fe.Index); } clippedMesh.AddFace(capFaceEdges.Select(fe => fe.ToVertexIndex).ToArray()); } } } // clear topology (is invalid if face has been added) clippedMesh.ClearTopology(); return(clippedMesh); }
public void TestEverything() { IntSet intSet; IEnumerator <IntSet.Range> ranges; int index; // {3-5} - {4} = {3,5} intSet = new IntSet(); intSet.AddRange(3, 5); intSet.Remove(4); Assert.True(intSet.Count == 2); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 3 && ranges.Current.Max == 3 && ranges.Current.PreviousItemsCount == 0); ranges.MoveNext(); Assert.True(ranges.Current.Min == 5 && ranges.Current.Max == 5 && ranges.Current.PreviousItemsCount == 1); Verify(intSet); // {3,5} + {4} = {3-5} intSet.Add(4); Assert.True(intSet.Count == 3); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 3 && ranges.Current.Max == 5 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {3-5} + {6-9} = {3-9} intSet.AddRange(6, 9); Assert.True(intSet.Count == 7); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 3 && ranges.Current.Max == 9 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {3-9} - {4} - {5} - {3} = {6-9} intSet.Remove(4); intSet.Remove(5); intSet.Remove(3); Assert.True(intSet.Count == 4); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 6 && ranges.Current.Max == 9 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {6-9} + {13-13} + {11} + {10-12} = {6-13} intSet.AddRange(13, 13); intSet.Add(11); Assert.True(intSet.Contains(6)); Assert.True(intSet.Contains(7)); Assert.True(intSet.Contains(8)); Assert.True(intSet.Contains(9)); Assert.True(intSet.Contains(11)); Assert.True(intSet.Contains(13)); Assert.True(intSet.Contains(6, out index) && index == 0); Assert.True(intSet.Contains(7, out index) && index == 1); Assert.True(intSet.Contains(8, out index) && index == 2); Assert.True(intSet.Contains(9, out index) && index == 3); Assert.True(intSet.Contains(11, out index) && index == 4); Assert.True(intSet.Contains(13, out index) && index == 5); Assert.False(intSet.Contains(5)); Assert.False(intSet.Contains(14)); Assert.False(intSet.Contains(10)); Assert.False(intSet.Contains(12)); intSet.AddRange(10, 12); Assert.True(intSet.Contains(6)); Assert.True(intSet.Contains(7)); Assert.True(intSet.Contains(8)); Assert.True(intSet.Contains(9)); Assert.True(intSet.Contains(10)); Assert.True(intSet.Contains(11)); Assert.True(intSet.Contains(12)); Assert.True(intSet.Contains(13)); Assert.False(intSet.Contains(5)); Assert.False(intSet.Contains(14)); Assert.True(intSet.Count == 8); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 6 && ranges.Current.Max == 13 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {6-13} - {6-12} = {13} intSet.RemoveRange(6, 12); Assert.True(intSet.Count == 1); Assert.True(intSet.Contains(13)); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 13 && ranges.Current.Max == 13 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {13} - {13-13} = {} intSet.RemoveRange(13, 13); Assert.True(intSet.Count == 0); Assert.False(intSet.Contains(13)); ranges = intSet.Ranges.GetEnumerator(); Assert.False(ranges.MoveNext()); Verify(intSet); // {} + {5-9} - {6-7} = {5,8-9} intSet.AddRange(5, 9); intSet.RemoveRange(6, 7); Assert.True(intSet.Count == 3); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 5 && ranges.Current.Max == 5 && ranges.Current.PreviousItemsCount == 0); ranges.MoveNext(); Assert.True(ranges.Current.Min == 8 && ranges.Current.Max == 9 && ranges.Current.PreviousItemsCount == 1); Assert.False(ranges.MoveNext()); Verify(intSet); // test Clear() intSet.Clear(); Verify(intSet); // randomly add and remove Random rnd = new Random(0); for (int i = 0; i < 1000; i++) { int one; int begin; int end; begin = rnd.Next(0, 100); end = begin + rnd.Next(0, 7); intSet.AddRange(begin, end); one = rnd.Next(0, 100); intSet.Add(one); begin = rnd.Next(0, 100); end = begin + rnd.Next(0, 7); intSet.RemoveRange(begin, end); one = rnd.Next(0, 100); intSet.Remove(one); Verify(intSet); } // test locking intSet.Lock(); Assert.Throws <NotSupportedException>(delegate { intSet.Add(20); }); Assert.Throws <NotSupportedException>(delegate { intSet.AddRange(20, 20); }); Assert.Throws <NotSupportedException>(delegate { intSet.Remove(6); }); Assert.Throws <NotSupportedException>(delegate { intSet.RemoveRange(1, 20); }); Verify(intSet); }
public void TestEverything() { IntSet intSet; IEnumerator<IntSet.Range> ranges; int index; // {3-5} - {4} = {3,5} intSet = new IntSet(); intSet.AddRange(3, 5); intSet.Remove(4); Assert.True(intSet.Count == 2); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 3 && ranges.Current.Max == 3 && ranges.Current.PreviousItemsCount == 0); ranges.MoveNext(); Assert.True(ranges.Current.Min == 5 && ranges.Current.Max == 5 && ranges.Current.PreviousItemsCount == 1); Verify(intSet); // {3,5} + {4} = {3-5} intSet.Add(4); Assert.True(intSet.Count == 3); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 3 && ranges.Current.Max == 5 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {3-5} + {6-9} = {3-9} intSet.AddRange(6, 9); Assert.True(intSet.Count == 7); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 3 && ranges.Current.Max == 9 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {3-9} - {4} - {5} - {3} = {6-9} intSet.Remove(4); intSet.Remove(5); intSet.Remove(3); Assert.True(intSet.Count == 4); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 6 && ranges.Current.Max == 9 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {6-9} + {13-13} + {11} + {10-12} = {6-13} intSet.AddRange(13, 13); intSet.Add(11); Assert.True(intSet.Contains(6)); Assert.True(intSet.Contains(7)); Assert.True(intSet.Contains(8)); Assert.True(intSet.Contains(9)); Assert.True(intSet.Contains(11)); Assert.True(intSet.Contains(13)); Assert.True(intSet.Contains(6, out index) && index == 0); Assert.True(intSet.Contains(7, out index) && index == 1); Assert.True(intSet.Contains(8, out index) && index == 2); Assert.True(intSet.Contains(9, out index) && index == 3); Assert.True(intSet.Contains(11, out index) && index == 4); Assert.True(intSet.Contains(13, out index) && index == 5); Assert.False(intSet.Contains(5)); Assert.False(intSet.Contains(14)); Assert.False(intSet.Contains(10)); Assert.False(intSet.Contains(12)); intSet.AddRange(10, 12); Assert.True(intSet.Contains(6)); Assert.True(intSet.Contains(7)); Assert.True(intSet.Contains(8)); Assert.True(intSet.Contains(9)); Assert.True(intSet.Contains(10)); Assert.True(intSet.Contains(11)); Assert.True(intSet.Contains(12)); Assert.True(intSet.Contains(13)); Assert.False(intSet.Contains(5)); Assert.False(intSet.Contains(14)); Assert.True(intSet.Count == 8); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 6 && ranges.Current.Max == 13 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {6-13} - {6-12} = {13} intSet.RemoveRange(6, 12); Assert.True(intSet.Count == 1); Assert.True(intSet.Contains(13)); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 13 && ranges.Current.Max == 13 && ranges.Current.PreviousItemsCount == 0); Assert.False(ranges.MoveNext()); Verify(intSet); // {13} - {13-13} = {} intSet.RemoveRange(13, 13); Assert.True(intSet.Count == 0); Assert.False(intSet.Contains(13)); ranges = intSet.Ranges.GetEnumerator(); Assert.False(ranges.MoveNext()); Verify(intSet); // {} + {5-9} - {6-7} = {5,8-9} intSet.AddRange(5, 9); intSet.RemoveRange(6, 7); Assert.True(intSet.Count == 3); ranges = intSet.Ranges.GetEnumerator(); ranges.MoveNext(); Assert.True(ranges.Current.Min == 5 && ranges.Current.Max == 5 && ranges.Current.PreviousItemsCount == 0); ranges.MoveNext(); Assert.True(ranges.Current.Min == 8 && ranges.Current.Max == 9 && ranges.Current.PreviousItemsCount == 1); Assert.False(ranges.MoveNext()); Verify(intSet); // test Clear() intSet.Clear(); Verify(intSet); // randomly add and remove Random rnd = new Random(0); for (int i = 0; i < 1000; i++) { int one; int begin; int end; begin = rnd.Next(0, 100); end = begin + rnd.Next(0, 7); intSet.AddRange(begin, end); one = rnd.Next(0, 100); intSet.Add(one); begin = rnd.Next(0, 100); end = begin + rnd.Next(0, 7); intSet.RemoveRange(begin, end); one = rnd.Next(0, 100); intSet.Remove(one); Verify(intSet); } // test locking intSet.Lock(); Assert.Throws<NotSupportedException>(delegate { intSet.Add(20); }); Assert.Throws<NotSupportedException>(delegate { intSet.AddRange(20, 20); }); Assert.Throws<NotSupportedException>(delegate { intSet.Remove(6); }); Assert.Throws<NotSupportedException>(delegate { intSet.RemoveRange(1, 20); }); Verify(intSet); }