//--------------------------------------------------------------------------------------------------
// Create/sort search sets according to radii
//--------------------------------------------------------------------------------------------------
private void GenerateSearchSets()
{
for (int i = 0; i < m_Radius + 1; i++)
{
m_SearchSets[i] = new SearchSet(i);
for (int y = -m_Radius; y < m_Radius + 1; y++)
{
for (int x = -m_Radius; x < m_Radius + 1; x++)
{
CircleEntry entry = m_Matrices[i, y + m_Radius, x + m_Radius];
if (entry == null)
{
continue;
}
if (entry.Distance > m_Radius)
{
continue;
}
m_SearchSets[i].AddEntry(entry);
m_nEntries++;
}
}
}
}
//--------------------------------------------------------------------------------------------------
// Debugging
//--------------------------------------------------------------------------------------------------
public void DumpMatrices( )
{
Console.WriteLine("\n");
for (int i = 0; i < m_Radius + 1; i++)
{
for (int y = -m_Radius; y < m_Radius + 1; y++)
{
for (int x = -m_Radius; x < m_Radius + 1; x++)
{
CircleEntry entry = m_Matrices[i, y + m_Radius, x + m_Radius];
if (entry == null)
{
Console.Write("-- ");
}
else
{
Console.Write("{0:00} ", entry.Distance);
}
}
Console.WriteLine("");
}
Console.WriteLine("\n");
}
}
private void AddMatrixEntry(int i, int x, int y)
{
double theta = Trig.Theta(x, y);
CircleEntry entry = new CircleEntry(x, y, theta);
m_Matrices[i, y + m_Radius, x + m_Radius] = entry;
}
public void CircleEntry_Clear_Test()
{
int count = 100;
int[] reff = count.Repeat (i => i).ToArray ();
CircleEntry<int> circle = new CircleEntry<int> (reff);
Assert.AreEqual (reff.Length, circle.Count);
circle.Clear ();
Assert.AreEqual (1, circle.Count);
}
public void CircleEntry_Constructor_Tests()
{
int[] arr = new int[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
CircleEntry<int> start = new CircleEntry<int> (arr);
for (int n = 0; n < 10; n++) {
Assert.AreEqual (n, start.Value);
start = start.Next;
}
for (int n = 0; n < 10; n++) {
Assert.AreEqual (n, start.Value);
start ++;
}
start --;
for (int n = 9; n >= 0; n--) {
Assert.AreEqual (n, start.Value);
start --;
}
}
public void CircleEntry_Find_Test()
{
int count = 100;
int[] reff = count.Repeat (i => i).ToArray ();
CircleEntry<int> circle = new CircleEntry<int> (reff);
foreach (int searchFor in count.Range ()) {
Assert.IsTrue (circle.Contains (searchFor));
Assert.AreEqual (searchFor, circle.Find (searchFor).At (0));
Assert.AreEqual (searchFor, circle.Find (t => t == searchFor).At (0));
IEnumerable<CircleEntry<int>> found1;
Assert.IsTrue (circle.Contains (searchFor, out found1));
Assert.AreEqual (searchFor, found1.At (0));
Assert.IsTrue (circle.Contains (t => t == searchFor, out found1));
Assert.AreEqual (searchFor, found1.At (0));
CircleEntry<int> found2;
Assert.IsTrue (circle.Contains (searchFor, out found2));
Assert.AreEqual (searchFor, found2);
Assert.IsTrue (circle.Contains (t => t == searchFor, out found2));
Assert.AreEqual (searchFor, found2);
if (found2 != circle) {
circle.Remove (searchFor);
Assert.IsFalse (circle.Contains (searchFor, out found1));
Assert.IsNull (found1.At (0));
Assert.IsFalse (circle.Contains (t => t == searchFor, out found1));
Assert.IsNull (found1.At (0));
}
}
foreach (int searchFor in count.Range ().Skip (1)) {
circle.Remove (searchFor);
}
Assert.AreEqual (1, circle.Count);
}
public void CircleEntry_CopyTo_Test()
{
int count = 100;
int[] reff = count.Repeat (i => i).ToArray ();
CircleEntry<int> circle = new CircleEntry<int> (reff);
int[] copy = count.Repeat (i => -1).ToArray ();
circle.CopyTo (copy, 0);
count.Repeat (i => Assert.AreEqual (reff [i], copy [i]));
}
public void CircleEntry_Implicit_Test()
{
int count = 100;
int[] reff = count.Repeat (i => i).ToArray ();
CircleEntry<int> circle = new CircleEntry<int> (reff);
// []-Operator
count.Repeat (i => Assert.AreEqual (circle [i], i));
// .Value
count.Repeat (i => Assert.AreEqual ((circle + i).Value, i));
// Implicit Cast
count.Repeat (i => Assert.AreEqual ((int)(circle + i), i));
}
private void AddMatrixEntry( int i, int x, int y )
{
double theta = Trig.Theta( x, y );
CircleEntry entry = new CircleEntry( x, y, theta );
m_Matrices[i,y+m_Radius,x+m_Radius] = entry;
}
public void CircleEntry_ToCircle_Test()
{
int[] reff = new int[] { 2, 6, 4, 5, 8, 7, 3, 1, 0, 9 };
CircleEntry<int> circle1 = new CircleEntry<int> (reff);
CircleEntry<int> circle2 = reff.ToCircle ();
reff.Length.Repeat (i => Assert.AreEqual (circle1 [i], circle2 [i]));
}
public void CircleEntry_Set_Test()
{
int count = 100;
int[] reff = count.Repeat (i => i).ToArray ();
CircleEntry<int> circle = new CircleEntry<int> (reff);
count.Repeat (i => Assert.AreEqual (i + 50, circle [i] = i + 50));
}
public void CircleEntry_RemoveAt_Test()
{
int count = 100;
int[] reff = count.Repeat (i => i).ToArray ();
CircleEntry<int> circle = new CircleEntry<int> (reff);
Assert.IsTrue (circle.Contains (5));
circle.RemoveAt (5);
Assert.IsFalse (circle.Contains (5));
}
public void CircleEntry_RandomAccess_Test()
{
int[] reff = new int[] { 2, 6, 4, 5, 8, 7, 3, 1, 0, 9 };
CircleEntry<int> circle = new CircleEntry<int> (reff);
foreach (int n in reff) {
Assert.AreEqual (circle [n], reff [n]);
Assert.AreEqual ((circle + n).Value, reff [n]);
}
}
public void CircleEntry_InterfaceNonsense_Test()
{
int count = 100;
int[] reff = count.Repeat (i => i).ToArray ();
CircleEntry<int> circle = new CircleEntry<int> (reff);
Assert.IsFalse (circle.IsReadOnly);
}
public void CircleEntry_Insert_Test()
{
CircleEntry<int> start = new CircleEntry<int> (new int[] {1});
start.InsertBefore (0);
start.InsertAfter (2);
start = start.Previous;
for (int n = 0; n < 3; n++) {
Assert.AreEqual (start.Value, n);
start = start.Next;
}
start.InsertBefore (3);
for (int n = 0; n < 4; n++) {
Assert.AreEqual (start.Value, n);
start = start.Next;
}
}
public void CircleEntry_IndexOf_Test()
{
int count = 100;
int[] reff = count.Repeat (i => i).ToArray ();
CircleEntry<int> circle = new CircleEntry<int> (reff);
count.Repeat (i => Assert.AreEqual (i, circle.IndexOf (i)));
count.Repeat (i => Assert.AreEqual (i, circle.IndexOf (j => j == i)));
}
public void AddEntry(CircleEntry entry)
{
m_Entries.Add(entry.Theta, entry);
}
public void CircleEntry_ToString_Test()
{
int[] reff = new int[] { 2, 6, 4, 5, 8, 7, 3, 1, 0, 9 };
CircleEntry<int> circle = new CircleEntry<int> (reff);
Assert.IsNotEmpty (circle.ToString ());
circle = CircleEntry<int>.Empty;
Assert.IsNotEmpty (circle.ToString ());
}
public void AddEntry( CircleEntry entry )
{
m_Entries.Add( entry.Theta, entry );
}
public void Knot_Equals_Test()
{
CircleEntry<Edge> start = new CircleEntry<Edge> (new Edge[] {
Edge.Up,
Edge.Left,
Edge.Backward,
Edge.Down,
Edge.Right,
Edge.Forward
}
);
KnotMetaData metaData = new KnotMetaData (name: "test", countEdges: () => start.Count ());
Knot knot = new Knot (metaData, start);
for (int i = 0; i < 6; i++) {
Assert.IsTrue (knot.Equals (new Knot (metaData, start)));
start = start.Previous;
}
start.InsertBefore (Edge.Forward);
start.InsertAfter (Edge.Backward);
for (int i = 0; i < 6; i++) {
Assert.IsFalse (knot.Equals (new Knot (metaData, start)));
start = start.Previous;
}
}
