public static void TestComparison_VERTEX()
{
Vertex a = RandVertex();
Vertex b = RandVertex();
Vertex c = RandVertex();
Vertex d = new Vertex(a);
// reference
Assert.IsFalse(a == b);
Assert.IsFalse(a == c);
Assert.IsTrue(a == d);
// hash
Assert.IsFalse(a.GetHashCode() == b.GetHashCode());
Assert.IsFalse(a.GetHashCode() == c.GetHashCode());
Assert.True(a.GetHashCode() == d.GetHashCode());
// value
Assert.AreNotEqual(a, b);
Assert.AreNotEqual(a, c);
Assert.AreEqual(a, d);
d.normal *= 3f;
Assert.AreNotEqual(a, d);
}
public void testGetVertexId()
{
AreEqual(vertexA.VertexId, vertexB.VertexId);
AreEqual(vertexA, vertexB);
AreEqual(vertexA.GetHashCode(), vertexB.GetHashCode());
}
public override int GetHashCode()
{
return(slotIndex.GetHashCode()
^ position.GetHashCode()
^ rotation.GetHashCode()
);
}
public void TestGetHashCode()
{
var vn = new Vertex(1.2f, -3.4f, 5);
var facet = new Facet(vn, null);
Assert.Equal(vn.GetHashCode(), facet.GetHashCode());
}
public override int GetHashCode()
{
unchecked
{
return((A.GetHashCode() * 397) ^ B.GetHashCode());
}
}
public void GetHashCode_SameVertices_ShouldBeUnique()
{
var vert1 = new Vertex(0, 0, 0);
var vert2 = new Vertex(0, 0, 0);
Assert.AreNotEqual(vert1, vert2);
Assert.AreNotEqual(vert1.GetHashCode(), vert2.GetHashCode());
}
public void TestGetHashCode()
{
var vertex = new Vertex(12.34f, -98.7f, 54);
Assert.Equal(
(12.34f).GetHashCode() ^ (-98.7f).GetHashCode() ^ (54f).GetHashCode()
, vertex.GetHashCode()
);
}
public override int GetHashCode()
{
unchecked {
int result = A.GetHashCode();
result = (result * 397) ^ B.GetHashCode();
result = (result * 397) ^ C.GetHashCode();
return(result);
}
}
public void VertexGetHashCodeTest()
{
for (var i = 0; i < 500; i++)
{
var vA = new Vertex(GenDoubleList(0));
var vB = new Vertex(GenDoubleList(vA.Dimension));
Assert.IsFalse(vA.GetHashCode() == vB.GetHashCode());
}
}
public override int GetHashCode()
{
var hashCode = 1748542731;
hashCode = hashCode * -1521134295 + Vertex.GetHashCode();
hashCode = hashCode * -1521134295 + Normal.GetHashCode();
hashCode = hashCode * -1521134295 + UV.GetHashCode();
return(hashCode);
}
public override int GetHashCode()
{
return(lightSource.GetHashCode()
^ transform.GetHashCode()
^ color.GetHashCode()
^ intensity.GetHashCode()
^ lightSourceDataArray.GetHashCode()
);
}
public void TestGetHashCode()
{
var vertex = new Vertex(12.34f, -98.7f, 54);
Assert.Equal(
(12.34f).GetHashCode() ^ (-98.7f).GetHashCode() ^ (54f).GetHashCode()
, vertex.GetHashCode()
);
}
public override int GetHashCode()
{
return(occluderType.GetHashCode()
^ origin.GetHashCode()
^ normal.GetHashCode()
^ xAxis.GetHashCode()
^ yAxis.GetHashCode()
^ pairOffset.GetHashCode()
);
}
public Edge(Vertex a, Vertex b)
{
if (a.Equals(b))
{
throw new System.ArgumentException("Can't create an edge with identical vertices");
}
vertices = (a.GetHashCode() < b.GetHashCode()) ? new[] { a, b } : new[] { b, a };
id = (vertices[0].GetHashCode() << 16) ^ vertices[1].GetHashCode();
midpoint = Vector3.zero;
}
public override int GetHashCode()
{
unchecked
{
int result = p1.GetHashCode();
result = (result * 100) ^ p2.GetHashCode();
result = (result * 100) ^ p3.GetHashCode();
return(result);
}
}
public void TestEquals_IncidentEdgesNotEqual()
{
Vector3 position = Auxilaries.RandomPosition();
Vertex thisVertex = new Vertex(position);
Vertex otherVertex = new Vertex(position);
HalfEdge edge1 = Auxilaries.RandomHalfEdge();
HalfEdge edge2 = Auxilaries.RandomHalfEdge();
HalfEdge edge3 = Auxilaries.RandomHalfEdge();
thisVertex.AddIncidentEdge(edge1);
thisVertex.AddIncidentEdge(edge2);
otherVertex.AddIncidentEdge(edge3);
Assert.IsFalse(thisVertex.Equals(otherVertex));
Assert.IsFalse(otherVertex.Equals(thisVertex));
Assert.AreNotEqual(thisVertex.GetHashCode(), otherVertex.GetHashCode());
}
public override int GetHashCode()
{
////// Überarbeiten wenn Vertex und Triangle ids bekommen?! Schneller?!
unchecked // Overflow is fine, just wrap
{
int hash = 17;
// Suitable nullity checks etc, of course :)
hash = hash * 23 + Vertex.GetHashCode();
if (SmoothingGroup == null)
{
hash = hash * 23 + Triangle.GetHashCode();
}
hash = hash * 23 + Material.GetHashCode();
if (SmoothingGroup != null)
{
hash = hash * 23 + SmoothingGroup.GetHashCode();
}
return(hash);
}
}
/// <summary>
/// Override of GetHashCode method
/// </summary>
/// <returns></returns>
public override int GetHashCode()
{
return(Centre.GetHashCode() ^ Vertex.GetHashCode());
}
public override int GetHashCode()
{
return(v1.GetHashCode() ^ v2.GetHashCode() ^ v3.GetHashCode());
}
public override int GetHashCode()
{
return(position.GetHashCode() ^ orientation.GetHashCode() ^ scaling.GetHashCode() ^ name.GetHashCode()
^ opposingBoneIndex.GetHashCode() ^ parentBoneIndex.GetHashCode() ^ hash.GetHashCode() ^ unknown2.GetHashCode());
}
public void GetHashCodeTest0()
{
Vertex v0 = new Vertex();
Vertex v1 = new Vertex();
Assert.IsTrue(v0.GetHashCode() == v1.GetHashCode());
}
public void GetHashCodeTest1()
{
Vertex v0 = new Vertex(new Vector3(2f, 234.4f, 30f), new Vector2(-341f, 234000f), new Vector3(9f, 24.4f, 330f), new Vector3(255f, 2.4f, 10.315f));
Vertex v1 = new Vertex(new Vector3(2f, 234.4f, 30f), new Vector2(-341f, 234000f), new Vector3(9f, 24.4f, 330f), new Vector3(255f, 2.4f, 10.315f));
Assert.IsTrue(v0.GetHashCode() == v1.GetHashCode());
}
public void TestGetHashCode()
{
var vn = new Vertex(1.2f, -3.4f, 5);
var facet = new Facet(vn, null);
Assert.Equal(vn.GetHashCode(), facet.GetHashCode());
}
static void Main(string[] args)
{
try
{
/*
* VertexStringDictionary verticesNames = new VertexStringDictionary();
* EdgeStringDictionary edgesNames = new EdgeStringDictionary();
* EdgeDoubleDictionary edgesWeights = new EdgeDoubleDictionary();
* IncidenceGraph g = new IncidenceGraph(true);
*
* // adding vertex
* Vertex u = g.AddVertex();
* verticesNames[u]="u";
* Vertex v = g.AddVertex();
* verticesNames[v]="v";
* Vertex w = g.AddVertex();
* verticesNames[w]="w";
* Vertex x = g.AddVertex();
* verticesNames[x]="x";
* Vertex y = g.AddVertex();
* verticesNames[y]="y";
* Vertex z = g.AddVertex();
* verticesNames[z]="z";
*
* // adding edges
* Edge uv = g.AddEdge(u,v);
* edgesNames[uv]="uv";
* edgesWeights[uv]=1;
* Edge ux = g.AddEdge(u,x);
* edgesNames[ux]="ux";
* edgesWeights[ux]=0.8;
* Edge wu = g.AddEdge(w,u);
* g.AddEdge(w,u);
* edgesNames[wu]="wu";
* edgesWeights[wu]=0.2;
* Edge xv = g.AddEdge(x,v);
* edgesNames[xv]="xv";
* edgesWeights[xv]=1.1;
* Edge vy = g.AddEdge(v,y);
* edgesNames[vy]="vy";
* edgesWeights[vy]=2.0;
* Edge wy = g.AddEdge(w,y);
* edgesNames[wy]="wy";
* edgesWeights[wy]=1.5;
* Edge yw = g.AddEdge(y,w);
* edgesNames[yw]="yw";
* edgesWeights[yw]=0.2;
* Edge wz = g.AddEdge(w,z);
* edgesNames[wz]="wz";
* edgesWeights[wz]=0.1;
*
* RandomGraph.Graph(g, 20,50,new Random(),true);
*
* /*
* // do a dfs serach
* Console.WriteLine("---- DepthFirstSearch");
* DepthFirstSearchAlgorithm dfs = new DepthFirstSearchAlgorithm(g);
* //TestDepthFirstSearchVisitor dfsVis =
* // new TestDepthFirstSearchVisitor(dfs,verticesNames);
* AlgorithmTracerVisitor dfstracer = new
* AlgorithmTracerVisitor(g,"dfs",".",GraphvizImageType.Png);
* dfstracer.VertexLabels = verticesNames;
* dfstracer.RegisterVertexHandlers(dfs);
* dfstracer.RegisterEdgeHandlers(dfs);
*
* dfs.Compute();
*/
Vertex source = u;
source = RandomGraph.Vertex(g, new Random());
Console.WriteLine("source: {0}", source.GetHashCode());
Console.WriteLine("---- BreathFirstSearch");
BreadthFirstSearchAlgorithm bfs = new BreadthFirstSearchAlgorithm(g);
TestBreadthFirstSearchVisitor bfsVis
= new TestBreadthFirstSearchVisitor(bfs, verticesNames, source);
AlgorithmTracerVisitor bfstracer = new
AlgorithmTracerVisitor(g, "bfs", ".", GraphvizImageType.Png);
// bfstracer.VertexLabels = verticesNames;
bfs.RegisterTreeEdgeBuilderHandlers(bfsTracer);
bfs.RegisterVertexColorizeHandlers(bfsTracer);
bfs.Compute(source);
/*
* Console.WriteLine("---- Dijkstra");
* DijkstraShortestPathAlgorithm dij = new DijkstraShortestPathAlgorithm(
* g,
* edgesWeights
* );
* TestDijkstraShortestPathVisitor dijVis = new TestDijkstraShortestPathVisitor(dij,verticesNames);
* AlgorithmTracerVisitor dijtracer = new
* AlgorithmTracerVisitor(g,"dij",".",GraphvizImageType.Png);
* dijtracer.VertexLabels = verticesNames;
* dijtracer.EdgeLabels = edgesWeights;
* dijtracer.RegisterVertexHandlers(dij);
* // dijtracer.RegisterEdgeHandlers(dij);
* dij.Compute(g.Vertex(0));
*
* Console.WriteLine("Distance from {0}", verticesNames[g.Vertex(0)]);
* foreach(DictionaryEntry de in dij.Distances)
* {
*
* Console.WriteLine("\t-> {0}, {1}",
* verticesNames[(Vertex)de.Key],
* de.Value.ToString()
* );
* }
*
* Console.WriteLine("---- Topological sort");
* VertexCollection vs = new VertexCollection();
* TopologicalSortAlgorithm tps= new TopologicalSortAlgorithm(g);
* tps.Compute(vs);
* foreach(Vertex ve in vs)
* {
* Console.WriteLine("v - {0}",verticesNames[ve]);
* }
*
* Console.WriteLine("--- graphviz output");
* GraphvizWriterAlgorithm gw = new GraphvizWriterAlgorithm(
* g,"dotgenerator",".",GraphvizImageType.Png);
* TestGraphvizVertex gv = new TestGraphvizVertex(verticesNames);
* gw.WriteVertex += new VertexHandler( gv.WriteVertex );
* gw.WriteEdge+= new EdgeHandler( gv.WriteEdge );
* gw.Write(GraphvizImageType.Png);
* gw.Write(GraphvizImageType.Svg);
* gw.Write(GraphvizImageType.Svgz);
* gw.Write(GraphvizImageType.Gif);
* gw.Write(GraphvizImageType.Jpeg);
*/
Console.WriteLine("Test finished");
String s2 = Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
String s = Console.ReadLine();
}
}
public override int GetHashCode()
{
return(vertexA.GetHashCode() * vertexB.GetHashCode() * vertexC.GetHashCode());
}
public override int GetHashCode()
{
return(from.GetHashCode() * to.GetHashCode() + passive.GetHashCode());
}
public override int GetHashCode()
{
var shash = ((uint)s.GetHashCode() << 16) | ((uint)s.GetHashCode() >> (31 - 15));
return((int)shash ^ t.GetHashCode());
}
public override int GetHashCode()
{
return(dest.GetHashCode()); //Ꝋ(1)
}
//Method used to generate a hashcode for a given edge. Used by HashSet.
public override int GetHashCode()
{
return(vert1.GetHashCode() + vert2.GetHashCode());
}
public override int GetHashCode()
{
return(vertex1.GetHashCode() ^ vertex2.GetHashCode());
}
