Print test modularity

Author: Royar13

CMakeLists.txt

@@ -5,5 +5,5 @@ set(CMAKE_C_STANDARD 90)
 set(GCC_COVERAGE_COMPILE_FLAGS "-ansi -Wall -Wextra -Werror -pedantic-errors")
 set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${GCC_COVERAGE_COMPILE_FLAGS}" )
 
-add_executable(cluster cluster.c spmat.c matrix.h matrix.c graph.h graph.c LinkedList.h LinkedList.c VerticesGroup.h VerticesGroup.c division.h division.c defs.h defs.c ErrorHandler.c ErrorHandler.h quicksort.h quicksort.c tests/graphs/testUtils.c tests/graphs/testUtils.h)
-add_executable(tester tests/tester.h tests/tester.c spmat.c matrix.h matrix.c graph.h graph.c LinkedList.h LinkedList.c VerticesGroup.h VerticesGroup.c division.h division.c defs.h defs.c ErrorHandler.c ErrorHandler.h quicksort.h quicksort.c)
+add_executable(cluster cluster.c spmat.c matrix.h matrix.c graph.h graph.c LinkedList.h LinkedList.c VerticesGroup.h VerticesGroup.c division.h division.c defs.h defs.c ErrorHandler.c ErrorHandler.h quicksort.h quicksort.c)
+add_executable(tester tests/tester.h tests/tester.c spmat.c matrix.h matrix.c graph.h graph.c LinkedList.h LinkedList.c VerticesGroup.h VerticesGroup.c division.h division.c defs.h defs.c ErrorHandler.c ErrorHandler.h quicksort.h quicksort.c tests/testUtils.c tests/testUtils.h)

LinkedList.c

@@ -93,38 +93,3 @@ void removeItem(LinkedList *list, LinkedListNode *item){
         list->length = 0;
     }
 }
-
-/**
- * Prints the vertex-coloring a given group-list defines over
- * a n-vertices graph.
- * @param groupList a partition of graph vertices into groups.
- * @param n the number of vertices in the graph.
- */
-void printGroupList(LinkedList *groupList, int n){
-    int L = groupList->length;
-    int *coloring = malloc(sizeof(int) * n);
-    int i, j;
-    LinkedListNode *node = groupList->first;
-    VerticesGroup *group;
-    VertexNode *vertex;
-    assertMemoryAllocation(coloring);
-
-    for(i = 0; i < L; ++i){
-        group = node->pointer;
-        vertex = group->first;
-        for(j = 0; j < group->size; ++j){
-            coloring[vertex->index] = i;
-            vertex = vertex->next;
-        }
-        node = node->next;
-    }
-
-    printf("[");
-    if(n>0)
-        printf("%d", coloring[0]);
-    for(i = 1; i < n; ++i)
-        printf(",%d", coloring[i]);
-    printf("]\n");
-
-    free(coloring);
-}

LinkedList.h

@@ -23,6 +23,4 @@ void *insertItem(LinkedList *list, void *pointer);
 
 void removeItem(LinkedList *list, LinkedListNode *item);
 
-void printGroupList(LinkedList *groupList, int n);
-
 #endif

VerticesGroup.c

