Merge branch 'develop'

Author: b08lsoai

.github/workflows/CI.yml

@@ -0,0 +1,25 @@
+name: Test # autorun of the project build and tests
+
+on: 
+  workflow_dispatch:
+  pull_request:
+    paths:
+      - '**.kt'
+  push:
+    paths:
+      - '**.kt'
+jobs: 
+  test:
+    runs-on: ubuntu-latest 
+    steps: 				   
+      - name: Check out repository code
+        uses: actions/checkout@v4
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          java-version: '21'
+          distribution: zulu
+      - name: Build 
+        run: ./gradlew build -x test 
+      - name: Test
+        run: ./gradlew test 

gradlew

@@ -9,24 +9,30 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.setValue
 import androidx.compose.ui.window.Window
 import androidx.compose.ui.window.application
+import model.graph.DirectedGraph
 import model.graph.Graph
 import model.graph.UndirectedGraph
 import view.MainScreen
 import viewmodel.MainScreenViewModel
 import viewmodel.graph.CircularPlacementStrategy
 
-val sampleGraph = UndirectedGraph<String>().apply {
+val sampleGraph = DirectedGraph<String>().apply {
   addVertex(1, "A")
   addVertex(2, "B")
   addVertex(3, "C")
   addVertex(4, "D")
   addVertex(5, "E")
-
-  addEdge(Pair(1, 2), 1)
-  addEdge(Pair(2, 3), 2)
+  addVertex(6, "F")
+  addVertex(7, "G")
+  addVertex(8, "H")
+  addVertex(9, "I")
+  addEdge(Pair(1, 2), 4)
+  addEdge(Pair(2, 3), 12)
   addEdge(Pair(3, 4), 3)
-  addEdge(Pair(2, 4), 4)
-  addEdge(Pair(1, 5), 5)
+  addEdge(Pair(4, 3), 56)
+  addEdge(Pair(7, 8), 0)
+  addEdge(Pair(8, 9), 19)
+  addEdge(Pair(9, 7), 2)
 }
 
 @Composable

src/main/kotlin/Main.kt

@@ -1,68 +1,162 @@
 package model.algorithms
 
-import model.graph.Graph
 import model.graph.Edge
+import model.graph.UndirectedGraph
+import model.graph.Vertex
+
+/**
+ * The class [CycleSearch] implements the algorithm for finding a cycle around
+ * selected vertex of the undirected graph.
+ *
+ * At the same time, the algorithm has some minimization of the desired cycle
+ * by iterating through possible pairs of neighbors of the selected vertex
+ * through which the desired cycle will pass.
+ * @param D input type
+ * @property [graph] a undirected graph for whose vertex we will search for a cycle
+ * @constructor Creates a graph, based on [graph],for which it will be possible to apply
+ * a cycle search algorithm around the vertex selected in it.
+ */
+
+class CycleSearch<D>(private val graph: UndirectedGraph<D>) {
+
+    /**
+     * This auxiliary function for the function [findAnyCycle] aims to get from
+     * some hashmap with extra elements the hashmap the elements of which
+     * accurately describe found cycle path.
+     *
+     * @param cyclePath hashmap with extra elements
+     * @param cycleVertexId the index of the vertex around which the cycle must be found
+     * @return cycle path
+     * @receiver private fun [findAnyCycle]
+     */
+    private fun getCyclePath(cyclePath: HashMap<Int, Int>, cycleVertexId: Int): HashMap<Int, Int> {
+
+        var current: Int = cycleVertexId
+        var next: Int
+        val returnCyclePath = HashMap<Int, Int>()
+        do {
+            next = cyclePath.filter { it.key == current }.values.first()
+            returnCyclePath[current] = next
+            current = next
+        } while (current != cycleVertexId)
+
+        return returnCyclePath
 
-class CycleSearch<D>(private val graph: Graph<D>) {
+    }
 
-    fun findCycle(cycleVertexId: Int): List<Edge<D>>? {
+    /**Searches for a cycle by dfs algorithm and writes it into [cyclePath]
+     *
+     *
+     * @param cycleVertexId the index of the vertex around which the cycle must be found
+     * @param currentVertexId using for recording the [cyclePath]
+     * @param visited stores information about which vertices of the graph
+     * have already been processed by [dfs]
+     * @param cyclePath hashmap consisting of elements that can be used to restore the found cycle path
+     * by applying the auxiliary function [getCyclePath] to it in function [findAnyCycle].
+     * @receiver private fun [findAnyCycle]
+     */
+    private fun dfs(
+        cycleVertexId: Int,
+        currentVertexId: Int,
+        visited: HashMap<Int, Boolean>,
+        cyclePath: HashMap<Int, Int>
+    ) {
+
+        for (idAdjacency in graph.adjacency[currentVertexId]!!.keys) {
 
-        if (cycleVertexId !in graph.vertices.keys) {
-            throw IllegalArgumentException("Vertex with index = $cycleVertexId doesn't exist in the graph. The cycle can't be found")
+            if (visited[idAdjacency] == false) {
+                visited[idAdjacency] = true
+                cyclePath[currentVertexId] = idAdjacency
+                dfs(cycleVertexId, idAdjacency, visited, cyclePath)
+            } else if (idAdjacency == cycleVertexId && cyclePath[cycleVertexId] != currentVertexId) {
+                cyclePath[currentVertexId] = idAdjacency
+                return
+            }
         }
+    }
 
-        val visited = HashMap<Int, Boolean>()
-        for (vertexId in graph.vertices.keys) {
-            visited[vertexId] = false
+    /** Finds any existing cycle in the graph around a given vertex
+     *
+     * @param vertexId the index of the vertex around which the cycle must be found
+     * @return found cycle path or null if the cycle doesn't exist around vertex with id = [vertexId]
+     * @receiver fun [findCycle]
+     */
+    private fun findAnyCycle(vertexId: Int): HashMap<Int, Int>? {
+
+        val devCyclePath = HashMap<Int, Int>()
+        val visited = hashMapOf<Int, Boolean>()
+        for (idVertex in graph.vertices.keys) {
+            visited[idVertex] = false
         }
-        val cycleWayFrom =
-            HashMap<Int, Int>()
-        val cycleIsFound = Array<Boolean>(1) { false }
-        val returnList = mutableListOf<Edge<D>>()
-
-        dfs(cycleVertexId, visited, cycleWayFrom, cycleVertexId, cycleIsFound, returnList)
-        if (cycleIsFound[0]) {
-            return returnList
+        visited[vertexId] = true
+        dfs(vertexId, vertexId, visited, devCyclePath)
+
+        if (devCyclePath.filter { it.value == vertexId }.isEmpty()) {
+            return null
         }
-        return null
+        return getCyclePath(devCyclePath, vertexId)
 
     }
 
-    private fun dfs(
-        vertexId: Int,
-        visited: HashMap<Int, Boolean>,
-        cycleWayFrom: HashMap<Int, Int>,
-        cycleVertexId: Int,
-        cycleIsFound: Array<Boolean>,
-        returnList: MutableList<Edge<D>>
-    ) {
+    /**
+     * The function implements the algorithm for finding a cycle around
+     * vertex with id = [vertex] of the undirected graph.
+     *
+     * The function searches for a cycle and performs some minimization of it.
+     * During the cycle minimization we iterate through variants of cycle,
+     * based on the choice of a pair of neighbors of [vertex] through which the cycle will pass.
+     * Each of the found cycle variants is written to a variable 'currentCyclePath'
+     * and its size compared with 'minCycleSize'.
+     * @param vertex the vertex around which the cycle must be found
+     * @return cycle path or null if it doesn't exist
+     */
+    fun findCycle(vertex: Vertex<D>): UndirectedGraph<D>? {
+
+        var returnCyclePath = hashMapOf<Int, Int>()
+        var currentCyclePath: HashMap<Int, Int>?
+        var minCycleSize: Int = Int.MAX_VALUE
+
+        if (vertex.id !in graph.vertices.keys) {
+            throw IllegalArgumentException("Vertex with id = ${vertex.id} doesn't exist in the graph")
+        }
+        val returnGraph = UndirectedGraph<D>()
+        if (graph.adjacency[vertex.id]!!.size < 2) {
+            return null
+        } else { // we consider all possible cases of a cycle by choosing a pair of neighbors to minimize the found cycle
+            val adjacencyOfVertex: MutableList<Int> = arrayListOf()
+            graph.adjacency[vertex.id]!!.keys.forEach { adjacencyOfVertex.add(it) }
+            val adjacencyWas: MutableList<Int> = arrayListOf()
+            val removedEdges: MutableList<Edge<Int>> = arrayListOf()
+            for (firstAdjacency in adjacencyOfVertex) {
+                adjacencyWas.add(firstAdjacency)
+                for (secondAdjacency in adjacencyOfVertex.filter { it !in adjacencyWas && it != vertex.id }) {
+
+                    for (adjacency in graph.adjacency[vertex.id]!!.filter { it.key != firstAdjacency && it.key != secondAdjacency }) {
+                        removedEdges.add(Edge(vertex.id to adjacency.key, adjacency.value))
+                        graph.removeEdge(vertex.id to adjacency.key, adjacency.value)
+                    }
 
-        visited[vertexId] = true
+                    currentCyclePath = findAnyCycle(vertex.id)
+                    if (currentCyclePath != null && currentCyclePath.size < minCycleSize) {
+                        minCycleSize = currentCyclePath.size
+                        returnCyclePath = currentCyclePath
+                    }
 
-        if (!cycleIsFound[0]) {
-            for (adjacencyVertexId in graph.adjacency[vertexId]!!.keys) {
-
-                if (visited[adjacencyVertexId] == false) {
-                    cycleWayFrom[adjacencyVertexId] = vertexId
-                    dfs(adjacencyVertexId, visited, cycleWayFrom, cycleVertexId, cycleIsFound, returnList)
-                } else if (adjacencyVertexId == cycleVertexId && adjacencyVertexId != cycleWayFrom[vertexId]) {
-                    cycleWayFrom[cycleVertexId] = vertexId
-                    var id = cycleWayFrom.keys.last()
-                    while (id != cycleVertexId) {
-                        returnList.add(Edge<D>(cycleWayFrom[id]!! to id, graph.adjacency[cycleWayFrom[id]]!![id]))
-                        id = cycleWayFrom[id]!!
+                    for (edge in removedEdges) {
+                        graph.addEdge(edge.vertices, edge.weight)
                     }
-                    returnList.add(Edge<D>(cycleWayFrom[id]!! to id, graph.adjacency[cycleWayFrom[id]]!![id]))
-                    cycleIsFound[0] = true
+                    removedEdges.clear()
                 }
-
             }
         }
-    }
-
-
-}
-
 
+        if (minCycleSize == Int.MAX_VALUE) {
+            return null
+        }
+        returnCyclePath.forEach { returnGraph.addVertex(it.key, graph.vertices[it.key]!!.data) }
+        returnCyclePath.forEach { returnGraph.addEdge(it.key to it.value, graph.adjacency[it.key]!![it.value]) }
+        return returnGraph
 
+    }
 
+}

src/main/kotlin/model/algorithms/CycleSearch.kt

@@ -0,0 +1,90 @@
+package model.algorithms
+
+import model.graph.DirectedGraph
+import model.graph.Graph
+import model.graph.UndirectedGraph
+import kotlin.math.roundToInt
+
+/** The class [HarmonicCentrality] implements the normalized harmonic centrality algorithm for
+ * a graph of any kind. For implementation using the Dijkstra algorithm.
+ *
+ * Harmonic centrality is a kind of closeness centrality, but the difference is that
+ * this algorithm is relevant not only for connected graphs, but also for disconnected ones.
+ * The harmonic centrality index for each vertex of the graph is calculated using the formula:
+ *     Index = sum(1/the length of the shortest path to i-th vertex),
+ *     for i in 1..n-1, where 'n' is amount of graph vertices.
+ * So that the index value lies in the interval from 0 to 1, we use the normalization of the centrality index
+ * by dividing the result by n, where 'n' is amount of graph vertices:
+ *     Index = sum(1/the length of the shortest path to i-th vertex) / n,
+ *     for i in 1..n-1, where 'n' is amount of graph vertices.
+ * In this case the length of the path is the amount of edges of this path.
+ *
+ * @param D input type
+ * @property [graph] a graph (of any kind) for the vertices of which it is necessary to calculate the centrality index
+ * @constructor Creates a graph, based on [graph], for which the algorithm for calculating the
+ * normalized harmonic centrality can be applied.
+ */
+
+class HarmonicCentrality<D>(private val graph: Graph<D>) {
+
+    /**
+     * This auxiliary function for the function [getIndex], that rounds
+     * the value [number] to the 4th digit after the decimal point.
+     *
+     * @return result of rounding
+     * @receiver [getIndex]
+     */
+    private fun roundTo(number: Double): Double {
+        return (number * 10000.0).roundToInt() / 10000.0
+    }
+
+    /**
+     * This function calculate the centrality index for vertex with id = [vertexId].
+     *
+     * @param graph graph for the vertex of which we calculate the centrality index.
+     * But weight of each graph edge is 1, what is used for applying Dijkstra algorithm.
+     * @param vertexId the index of the vertex for which calculating the centrality index.
+     * @return centrality index of vertex with id = [vertexId]
+     * @receiver [harmonicCentrality]
+     */
+    private fun getIndex(graph: Graph<D>, vertexId: Int): Double {
+
+        var index = 0.00
+
+        graph.vertices.filter { it.key != vertexId }
+            .forEach {
+                if (Dijkstra(graph).findShortestPaths(vertexId, it.key).isNotEmpty()) {
+                    index += 1.0 / ((Dijkstra(graph).findShortestPaths(vertexId, it.key)).size - 1)
+                }
+            }
+
+        return roundTo(index / (graph.vertices.size - 1))
+
+    }
+
+    /**
+     * This function calculates the centrality index for each graph vertex.
+     *
+     * @return hashmap, where key = vertex id; value =  centrality index.
+     */
+    fun harmonicCentrality(): HashMap<Int, Double> {
+
+        val centralityIndexes = HashMap<Int, Double>()
+
+        val graphForCentrality: Graph<D> = if (graph is UndirectedGraph) {
+            UndirectedGraph()
+        } else {
+            DirectedGraph()
+        }
+        graph.vertices.forEach { graphForCentrality.addVertex(it.key, it.value.data) }
+        graph.edges.forEach { graphForCentrality.addEdge(it.vertices, 1) }
+
+        for (vertexId in graphForCentrality.vertices.keys) {
+            centralityIndexes[vertexId] = getIndex(graphForCentrality, vertexId)
+        }
+
+        return centralityIndexes
+
+    }
+
+}