public void Point2_EqualsObject()
{
var point1 = new Point2(123, 456);
var point2 = new Point2(123, 456);
TheResultingValue(point1.Equals((Object)point2)).ShouldBe(true);
TheResultingValue(point1.Equals("This is a test")).ShouldBe(false);
}
public void Point2_EqualsObject()
{
var size1 = new Point2(123, 456);
var size2 = new Point2(123, 456);
TheResultingValue(size1.Equals((Object)size2)).ShouldBe(true);
TheResultingValue(size1.Equals("This is a test")).ShouldBe(false);
}
public void Point2_EqualsPoint()
{
var size1 = new Point2(123, 456);
var size2 = new Point2(123, 456);
var size3 = new Point2(123, 555);
var size4 = new Point2(222, 456);
TheResultingValue(size1.Equals(size2)).ShouldBe(true);
TheResultingValue(size1.Equals(size3)).ShouldBe(false);
TheResultingValue(size1.Equals(size4)).ShouldBe(false);
}
public void Point2_EqualsPoint()
{
var size1 = new Point2(123, 456);
var size2 = new Point2(123, 456);
var size3 = new Point2(123, 555);
var size4 = new Point2(222, 456);
TheResultingValue(size1.Equals(size2)).ShouldBe(true);
TheResultingValue(size1.Equals(size3)).ShouldBe(false);
TheResultingValue(size1.Equals(size4)).ShouldBe(false);
}
public void Point2_EqualsPoint()
{
var point1 = new Point2(123, 456);
var point2 = new Point2(123, 456);
var point3 = new Point2(123, 555);
var point4 = new Point2(222, 456);
TheResultingValue(point1.Equals(point2)).ShouldBe(true);
TheResultingValue(point1.Equals(point3)).ShouldBe(false);
TheResultingValue(point1.Equals(point4)).ShouldBe(false);
}
public void equal_type()
{
var a = new Point2(1, 2);
var b = new Point2(3, 4);
var c = new Point2(3, 4);
Assert.False(a.Equals(b));
Assert.False(a.Equals(c));
Assert.False(b.Equals(a));
Assert.True(b.Equals(c));
Assert.False(c.Equals(a));
Assert.True(c.Equals(b));
}
public void equal_object()
{
var a = new Point2(1, 2);
var b = new Point2(3, 4);
var c = new Point2(3, 4);
Assert.False(a.Equals((object)(new Vector2(b))));
Assert.False(a.Equals((object)(new Vector2(c))));
Assert.False(((object)b).Equals(a));
Assert.True(((object)b).Equals(new Vector2(c)));
Assert.False(c.Equals((object)a));
Assert.True(c.Equals((object)b));
}
public void equal_coordinate_pair()
{
var a = new Point2(1, 2);
var b = new Point2(3, 4);
var c = new Point2(3, 4);
ICoordinatePair <double> nil = null;
Assert.False(a.Equals((ICoordinatePair <double>)b));
Assert.False(a.Equals((ICoordinatePair <double>)c));
Assert.False(b.Equals((ICoordinatePair <double>)a));
Assert.True(b.Equals((ICoordinatePair <double>)c));
Assert.False(c.Equals((ICoordinatePair <double>)a));
Assert.True(c.Equals((ICoordinatePair <double>)b));
Assert.False(a.Equals(nil));
}
public void Equality(Point2 point1, Point2 point2, bool expectedToBeEqual)
{
Assert.IsTrue(Equals(point1, point2) == expectedToBeEqual);
Assert.IsTrue(point1 == point2 == expectedToBeEqual);
Assert.IsFalse(point1 == point2 != expectedToBeEqual);
Assert.IsTrue(point1.Equals(point2) == expectedToBeEqual);
if (expectedToBeEqual)
{
Assert.AreEqual(point1.GetHashCode(), point2.GetHashCode());
}
}
void FixedUpdate()
{
if (!isWaitingForMainQueue)
{
StartCoroutine(WaitForMainQueue());
}
Point2 p = CurrentChunk();
if (!p.Equals(centerChunk))
{
centerChunk = p;
needTerrainUpdate = true;
}
}
public void CreateCurves()
{
/* not used
* if (StartTime == 35915)
* {
* int u = 0;
* }*/
this.Curves = new List <Curve>();
int n = this.Points.Count;
if (n == 0)
{
return;
}
Point2 lastPoint = this.Points[0];
Curve currentCurve = null;
for (int i = 0; i < n; i++)
{
// if there are two points in a row that are the same control point then it is a red control point
// and a new curve exists
if (lastPoint.Equals(this.Points[i]))
{
currentCurve = this.CreateCurve();
this.Curves.Add(currentCurve);
}
currentCurve.AddPoint(this.Points[i].ToVector2());
lastPoint = this.Points[i];
}
this._TotalLength = 0;
int lastIndex = this.Curves.Count - 1;
for (int i = 0; i < lastIndex; i++)
{
this.Curves[i].Init();
this._TotalLength += this.Curves[i].Length;
}
if (lastIndex >= 0)
{
// the last curve will be affected by the 'pixel length' property of sliders which
// limit how long it is (so that way it ends in time with the beat, not geometrically)
Curve lastCurve = this.Curves[lastIndex];
lastCurve.PixelLength = this.PixelLength - this._TotalLength;
lastCurve.Init();
this._TotalLength += lastCurve.Length;
}
}
public bool SharesEndPoint(LineSegment line, out Point sharedPoint)
{
if (Point1.Equals(line.Point1) || Point1.Equals(line.Point2))
{
sharedPoint = Point1;
return(true);
}
else if (Point2.Equals(line.Point2) || Point2.Equals(line.Point1))
{
sharedPoint = Point2;
return(true);
}
sharedPoint = new Point(0, 0);
return(false);
}
internal void Add(Point2 <T> start, Point2 <T> end)
{
if (start == null || end == null || start.Equals(end))
{
return;
}
LineSegment2 <T> seg = start.Factory.ConstructSegment(start, end);
Node <T> n = new Node <T>(start, seg);
Node <T> p = new Node <T>(end, seg);
this.Nodes.Add(n);
this.Nodes.Add(p);
Edge <T> e = new Edge <T>(n, p);
this.Edges.Add(e);
}
public bool Equals(LineSegment line)
{
if (Point1.Equals(line.Point1))
{
if (Point2.Equals(line.Point2))
{
return(true);
}
}
else if (Point1.Equals(line.Point2))
{
if (Point2.Equals(line.Point1))
{
return(true);
}
}
return(false);
}
public Point SharedVertex(Segment s)
{
if (Point1.Equals(s.Point1))
{
return(Point1);
}
if (Point1.Equals(s.Point2))
{
return(Point1);
}
if (Point2.Equals(s.Point1))
{
return(Point2);
}
if (Point2.Equals(s.Point2))
{
return(Point2);
}
return(null);
}
/// <summary>
/// Main method that gets called for determining ad.
/// </summary>
public void run()
{
init(Globals.d);
var allEdges = Initialization.initializeEdges();
var candidateVertexQueue = new Queue <Point2>();
var invalidVertexFlag = false; //flag to determine if one of the tests fail (i.e. candidate vertex cannot be a vertex).
var st = DateTime.Now; // datetime variable to track running time.
var timeCheck = true; // bool to display running time for each check.
Point2 currentCandidate;
foreach (Point2 candidateVertex in CandidateVertices)
{
candidateVertexQueue.Enqueue(candidateVertex);
}
//go through a number of checks to see if candidate vertex is still valid.
while (candidateVertexQueue.Count != 0)
{
currentCandidate = candidateVertexQueue.Dequeue();
foreach (Point2 possibleEdge in allEdges)
{
//add possibleEdge to currentCandidate
Point2 thisCandidate = Point2.AddPoints(currentCandidate, possibleEdge);
invalidVertexFlag = false; //reset vertex flag
if (thisCandidate == null)
{
if (Globals.ShowMessages)
{
Console.WriteLine("ERROR: thisCandidate is null. Check possibleEdge being added to currentCandidate.");
}
invalidVertexFlag = true;
continue;
}
thisCandidate.SortLexicographically(); //sort coordinates of points to account for symmetry
//Testing output
Console.WriteLine("Now checking: {0}. # of elements in queue: {1}", thisCandidate, candidateVertexQueue.Count);
st = DateTime.Now;
//check to see if currentCandidate is in RedVertices List
foreach (Point2 thisRedVertex in RedVertices)
{
if (thisCandidate.Equals(thisRedVertex))
{
if (Globals.ShowMessages)
{
Console.WriteLine("{0} is a red vertex.", thisCandidate);
}
invalidVertexFlag = true;
break;
}
}
if (timeCheck)
{
Console.WriteLine("Checking Red Vertices: {0}ms.", st - DateTime.Now);
}
st = DateTime.Now;
if (invalidVertexFlag)
{
continue;
}
//check if sum of coordinates is > d*2^(d-2)
if (thisCandidate.SumOfCoordinates() > (Globals.d * Math.Pow(2, (Globals.d - 2))))
{
if (Globals.ShowMessages)
{
Console.WriteLine("{0}. Sum of coordinates exceeds d*2^(d-2).", thisCandidate);
}
NonVertices.Add(thisCandidate);
continue;
}
if (timeCheck)
{
Console.WriteLine("Checking Sum of Coords > d*2^(d-2): {0}ms.", st - DateTime.Now);
}
st = DateTime.Now;
foreach (int coordinate in thisCandidate.Coordinates)
{
if (coordinate == 0)
{
if (Globals.ShowMessages)
{
Console.WriteLine("--Eliminated. In Red Vertices List (one of the coordinates is 0).");
}
invalidVertexFlag = true;
break;
}
}
if (timeCheck)
{
Console.WriteLine("Checking Each Coord for 0: {0}ms.", st - DateTime.Now);
}
st = DateTime.Now;
if (invalidVertexFlag)
{
continue;
}
//check if currentCandidate is in list of vertices
foreach (Point2 thisVertex in Vertices)
{
if (thisCandidate.Equals(thisVertex))
{
if (Globals.ShowMessages)
{
Console.WriteLine("--Eliminated. In Vertices List.");
}
invalidVertexFlag = true;
break;
}
}
if (timeCheck)
{
Console.WriteLine("In Vertex List Check: {0}ms.", st - DateTime.Now);
}
st = DateTime.Now;
if (invalidVertexFlag)
{
continue;
}
//check if currentCandidate is in list of non-vertices
foreach (Point2 thisNonVertex in NonVertices)
{
if (thisCandidate.Equals(thisNonVertex))
{
if (Globals.ShowMessages)
{
Console.WriteLine("--Eliminated. In Non Vertices List.");
}
invalidVertexFlag = true;
break;
}
}
if (timeCheck)
{
Console.WriteLine("In Nonvertex List Check: {0}ms.", st - DateTime.Now);
}
st = DateTime.Now;
if (invalidVertexFlag)
{
continue;
}
//check if currentCandidate is in list of FinalCandidate (e.g. already checked before).
foreach (Point2 thisFinalCandidate in FinalCandidateVertexList)
{
if (thisCandidate.Equals(thisFinalCandidate))
{
if (Globals.ShowMessages)
{
Console.WriteLine("--Eliminated. In Final Candidate List.");
}
invalidVertexFlag = true;
break;
}
}
if (timeCheck)
{
Console.WriteLine("In Final Candidate List Check: {0}ms.", st - DateTime.Now);
}
st = DateTime.Now;
if (invalidVertexFlag)
{
continue;
}
//Check if currentCandidate is in one of the cones
if (InsideConeCheck(thisCandidate))
{
if (Globals.ShowMessages)
{
Console.WriteLine("{0} is inside a cone.", thisCandidate);
}
NonVertices.Add(thisCandidate);
continue;
}
if (timeCheck)
{
Console.WriteLine("Inside Cone CHeck: {0}ms.", st - DateTime.Now);
}
st = DateTime.Now;
//Epsilon Check -- check eps{ij}=1 while eps{i}=eps{j}=0 and eps{ij}=0 while eps{i}=eps{j}=1
if (EpsilonCheck(thisCandidate))
{
if (Globals.ShowMessages)
{
Console.WriteLine("{0} failed the epsilon check.", thisCandidate);
}
}
if (timeCheck)
{
Console.WriteLine("Epsilon Check: {0}ms.", st - DateTime.Now);
}
st = DateTime.Now;
//Double decomposition heuristic
if (DoubleDecompositionHeuristic(thisCandidate, allEdges))
{
if (Globals.ShowMessages)
{
Console.WriteLine("{0} has at least two decompositions.", thisCandidate);
}
NonVertices.Add(thisCandidate);
if (timeCheck)
{
Console.WriteLine("DDHeuristic: {0}ms.", st - DateTime.Now);
}
st = DateTime.Now;
continue;
}
if (timeCheck)
{
Console.WriteLine("DDHeuristic: {0}ms.", st - DateTime.Now);
}
if (Globals.ShowMessages)
{
Console.WriteLine("Adding {0} to Final Candidate Vertex List.", thisCandidate);
}
FinalCandidateVertexList.Add(thisCandidate);
candidateVertexQueue.Enqueue(thisCandidate);
}
}
CandidateVertexPostProcessing(FinalCandidateVertexList);
Console.WriteLine("\n\nRed Vertices:");
foreach (Point2 p in RedVertices)
{
Console.WriteLine(p);
}
Console.WriteLine("\n\nFinal Candidate Vertex List: ");
foreach (Point2 p in FinalCandidateVertexList)
{
Console.WriteLine(p);
}
}
public void runWithCandidate(Point2 candidate)
{
init(Globals.d);
List <Point2> allEdges = Initialization.initializeEdges();
Queue <Point2> candidateVertexQueue = new Queue <Point2>();
var invalidVertexFlag = false; //flag to dtermine if one of the tests fail (i.e. candidate vertex cannot be a vertex).
var st = DateTime.Now;
foreach (Point2 candidateVertex in CandidateVertices)
{
candidateVertexQueue.Enqueue(candidateVertex);
}
invalidVertexFlag = false; //reset vertex flag
if (candidate == null)
{
if (Globals.ShowMessages)
{
Console.WriteLine("ERROR: thisCandidate is null. Check possibleEdge being added to currentCandidate.");
}
invalidVertexFlag = true;
return;
}
candidate.SortLexicographically(); //sort coordinates of points to account for symmetry
//Testing output
Console.WriteLine("Now checking: {0}. # of elements in queue: {1}", candidate, candidateVertexQueue.Count);
//check to see if currentCandidate is in RedVertices List
foreach (Point2 thisRedVertex in RedVertices)
{
if (candidate.Equals(thisRedVertex))
{
if (Globals.ShowMessages)
{
Console.WriteLine("{0} is a red vertex.", candidate);
}
if (Globals.ShowMessages)
{
Console.WriteLine("--Eliminated. In Red Vertices List.");
}
invalidVertexFlag = true;
break;
}
}
//check if sum of coordinates is > d*2^(d-2)
if (candidate.SumOfCoordinates() > (Globals.d * Math.Pow(2, (Globals.d - 2))))
{
if (Globals.ShowMessages)
{
Console.WriteLine("{0}. Sum of coordinates exceedds d*2^(d-2).", candidate);
}
NonVertices.Add(candidate);
return;
}
foreach (int coordinate in candidate.Coordinates)
{
if (coordinate == 0)
{
if (Globals.ShowMessages)
{
Console.WriteLine("--Eliminated. In Red Vertices List (one of the coordinates is 0).");
}
invalidVertexFlag = true;
break;
}
}
//check if currentCandidate is in list of vertices
foreach (Point2 thisVertex in Vertices)
{
if (candidate.Equals(thisVertex))
{
if (Globals.ShowMessages)
{
Console.WriteLine("--Eliminated. In Vertices List.");
}
invalidVertexFlag = true;
break;
}
}
//check if currentCandidate is in list of non-vertices
foreach (Point2 thisNonVertex in NonVertices)
{
if (candidate.Equals(thisNonVertex))
{
if (Globals.ShowMessages)
{
Console.WriteLine("--Eliminated. In Non Vertices List.");
}
invalidVertexFlag = true;
break;
}
}
foreach (Point2 thisFinalCandidate in FinalCandidateVertexList)
{
if (candidate.Equals(thisFinalCandidate))
{
if (Globals.ShowMessages)
{
Console.WriteLine("--Eliminated. In Final Candidate List.");
}
invalidVertexFlag = true;
break;
}
}
if (invalidVertexFlag)
{
return;
}
//Check if currentCandidate is in one of the cones
if (InsideConeCheck(candidate))
{
Console.WriteLine("{0} is inside a cone.", candidate);
return;
}
//Check decomposition heuristic
if (DoubleDecompositionHeuristic(candidate, allEdges))
{
Console.WriteLine("{0} has at least two decompositions.", candidate);
return;
}
Console.WriteLine("Adding {0} to Final Canddiate Vertex List.", candidate);
}
public void equal_type() {
var a = new Point2(1, 2);
var b = new Point2(3, 4);
var c = new Point2(3, 4);
Assert.False(a.Equals(b));
Assert.False(a.Equals(c));
Assert.False(b.Equals(a));
Assert.True(b.Equals(c));
Assert.False(c.Equals(a));
Assert.True(c.Equals(b));
}
public static List <Point2> GenerateV(Point2 u)
{
var result = new List <Point2>();
var candidateV = new Point2();
var vCoordinates = new int[u.GetDimension()];
var g0 = new int[Globals.d];
var terminateFlag = false;
//set first v candidate
for (int i = 0; i < u.GetDimension(); i++)
{
vCoordinates[i] = Globals.k - u.Coordinates[i] - Globals.gap;
}
while (!terminateFlag)
{
candidateV = new Point2(vCoordinates);
//same point check
if (u.Equals(candidateV))
{
if (Globals.ShowMessages)
{
Console.WriteLine(candidateV.ToString() + ": Eliminated. Same point as u.");
}
}
//inverse check
else if (CheckInverse(u, candidateV))
{
if (Globals.ShowMessages)
{
Console.WriteLine(candidateV.ToString() + ": Eliminated. Inverse already checked.");
}
}
else
{
var uRedundant = false;
var vRedundant = false;
//generate gi
for (int i = 0; i < Globals.d; i++)
{
g0[i] = Globals.gap + u.Coordinates[i] + vCoordinates[i] - Globals.k;
}
//check vStar, given gap i, check that both u and v exist within the vertex set of the corresponding facets.
if (!CheckVertexSet(u, candidateV, g0, Globals.d - 1, Globals.k))
{
if (Globals.ShowMessages)
{
Console.WriteLine(candidateV.ToString() + ": Eliminated. Point does not belong to vertex set.");
}
}
//check convex core
else if (CheckConvexCore(u, candidateV, g0, out uRedundant, out vRedundant))
{
result.Add(candidateV);
if (Globals.ShowMessages)
{
Console.WriteLine("u: " + u + ". v: " + candidateV);
}
}
else
{
if (Globals.ShowMessages)
{
Console.Write("u: " + u + ". v: ");
foreach (int i in vCoordinates)
{
Console.Write(i + " ");
}
Console.WriteLine(" eliminated, " + (uRedundant && vRedundant ? "u and v are not vertices " :
(uRedundant ? "u is not a vertex " : "v is not a vertex ")) +
"of the convex core.");
}
}
result.Add(candidateV);
if (Globals.ShowMessages)
{
Console.WriteLine("u: " + u + ". v: " + candidateV);
}
}
//increment candidate and check termination condition
while (symmetryCheck(u.Coordinates, vCoordinates))
{
IncrementCandidatePoint(u.Coordinates, vCoordinates, out terminateFlag);
}
}
return(result);
}
public void equal_coordinate_pair() {
var a = new Point2(1, 2);
var b = new Point2(3, 4);
var c = new Point2(3, 4);
ICoordinatePair<double> nil = null;
Assert.False(a.Equals((ICoordinatePair<double>)b));
Assert.False(a.Equals((ICoordinatePair<double>)c));
Assert.False(b.Equals((ICoordinatePair<double>)a));
Assert.True(b.Equals((ICoordinatePair<double>)c));
Assert.False(c.Equals((ICoordinatePair<double>)a));
Assert.True(c.Equals((ICoordinatePair<double>)b));
Assert.False(a.Equals(nil));
}
public void equal_object() {
var a = new Point2(1, 2);
var b = new Point2(3, 4);
var c = new Point2(3, 4);
Assert.False(a.Equals((object)(new Vector2(b))));
Assert.False(a.Equals((object)(new Vector2(c))));
Assert.False(((object)b).Equals(a));
Assert.True(((object)b).Equals(new Vector2(c)));
Assert.False(c.Equals((object)a));
Assert.True(c.Equals((object)b));
}
public void Inequality(Point2 point, object obj, bool expectedToBeEqual)
{
Assert.IsTrue(point.Equals(obj) == expectedToBeEqual);
}
public bool Equals(LineSegment2D other) => Point1.Equals(other.Point1) && Point2.Equals(other.Point2);
public bool Equals(Side side)
{
return((Point1.Equals(side.Point1) && Point2.Equals(side.Point2)) ||
(Point1.Equals(side.Point2) && Point2.Equals(side.Point1)));
}
public bool HasPoint(Point p)
{
return(Point1.Equals(p) || Point2.Equals(p));
}
