public void BuildMesh(PartType partType, AdjacencyMatrix adjMatrix, MeshBuilder meshBuilder, BlockBounds clipBounds)
{
var slopeBuilder = new SlopedMeshBuilder(meshBuilder);
if (partType == PartType.OuterCorner) {
BuildMeshCorner(slopeBuilder);
}
}
public bool Search(AdjacencyMatrix matrix)
{
Bfs(matrix);
bool allNodesVisited = this.visitedNodes.Count == matrix.NodesCount();
return(allNodesVisited);
}
public BFSTraversal(AdjacencyMatrix adjacencyMatrix, Vertex[] vertexList, int vertexCount) :
base(adjacencyMatrix, vertexList, vertexCount)
{
_vertexList = vertexList;
_theQueue = new Queue <int>();;
_vertexCount = vertexCount;
_adjacencyMatrix = adjacencyMatrix;
}
public CommonGraph(AdjacencyMatrix adjMat, Vertex[] vertex, int vertexCount)
{
_vertexList = vertex;
_adjMatrix = adjMat;
_vertexCount = vertexCount;
_theStack = new Stack <int>();
_theQueue = new Queue <int>();
}
public Polyhedron(List <Point3D> points)
{
Vertices = points;
foreach (var point in points)
{
AdjacencyMatrix.Add(point, new List <Point3D>());
}
}
// [TestMethod]
public void Test5()
{
AdjacencyMatrix testMatrix = new AdjacencyMatrix("test5.txt");
BranchAndBound solver = new BranchAndBound(); solver.SetVariables(testMatrix);
solver.Solve();
Assert.AreEqual(solver.max, 269);
}
public void GraphTests_ShouldReturnException_ForInvalidVertix_Z()
{
var vertices = new int[] { 'A', 'B', 'C', 'D', 'E' };
var graph = new AdjacencyMatrix <int>(vertices);
graph.AddEdge('A', 'B');
graph.AddEdge('B', 'Z');
}
public void Test5()
{
AdjacencyMatrix testMatrix = new AdjacencyMatrix("test5.txt");
DynamicTSP solver = new DynamicTSP(testMatrix, 0);
solver.Solve();
Assert.AreEqual(solver.minTourCost, 269);
}
public DFSTraversal(AdjacencyMatrix adjacencyMatrix, Vertex[] vertexList, int vertexCount) :
base(adjacencyMatrix, vertexList, vertexCount)
{
_vertexList = vertexList;
_theStack = new Stack <int>();
_vertexCount = vertexCount;
_adjacencyMatrix = adjacencyMatrix;
}
//methods
public void Add(Vertex element)
{
Vertices?.Add(element);
element.Id = IdVertexesCounter;
IdVertexesCounter++;
AdjacencyMatrix.AddVertex();
}
public void GraphTests_ShowGive2Record()
{
var vertices = new int[] { 'A', 'B', 'C', 'D', 'E' };
var graph = new AdjacencyMatrix <int>(vertices);
graph.AddEdge('A', 'B');
Assert.AreEqual(2, graph.GetEdges().Count);
}
private static void test09()
//****************************************************************************80
//
// Purpose:
//
// TEST09 tests TRIANGULATION_ORDER3_ADJ_SET
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 04 January 2007
//
// Author:
//
// John Burkardt
//
{
int hole_num = 0;
int node_num = 0;
int triangle_num = 0;
Console.WriteLine("");
Console.WriteLine("TEST09");
Console.WriteLine(" TRIANGULATION_ORDER3_ADJ_SET sets the (lower)");
Console.WriteLine(" adjacencies defined by a triangulation.");
Order3_Example.triangulation_order3_example2_size(ref node_num, ref triangle_num, ref hole_num);
double[] node_xy = new double[2 * node_num];
int[] triangle_node = new int[3 * triangle_num];
int[] triangle_neighbor = new int[3 * triangle_num];
Order3_Example.triangulation_order3_example2(node_num, triangle_num, ref node_xy,
ref triangle_node, ref triangle_neighbor);
typeMethods.i4mat_transpose_print(3, triangle_num, triangle_node,
" TRIANGLE_NODE");
int[] adj_row = new int[node_num + 1];
int adj_num = Adjacency.triangulation_order3_adj_count(node_num, triangle_num,
triangle_node, triangle_neighbor, adj_row);
int[] adj = Adjacency.triangulation_order3_adj_set(node_num, triangle_num, triangle_node,
triangle_neighbor, adj_num, adj_row);
AdjacencyMatrix.adj_print(node_num, adj_num, adj_row, adj, " ADJ array:");
int bandwidth = AdjacencyMatrix.adj_bandwidth(node_num, adj_num, adj_row, adj);
Console.WriteLine("");
Console.WriteLine(" ADJ bandwidth = " + bandwidth + "");
}
public Graph(List <Vertex <T> > vertices)
{
_vertices = vertices;
for (int i = 0; i < _vertices.Count; i++)
{
_vertices[i].Index = i;
}
_adjacencyMatrix = new AdjacencyMatrix(_vertices.Count);
}
public void SingleVertexIsTheCenterOfTheGraph()
{
var m = new AdjacencyMatrix(new[] { 11 }, new[] { new Edge(11, 11), });
var service = new LogisticCenterService(m);
var center = service.CalculateLogisticCenter();
Assert.AreEqual(11, center);
}
public InvariantMap(AdjacencyMatrix matrix)
{
this.matrix = matrix;
container = new Container[matrix.Vertices - 2];
for (int i = 0; i < container.Length; i++)
{
container[i] = new Container();
}
}
public void EqualsTest2()
{
var adjMat1 = new AdjacencyMatrix(new[, ]
{
{ false, true, false, false },
{ true, false, true, true },
{ false, true, false, false },
{ false, true, false, false }
});
var graph1 = new UndirectedGraph(adjMat1);
var adjMat2 = new AdjacencyMatrix(new[, ]
{
{ false, true, false, true },
{ true, false, true, true },
{ false, true, false, false },
{ true, true, false, false }
});
var graph2 = new UndirectedGraph(adjMat2);
Assert.AreEqual(false, graph1.Equals(graph2));
var adjMat3 = new AdjacencyMatrix(new[, ]
{
{ false, false, false, true },
{ false, false, true, true },
{ false, true, false, false },
{ true, true, false, false }
});
var graph3 = new UndirectedGraph(adjMat3);
Assert.AreEqual(false, graph1.Equals(graph3));
var graph4 = new UndirectedGraph();
var graph5 = new UndirectedGraph();
var n0 = new Node(0, 0.ToString());
var n1 = new Node(1, 1.ToString());
var n2 = new Node(2, 2.ToString());
var n3 = new Node(3, 3.ToString());
graph4.TryAddNode(n2);
graph4.TryAddNode(n1);
graph4.TryAddNode(n0);
graph4.TryAddNode(n3);
graph5.TryAddNode(n0);
graph5.TryAddNode(n1);
graph5.TryAddNode(n2);
graph5.TryAddNode(n3);
Assert.AreEqual(true, graph4.Equals(graph5));
graph4.TryAddEdge(n1, n2);
graph4.TryAddEdge(n3, n1);
graph4.TryAddEdge(n1, n0);
Assert.AreEqual(true, graph1.Equals(graph4));
graph5.TryAddEdge(n0, n1);
graph5.TryAddEdge(n2, n1);
graph5.TryAddEdge(n1, n3);
Assert.AreEqual(true, graph4.Equals(graph5));
}
public PatternMap(AdjacencyMatrix matrix)
{
this.matrix = matrix;
patterns = new List <Pattern> [matrix.Vertices - 2];
for (int i = 0; i < patterns.Length; i++)
{
patterns[i] = new List <Pattern>();
}
}
public void Test04()
{
var m = new AdjacencyMatrix(new int[] { 1, 2 }, new Edge[]
{
new Edge(1, 2),
});
Assert.AreEqual("0110", m.Identity());
}
private List <int> HKC(int[] C, int[] newIndex)
{
int n = AdjacencyMatrix.GetLength(0);
int[] height = new int[n];
int diameter = 0;
for (int i = (n - 1); i > 0; i--)
{
var remote = C[i];
int newHeight = height[i] + 1;
int newDiam = height[remote] + newHeight;
if (newHeight > height[remote])
{
height[remote] = newHeight;
}
if (newDiam > diameter)
{
diameter = newDiam;
}
}
int radiusFloor = diameter / 2;
List <int> center = new List <int>();
for (int i = 0; i < n; i++)
{
if (height[i] == radiusFloor)
{
if (diameter % 2 == 1)
{
center.Add(i);
center.Add(C[i]);
}
else
{
center.Add(i);
}
break;
}
}
var result = new List <int>();
for (int i = 0; i < n; i++)
{
if (center.Contains(newIndex[i]))
{
result.Add(i);
}
}
return(result);
}
public void BuildMesh(PartType partType, AdjacencyMatrix adjMatrix, MeshBuilder meshBuilder, BlockBounds clipBounds)
{
if (PartType.BlockFront == partType) {
meshBuilder.AddTriangleStrip(
false,
meshBuilder.VertAutoNormal(new Vector3(1, 1, 0), new Vector2(1, 1), true),
meshBuilder.VertAutoNormal(new Vector3(1, 0, 0), new Vector2(1, 0), true),
meshBuilder.VertAutoNormal(new Vector3(0, 1, 0), new Vector2(0, 1), true),
meshBuilder.VertAutoNormal(new Vector3(0, 0, 0), new Vector2(0, 0), true));;
}
else if (PartType.BlockBack == partType)
{
meshBuilder.AddTriangleStrip(
false,
meshBuilder.VertAutoNormal(new Vector3(0, 1, 1), new Vector2(1, 1), true),
meshBuilder.VertAutoNormal(new Vector3(0, 0, 1), new Vector2(1, 0), true),
meshBuilder.VertAutoNormal(new Vector3(1, 1, 1), new Vector2(0, 1), true),
meshBuilder.VertAutoNormal(new Vector3(1, 0, 1), new Vector2(0, 0), true));
}
else if (PartType.BlockRight == partType)
{
meshBuilder.AddTriangleStrip(
false,
meshBuilder.VertAutoNormal(new Vector3(1, 1, 1), new Vector2(1, 1), true),
meshBuilder.VertAutoNormal(new Vector3(1, 0, 1), new Vector2(1, 0), true),
meshBuilder.VertAutoNormal(new Vector3(1, 1, 0), new Vector2(0, 1), true),
meshBuilder.VertAutoNormal(new Vector3(1, 0, 0), new Vector2(0, 0), true));
}
else if (PartType.BlockLeft == partType)
{
meshBuilder.AddTriangleStrip(
false,
meshBuilder.VertAutoNormal(new Vector3(0, 1, 0), new Vector2(1, 1), true),
meshBuilder.VertAutoNormal(new Vector3(0, 0, 0), new Vector2(1, 0), true),
meshBuilder.VertAutoNormal(new Vector3(0, 1, 1), new Vector2(0, 1), true),
meshBuilder.VertAutoNormal(new Vector3(0, 0, 1), new Vector2(0, 0), true));
}
else if (PartType.BlockTop == partType)
{
meshBuilder.AddTriangleStrip(
false,
meshBuilder.VertAutoNormal(new Vector3(1, 1, 1), new Vector2(1, 1), true),
meshBuilder.VertAutoNormal(new Vector3(1, 1, 0), new Vector2(1, 0), true),
meshBuilder.VertAutoNormal(new Vector3(0, 1, 1), new Vector2(0, 1), true),
meshBuilder.VertAutoNormal(new Vector3(0, 1, 0), new Vector2(0, 0), true));
}
else if (PartType.BlockBottom == partType)
{
meshBuilder.AddTriangleStrip(
false,
meshBuilder.VertAutoNormal(new Vector3(1, 0, 0), new Vector2(1, 1), true),
meshBuilder.VertAutoNormal(new Vector3(1, 0, 1), new Vector2(1, 0), true),
meshBuilder.VertAutoNormal(new Vector3(0, 0, 0), new Vector2(0, 1), true),
meshBuilder.VertAutoNormal(new Vector3(0, 0, 1), new Vector2(0, 0), true));
}
}
/// <summary>
/// Creates new instance of <see cref="FWAlgorithm"/>
/// </summary>
/// <param name="initialAdjacencyMatrix">adjacency matrix for graph</param>
public FWAlgorithm(AdjacencyMatrix initialAdjacencyMatrix)
{
// setting fields
this.initialAdjacencyMatrix = initialAdjacencyMatrix;
this.count = initialAdjacencyMatrix.Size;
this.current = -1;
// initializing steps
this.steps = new List <Step>(initialAdjacencyMatrix.Size);
}
public void Test07()
{
var m = new AdjacencyMatrix(new int[] { 1, 2, 3 }, new Edge[]
{
new Edge(2, 1),
new Edge(1, 2),
});
Assert.AreEqual("010100000", m.Identity());
}
public int VerticeDegree(int v)
{
int degree = 0;
for (int i = 0; i < AdjacencyMatrix.GetLength(0); i++)
{
degree += AdjacencyMatrix[v, i];
}
return(degree);
}
public void GraphWithDisconnectedVerticesDoesNotHaveCenter()
{
var m = new AdjacencyMatrix(new[] { 11, 12 },
new[] { new Edge(11, 11), new Edge(12, 12) });
var service = new LogisticCenterService(m);
var center = service.CalculateLogisticCenter();
Assert.AreEqual(-1, center);
}
public void Test9()
{
AdjacencyMatrix testMatrix = new AdjacencyMatrix("test9.txt");
BranchAndBound solver = new BranchAndBound(); solver.SetVariables(testMatrix);
solver.Solve();
DynamicTSP dynamicSolver = new DynamicTSP(testMatrix, 0);
dynamicSolver.Solve();
Assert.AreEqual(dynamicSolver.minTourCost, solver.max);
}
/// <summary>
/// Starts the game. Creates the random state of the polygons, deletes the container, then enabled the polygons.
/// </summary>
void startGame(Object obj)
{
winState = false;
Debug.Log("startGame called by " + obj.name);
enablePolygons(true);
AdjacencyMatrix adj = new AdjacencyMatrix(polygons);
Debug.Log(adj.ToString());
}
public void TwoConnectedVerticesShouldReturnSecondVertexAsCenter()
{
var m = new AdjacencyMatrix(new int[] { 11, 12 },
new[] { new Edge(11, 12), new Edge(12, 11) });
var service = new LogisticCenterService(m);
var center = service.CalculateLogisticCenter();
Assert.AreEqual(12, center);
}
public void Initialize()
{
this.Matrix = new AdjacencyMatrix(MATRIXLENGTH);
for (int i = 0; i < MATRIXLENGTH; i++)
{
for (int j = 0; j < MATRIXLENGTH; j++)
{
this.Matrix[i, j] = i * j;
}
}
}
public void PMXmultiThread()
{
String FileName = "C:\\Studia\\Genetic-multi-tasks\\GeneticMultiTask\\TSP instances\\br17.xml";
XDocument tspXmlFile = XDocument.Load(FileName);
AdjacencyMatrix matrix = new AdjacencyMatrix(tspXmlFile);
MultiThreadInversionMutation pmx = new MultiThreadInversionMutation(1);
MultiTaskGeneticSolver solver = new MultiTaskGeneticSolver(matrix, pmx, null, null, 100, 0);
List <Candidate> population = randomPopulation(50);
pmx.MutateList(population);
}
public Graph BellmanFord(FromVertex from)
{
Graph graph = from.graph;
AdjacencyList <string> adjacencyList = graph;
TreeAlgorithms <string> .BellmanFord(adjacencyList, from.orig, out GraphLib.Model.Graph <string> q);
AdjacencyMatrix <string> output = (AdjacencyMatrix <string>)q;
return(output);
}
public int FindC3ByMatrixMul3()
{
int n = AdjacencyMatrix.GetLength(0);
var AdjacencyMatrixCubed = ArrayHelper.Multiply(AdjacencyMatrix, ArrayHelper.Multiply(AdjacencyMatrix, AdjacencyMatrix));
int sum = 0;
for (int i = 0; i < n; i++)
{
sum += AdjacencyMatrixCubed[i, i];
}
return(sum / 6);
}
public void WriteAdjacencyMatrix()
{
for (int i = 0; i < AdjacencyMatrix.GetLength(0); i++)
{
for (int j = 0; j < AdjacencyMatrix.GetLength(1); j++)
{
Console.Write(AdjacencyMatrix[i, j] + "; ");
}
Console.WriteLine();
Console.WriteLine();
}
}
public void BuildMesh(PartType partType, AdjacencyMatrix adjMatrix, MeshBuilder meshBuilder, BlockBounds clipBounds)
{
SlopedMeshBuilder slopeBuilder = new SlopedMeshBuilder(meshBuilder);
if (PartType.OuterEdgeFront == partType) {
slopeBuilder.ConstructSlopedFront(slopeBuilder.GetOuterSlopePoints());
}else if (PartType.OuterEdgeLeft == partType)
{
Matrix4x4 mat = Matrix4x4.TRS(new Vector3(0, 0, 0), Quaternion.identity, new Vector3(-1, 1, 1));
slopeBuilder.ConstructSlopedSide(false, mat, slopeBuilder.GetOuterSlopePoints());
}else if (PartType.OuterEdgeRight == partType)
{
Matrix4x4 mat = Matrix4x4.TRS(new Vector3(1, 0, 0), Quaternion.identity, new Vector3(1, 1, 1));
slopeBuilder.ConstructSlopedSide(true, mat, slopeBuilder.GetOuterSlopePoints());
}
}
private AdjacencyMatrix<LayerTile> GetAdjacencyMatrixFromTiledMapLayer(TiledMapLayer tiledMapLayer, IDictionary<int, int> weights)
{
var result = new AdjacencyMatrix<LayerTile>();
foreach (var tile in tiledMapLayer.Tiles)
{
if (weights.ContainsKey(tile.Id))
{
foreach (var neighbour in tiledMapLayer.GetNeighboursFromTile(tile))
{
if (neighbour != null && weights.ContainsKey(neighbour.Id))
{
result.AddAdjacent(tile, neighbour, weights[neighbour.Id]);
}
}
}
}
return result;
}
