// only works right for a directed simple graph, that is // there is at most one edge between any two vertices public IntMatrix CreateDirectedIncidenceMatrix() { // for first we need to know how many edges there are in the graph // somehow label the edges var edges = new Dictionary <(int, int), int>(); int edgeCount = 0; for (int i = 0; i < m_nodes.Length; i++) { foreach (int j in m_nodes[i].connections) { edges.Add((i, j), edgeCount); edgeCount++; } } // now construct the matrix where: // height = # of verteces // width = # of edges IntMatrix result = new IntMatrix(m_nodes.Length, edgeCount); foreach (var((from, to), i) in edges) { result[from, i] = 1; result[to, i] = -1; } return(result); }
// basically diplicate logic for the default list graph representation I used public static IntMatrix ConvertAdjacencyToUndirectedIncidence(IntMatrix adjacency) { // for first we need to know how many edges there are in the graph // somehow label the edges var edges = new Dictionary <(int, int), int>(); int edgeCount = 0; for (int i = 0; i < adjacency.Height; i++) { for (int j = 0; j < adjacency.Width; j++) { if (adjacency[i, j] == 1 && edges.ContainsKey((j, i)) == false) { edges.Add((i, j), edgeCount); edgeCount++; } } } // now construct the matrix where: // height = # of verteces // width = # of edges IntMatrix result = new IntMatrix(adjacency.Height, edgeCount); foreach (var((from, to), i) in edges) { result[from, i] = 1; result[to, i] = 1; } return(result); }
public static IntMatrix ConvertAdjacencyToDirectedIncidence(IntMatrix adjacency) { // for first we need to know how many edges there are in the graph // somehow label the edges var edges = new List <(int, int)>(); for (int i = 0; i < adjacency.Height; i++) { for (int j = 0; j < adjacency.Width; j++) { if (adjacency[i, j] == 1) { edges.Add((i, j)); } } } // now construct the matrix where: // height = # of verteces // width = # of edges IntMatrix result = new IntMatrix(adjacency.Height, edges.Count); for (int i = 0; i < edges.Count; i++) { var(from, to) = edges[i]; result[from, i] = 1; result[to, i] = -1; } return(result); }
public static IntMatrix ConvertDirectedIncidenceToAdjacency(IntMatrix incidence) { var result = new IntMatrix(incidence.Height, incidence.Height); for (int i = 0; i < incidence.Width; i++) { // we need to initialize the values anyway int from = 0, to = 0; for (int j = 0; j < incidence.Height; j++) { if (incidence[j, i] == 1) { from = j; } else if (incidence[j, i] == -1) { to = j; } } result[from, to] = 1; // result[to, from] = -1; } return(result); }
public static IntMatrix ConvertKirchhoffToAdjacency(IntMatrix kirchhoff) { var result = -kirchhoff; for (int i = 0; i < result.Height; i++) { result[i, i] = 0; } return(result); }
public IntMatrix Fill(int value) { IntMatrix result = new IntMatrix(Height, Width); for (int i = 0; i < Height; i++) { for (int j = 0; j < Width; j++) { result.m_numbers[i, j] = value; } } return(result); }
public static IntMatrix operator -(IntMatrix matrix) { var result = new IntMatrix(matrix.Height, matrix.Width); for (int i = 0; i < matrix.Height; i++) { for (int j = 0; j < matrix.Width; j++) { result.m_numbers[i, j] = -matrix.m_numbers[i, j]; } } return(result); }
public IntMatrix CreateAdjacencyMatrix() { var result = new IntMatrix(m_nodes.Length, m_nodes.Length); for (int i = 0; i < m_nodes.Length; i++) { foreach (int j in m_nodes[i].connections) { result[i, j] = 1; } } return(result); }
/* * The definition of Kirchoff for a directed graph is inconsistent * https://www.wikiwand.com/en/Laplacian_matrix#/Definition * By this definition, if i != j, the entry in the matrix is * -1 if vi and vj are adjacent. Now, the way adjacency is defined * for vertices doesn't state whether, in a directed graph, if there * is a connection vi -> vj, vj is to be considered adjacent to vi. * In my mind, it is not. * However, when I apply the formula at * https://www.wikiwand.com/en/Laplacian_matrix#/Incidence_matrix * it seems to always give the result as though they were both adjacent, * which is why this conversion diverges in its results from * Incidence -> Kirchhoff conversion function (that one always results * in a simmetric matrix). */ public static IntMatrix ConvertAdjacencyToKirchhoff(IntMatrix adjacency) { var result = -adjacency; for (int i = 0; i < adjacency.Height; i++) { for (int j = 0; j < adjacency.Width; j++) { result[i, i] += adjacency[i, j]; } } return(result); }
public IntMatrix CreateKirchhoffMatrix() { var result = new IntMatrix(m_nodes.Length, m_nodes.Length); for (int i = 0; i < m_nodes.Length; i++) { foreach (int j in m_nodes[i].connections) { result[i, j] = -1; } result[i, i] = m_nodes[i].connections.Length; } return(result); }
public static IntMatrix operator -(IntMatrix lhs, IntMatrix rhs) { if (lhs.Width != rhs.Width || lhs.Height != rhs.Height) { throw new System.Exception("Dimensions didn't match, couldn't subtract the two matrices"); } var result = new IntMatrix(lhs.Height, lhs.Width); for (int i = 0; i < lhs.Height; i++) { for (int j = 0; j < lhs.Width; j++) { result.m_numbers[i, j] = lhs.m_numbers[i, j] - rhs.m_numbers[i, j]; } } return(result); }
public IntMatrix Mult(IntMatrix mat) { if (Width != mat.Height) { throw new System.Exception("The width doesn't match the height of the matrix multiplying into"); } var result = new IntMatrix(Height, mat.Width); for (int i = 0; i < Height; i++) { for (int j = 0; j < mat.Width; j++) { for (int k = 0; k < Width; k++) { result.m_numbers[i, j] += m_numbers[i, k] * mat.m_numbers[k, j]; } } } return(result); }
public static IntMatrix ConvertUndirectedIncidenceToAdjacency(IntMatrix incidence) { var result = new IntMatrix(incidence.Height, incidence.Height); List <int> currentEdge = new List <int>(2); for (int j = 0; j < incidence.Width; j++) { for (int i = 0; i < incidence.Height; i++) { if (incidence[i, j] == 1) { currentEdge.Add(i); } } result[currentEdge[0], currentEdge[1]] = 1; result[currentEdge[1], currentEdge[0]] = 1; currentEdge.Clear(); } return(result); }
public IntMatrix(IntMatrix matrix) { m_numbers = (int[, ])matrix.m_numbers.Clone(); }
// K = M_t * M public static IntMatrix ConvertDirectedIncidenceToKirchhoff(IntMatrix incidence) { return(incidence.Mult(incidence.Transpose)); }