@@ -137,15 +137,15 @@ void calculateModularitySubMatrix(Graph *G, VerticesGroup *group) {
  * (otherwise, we'll have to sort it later).
  * @param group a non-empty VerticesGroup.
  */
-void fillVerticesArr(VerticesGroup *group){
+void fillVerticesArr(VerticesGroup *group) {
     VertexNode *node = group->first;
     int i = 0;
     char isSorted = 1;
     int prevIndex = node->index;
     group->verticesArr = malloc(sizeof(int) * group->size);
     assertMemoryAllocation(group->verticesArr);
     do {
-        if(node->index < prevIndex)
+        if (node->index < prevIndex)
             isSorted = 0;
         group->verticesArr[i] = node->index;
         ++i;
@@ -168,6 +168,9 @@ double multiplyModularityByVector(Graph *G, VerticesGroup *group, double *s, dou
     double numRes = 0;
     /* the common value of all rows of the multiplication of the expectedEdges (K) matrix by s */
     double degreesCommon = 0, modularityNorm1 = getModularityMatrixNorm1(group);
+    if (G->degreeSum == 0) {
+        return 0;
+    }
     group->edgeSubMatrix->mult(group->edgeSubMatrix, s, res);
     for (i = 0; i < group->size; i++) {
         degreesCommon += G->degrees[i] * s[i];

cluster.c

@@ -6,15 +6,15 @@
 #include "VerticesGroup.h"
 #include "LinkedList.h"
 #include "division.h"
+#include "defs.h"
 
 int main() {
     int i = 1, j;
     LinkedList *groupsLst;
     LinkedListNode *node;
     VerticesGroup *group;
     VertexNode *vNode;
-    Graph *G = constructGraphFromInput(
-            "graph.in");
+    Graph *G = constructGraphFromInput(GRAPH_FILE_PATH);
     srand(time(0));
     groupsLst = divisionAlgorithm(G);
     node = groupsLst->first;

defs.h

@@ -1,6 +1,7 @@
 #ifndef CLUSTER_DEFS_H
 #define CLUSTER_DEFS_H
 
+#define GRAPH_FILE_PATH "C:\\Users\\royar\\Source\\Workspaces\\Workspace\\C projects\\cproject-cluster\\graph.in"
 #define IS_POSITIVE(X) ((X)>0.0001)
 
 #endif

division.c

@@ -202,3 +202,29 @@ void saveOutputToFile(LinkedList *groupLst, char *output_path) {
     }
     fclose(output_file);
 }
+
+
+/**
+ * Calculate modularity of a graph's division
+ * @param groupLst
+ * @return modularity
+ */
+double calculateDivisionModularity(Graph *G, LinkedList *groupLst) {
+    double *s = malloc(sizeof(double) * G->n);
+    VerticesGroup *group;
+    double modularity = 0;
+    int i;
+    LinkedListNode *node = groupLst->first;
+    for (i = 0; i < G->n; i++) {
+        s[i] = 1;
+    }
+    if (node != NULL) {
+        do {
+            group = node->pointer;
+            calculateModularitySubMatrix(G, group);
+            modularity += calculateModularity(G, group, s);
+            node = node->next;
+        } while (node != groupLst->first);
+    }
+    return modularity;
+}

division.h

@@ -18,4 +18,6 @@ void divisionAlgRec(Graph *G, VerticesGroup *group, LinkedList *groupsLst, doubl
 
 void saveOutputToFile(LinkedList *groupLst, char *output_path);
 
+double calculateDivisionModularity(Graph *G, LinkedList *groupLst);
+
 #endif

tests/graphs/testUtils.c tests/testUtils.c

@@ -1,6 +1,8 @@
 #include <stdio.h>
+#include <stdlib.h>
 #include "testUtils.h"
-#include "../../spmat.h"
+#include "../spmat.h"
+#include "../ErrorHandler.h"
 
 /**
  * Print matrix (python style)
@@ -120,3 +122,38 @@ void printSpmat(spmat *spm) {
         printf("\n");
     }
 }
+
+/**
+ * Prints the vertex-coloring a given group-list defines over
+ * a n-vertices graph.
+ * @param groupList a partition of graph vertices into groups.
+ * @param n the number of vertices in the graph.
+ */
+void printGroupList(LinkedList *groupList, int n){
+    int L = groupList->length;
+    int *coloring = malloc(sizeof(int) * n);
+    int i, j;
+    LinkedListNode *node = groupList->first;
+    VerticesGroup *group;
+    VertexNode *vertex;
+    assertMemoryAllocation(coloring);
+
+    for(i = 0; i < L; ++i){
+        group = node->pointer;
+        vertex = group->first;
+        for(j = 0; j < group->size; ++j){
+            coloring[vertex->index] = i;
+            vertex = vertex->next;
+        }
+        node = node->next;
+    }
+
+    printf("[");
+    if(n>0)
+        printf("%d", coloring[0]);
+    for(i = 1; i < n; ++i)
+        printf(",%d", coloring[i]);
+    printf("]\n");
+
+    free(coloring);
+}

tests/graphs/testUtils.h tests/testUtils.h

@@ -1,12 +1,15 @@
 #ifndef CLUSTER_TESTUTILS_H
 #define CLUSTER_TESTUTILS_H
 
-#include "../../matrix.h"
+#include "../matrix.h"
+#include "../LinkedList.h"
 
 void printMatrix(Matrix *mat);
 
 void printMatrixPy(Matrix *mat);
 
 void printVect(double *vector, int length);
 
+void printGroupList(LinkedList *groupList, int n);
+
 #endif

tests/tester.c

@@ -1,7 +1,7 @@
 #include <stdlib.h>
 #include "tester.h"
 #include "../ErrorHandler.h"
-#include "../VerticesGroup.h"
+#include "testUtils.h"
 #include <time.h>
 #include <stdio.h>
 
@@ -82,21 +82,28 @@ Graph *generateCommunitiesGraph(LinkedList *GroupList, int n, char noise) {
  * @param n The number of vertices G consists of.
  * @return 1-if the partitions are equivalent. 0-otherwise.
  */
-char checkGroupListsEquality(LinkedList *GroupList1, LinkedList *GroupList2, int n) {
-    int i = 0, j = 0;
+char checkGroupListsEquality(LinkedList *GroupList1, testGraph *TG) {
+    int i = 0, j = 0, n = TG->G->n;
+    double modularity;
+    LinkedList *GroupList2 = TG->GroupList;
     LinkedListNode *node1 = GroupList1->first, *node2 = GroupList2->first;
     VerticesGroup *G1, *G2;
     VertexNode *vertex1, *vertex2;
     int *coloring1, *coloring2, *colorMapping;
     int n1 = 0, n2 = 0;
     int numberOfGroups = GroupList1->length;
+    modularity = calculateDivisionModularity(TG->G, GroupList1);
+    printf("Found modularity: %f\n", modularity);
+    modularity = calculateDivisionModularity(TG->G, GroupList2);
+    printf("Expected modularity: %f\n", modularity);
     if (numberOfGroups != GroupList2->length) {
         printf("The first partition consists of %d groups, while the second consists of %d groups.\n",
                GroupList1->length, GroupList2->length);
         printf("Coloring1: ");
         printGroupList(GroupList1, n);
         printf("Coloring2: ");
         printGroupList(GroupList2, n);
+
         return 0;
     }
     coloring1 = (int *) malloc(n * sizeof(int));
@@ -236,7 +243,7 @@ void destroyTestGraph(testGraph *TG) {
  */
 char performTest(testGraph *TG) {
     LinkedList *result = divisionAlgorithm(TG->G);
-    return checkGroupListsEquality(result, TG->GroupList, TG->G->n);
+    return checkGroupListsEquality(result, TG);
 }
 
 /**

tests/tester.h

@@ -1,15 +1,16 @@
 #ifndef CLUSTER_TESTER_H
 #define CLUSTER_TESTER_H
+
 #include "../division.h"
 
-typedef struct _testGraph{
+typedef struct _testGraph {
     Graph *G;
     LinkedList *GroupList;
 } testGraph;
 
 Graph *generateCommunitiesGraph(LinkedList *GroupList, int n, char noise);
 
-char checkGroupListsEquality(LinkedList *GroupList1, LinkedList *GroupList2, int n);
+char checkGroupListsEquality(LinkedList *GroupList1, testGraph *TG);
 
 testGraph *createTestGraph(int edges[][2], int length, int n, LinkedList *GroupList);
 
@@ -19,6 +20,6 @@ char performTest(testGraph *TG);
 
 char testGraphFromFile(char *path);
 
-void printResultsFromOutputFile(char* output_file_path);
+void printResultsFromOutputFile(char *output_file_path);
 
 #endif