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