Merge pull request #5 from idodoron11/division-alg

Division alg

Author: Royar13

CMakeLists.txt

@@ -5,4 +5,4 @@ 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 VerticesGroup.h VerticesGroup.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)

LinkedList.c

@@ -0,0 +1,76 @@
+#include <stdlib.h>
+#include "LinkedList.h"
+
+/**
+ * Creates a new empty linked list.
+ * @return a pointer to the new list.
+ */
+LinkedList *createLinkedList(){
+    LinkedList *list = malloc(sizeof(LinkedList));
+    list->length = 0;
+    return list;
+}
+
+/**
+ * Destroys a given list and frees up its allocated memory.
+ * @param list a linked list.
+ */
+void freeLinkedList(LinkedList *list){
+    LinkedListNode *temp;
+    LinkedListNode *node = list->first;
+    if (node != NULL) {
+        do {
+            temp = node->next;
+            free(node);
+            node = temp;
+        } while (node != list->first);
+    }
+    free(list);
+}
+
+/**
+ * Inserts a new item to a given list.
+ * In case this list functions as a list of VerticesGroups, 'value' should be a pointer to a 'VerticesGroup'.
+ * @param list the list where the item should be inserted.
+ * @param pointer a pointer to some variable of any type. (casting). Can be NULL.
+ * @param index an integer.
+ * @return a pointer to the new LinkedListNode.
+ */
+void *insertItem(LinkedList *list, void *pointer, int index){
+    LinkedListNode *node = malloc(sizeof(LinkedListNode));
+    node->pointer = pointer;
+    node->index = index;
+    if (list->length != 0) {
+        node->next = list->first;
+        node->prev = list->first->prev;
+        list->first->prev->next = node;
+        list->first->prev = node;
+    } else {
+        list->first = node;
+        node->prev = node;
+        node->next = node;
+    }
+    list->length++;
+    return node;
+}
+
+/**
+ * Removes a specific item from a list.
+ * @param list a linked list
+ * @param item a LinkedListNode pointer to some item in 'list'.
+ */
+void removeItem(LinkedList *list, LinkedListNode *item){
+    LinkedListNode *oldPrev = item->prev;
+    LinkedListNode  *oldNext = item->next;
+    if(list->length > 1){
+        oldPrev->next = oldNext;
+        oldNext->prev = oldPrev;
+        free(item);
+        list->length--;
+    }
+    else if(list->length == 1){
+        free(item);
+        list->first = NULL;
+        list->length = 0;
+    }
+}

LinkedList.h

@@ -0,0 +1,25 @@
+#ifndef CLUSTER_LINKEDLIST_H
+#define CLUSTER_LINKEDLIST_H
+
+#include "VerticesGroup.h"
+
+typedef struct _LinkedListNode {
+    void *pointer;
+    int index;
+    struct _LinkedListNode *next;
+    struct _LinkedListNode *prev;
+} LinkedListNode;
+typedef struct _LinkedList {
+    LinkedListNode *first;
+    int length;
+} LinkedList;
+
+LinkedList *createLinkedList();
+
+void freeLinkedList(LinkedList *list);
+
+void *insertItem(LinkedList *list, void *pointer, int index);
+
+void removeItem(LinkedList *list, LinkedListNode *item);
+
+#endif

VerticesGroup.c

@@ -7,6 +7,10 @@
 VerticesGroup *createVerticesGroup() {
     VerticesGroup *group = malloc(sizeof(VerticesGroup));
     group->size = 0;
+    group->edgesMinusBHatSubMatrix = NULL;
+    group->edgeSubMatrix = NULL;
+    group->bSubMatrix = NULL;
+    group->bHatSubMatrix = NULL;
     return group;
 }
 
@@ -20,13 +24,21 @@ void freeVerticesGroup(VerticesGroup *group) {
             node = temp;
         } while (node != group->first);
     }
-    freeMatrix(group->bHatSubMatrix);
-    group->edgeSubMatrix->free(group->edgeSubMatrix);
+    if (group->bHatSubMatrix != NULL) {
+        freeMatrix(group->bHatSubMatrix);
+    }
+    if (group->edgesMinusBHatSubMatrix != NULL) {
+        freeMatrix(group->edgesMinusBHatSubMatrix);
+    }
+    if (group->edgeSubMatrix != NULL) {
+        group->edgeSubMatrix->free(group->edgeSubMatrix);
+    }
 }
 
 VertexNode *addVertexToGroup(VerticesGroup *group, int index) {
     VertexNode *node = malloc(sizeof(VertexNode));
     node->index = index;
+    node->hasMoved = 0;
     if (group->size != 0) {
         node->next = group->first;
         node->prev = group->first->prev;
@@ -41,15 +53,29 @@ VertexNode *addVertexToGroup(VerticesGroup *group, int index) {
     return node;
 }
 
+void removeVertexFromGroup(VerticesGroup *group, VertexNode *node) {
+    if (group->first == node) {
+        if (group->size == 1) {
+            group->first = NULL;
+        } else {
+            group->first = node->next;
+        }
+    }
+    node->prev->next = node->next;
+    node->next->prev = node->prev;
+    group->size--;
+    free(node);
+}
+
 /**
  * Adds a sequence of indices to the group.
  * @param group the group to which nodes are added.
  * @param sequence a sequence of integers, representing nodes in a graph.
  * @param length the length of the input sequence.
  */
-void addSequence(VerticesGroup *group, int *sequence, int length){
+void addSequence(VerticesGroup *group, int *sequence, int length) {
     int i;
-    for(i = 0; i < length; ++i)
+    for (i = 0; i < length; ++i)
         addVertexToGroup(group, sequence[i]);
 }
 
@@ -66,6 +92,7 @@ void calculateSubMatrix(Matrix *A, int M, VerticesGroup *group) {
     int i = 0, j;
     if (group->size != 0) {
         group->edgeSubMatrix = spmat_allocate_list(group->size);
+        group->edgesMinusBHatSubMatrix = createMatrix(group->size);
         group->bSubMatrix = createMatrix(group->size);
         group->bHatSubMatrix = createMatrix(group->size);
         group->verticesArr = malloc(sizeof(int) * group->size);
@@ -81,6 +108,7 @@ void calculateSubMatrix(Matrix *A, int M, VerticesGroup *group) {
                 row[j] = readVal(A, group->verticesArr[i], group->verticesArr[j]);
                 /* For each vertex v: A[v][0] + ... + A[v][n-1] = deg(v) */
                 expectedEdges = A->rowSums[group->verticesArr[i]] * A->rowSums[group->verticesArr[j]] / M;
+                setVal(group->edgesMinusBHatSubMatrix, i, j, -expectedEdges);
                 setVal(group->bSubMatrix, i, j, row[j] - expectedEdges);
                 /* the case where delta(i,j)=0 */
                 if (i != j) {
@@ -89,10 +117,29 @@ void calculateSubMatrix(Matrix *A, int M, VerticesGroup *group) {
             }
             /* the case where i=j and so delta(i,j)=1. we subtract deg(i) from B[g][i][j]. */
             setVal(group->bHatSubMatrix, i, i, readVal(group->bSubMatrix, i, i) - group->bSubMatrix->rowSums[i]);
+            setVal(group->edgesMinusBHatSubMatrix, i, i,
+                   readVal(group->edgesMinusBHatSubMatrix, i, i) - group->bSubMatrix->rowSums[i]);
             group->edgeSubMatrix->add_row(group->edgeSubMatrix, row, i);
         }
 
         free(row);
     }
 }
 
+/**
+ * Calculate modularity delta of group's division given by an eigenvector
+ * @param group
+ * @param s eigenvector
+ * @return
+ */
+double calculateModularity(VerticesGroup *group, double *s) {
+    double *res, numRes;
+    res = malloc(group->size * sizeof(double));
+    group->edgeSubMatrix->mult(group->edgeSubMatrix, s, res);
+    numRes = vectorMult(s, res, group->size);
+    matrixVectorMult(group->edgesMinusBHatSubMatrix, s, res);
+    numRes -= vectorMult(s, res, group->size);
+    numRes *= 0.5;
+    free(res);
+    return numRes;
+}

VerticesGroup.h

@@ -6,6 +6,8 @@
 
 typedef struct vertexNode {
     int index;
+    /*Has the node's group changed during modularity maximization*/
+    int hasMoved;
     struct vertexNode *next;
     struct vertexNode *prev;
 } VertexNode;
@@ -15,8 +17,11 @@ typedef struct verticesGroup {
     int size;
     int *verticesArr;
     spmat *edgeSubMatrix;
+    /*a matrix that equals bHat-A*/
+    Matrix *edgesMinusBHatSubMatrix;
     Matrix *bSubMatrix;
     Matrix *bHatSubMatrix;
+
 } VerticesGroup;
 
 VerticesGroup *createVerticesGroup();
@@ -25,8 +30,12 @@ void freeVerticesGroup(VerticesGroup *group);
 
 VertexNode *addVertexToGroup(VerticesGroup *group, int index);
 
+void removeVertexFromGroup(VerticesGroup *group, VertexNode *node);
+
 void addSequence(VerticesGroup *group, int *sequence, int length);
 
 void calculateSubMatrix(Matrix *A, int M, VerticesGroup *group);
 
+double calculateModularity(VerticesGroup *group, double *s);
+
 #endif

cluster.c

@@ -5,73 +5,34 @@
 #include "spmat.h"
 #include "graph.h"
 #include "VerticesGroup.h"
-
-void randVector(double *vector, int n);
-
-void printVector(double *vector, int length);
+#include "LinkedList.h"
+#include "division.h"
 
 int main() {
-    spmat *A;
-    Matrix *AMatrix;
-    int M, n, gSize = 20;
-    double *vector, *s, lambda;
-    graph *G = constructGraphFromInput("graph.in");
-    int gVertices[] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19};
+    int i = 1, j;
+    LinkedList *groupsLst;
+    LinkedListNode *node;
     VerticesGroup *group;
-    n = G->n;
+    VertexNode *vNode;
+    graph *G = constructGraphFromInput("graph.in");
     srand(time(0));
-    vector = malloc(gSize * sizeof(double));
-    s = malloc(gSize * sizeof(double));
-    AMatrix = createMatrix(n);
-    /* A = generateRandomSymSpmat(n, 20, AMatrix); */
-    A = G->spAdjMat;
-    AMatrix = G->adjMat;
-    M = G->M;
-    group = createVerticesGroup();
-    addSequence(group, gVertices, gSize);
-    calculateSubMatrix(AMatrix, M, group);
-    randVector(vector, gSize);
-    printf("Edges matrix:\n");
-    printSpmat(A);
-    printf("\nEdges sub matrix:\n");
-    printSpmat(group->edgeSubMatrix);
-    printf("\nB sub matrix:\n");
-    printMatrix(group->bSubMatrix);
-    printf("\nB-hat sub matrix:\n");
-    printMatrix(group->bHatSubMatrix);
-    printf("\nShifted B-hat sub matrix:\n");
-    setMatrixShift(group->bHatSubMatrix, 1);
-    printMatrix(group->bHatSubMatrix);
-    setMatrixShift(group->bHatSubMatrix, 0);
-    printf("\ns vector:\n");
-    lambda = powerIteration(group->bHatSubMatrix, vector, s);
-    printVector(s, gSize);
-    printf("\nlambda: %f\n", lambda);
-    return 0;
-}
-
-/**
- * Generate a random vector
- * @param vector an allocated array of size n for the vector
- * @param n the size of the vector
- */
-void randVector(double *vector, int n) {
-    int i;
-    for (i = 0; i < n; i++) {
-        *(vector + i) = rand();
+    groupsLst = divisionAlgorithm(G);
+    node = groupsLst->first;
+    if (node != NULL) {
+        do {
+            printf("Group %d:\n", i);
+            group = (VerticesGroup *) node->pointer;
+            vNode = group->first;
+            for (j = 0; j < group->size; j++) {
+                printf("%d ", vNode->index);
+                vNode = vNode->next;
+            }
+            printf("\n\n");
+            i++;
+            node = node->next;
+        } while (node != groupsLst->first);
     }
-}
 
-/**
- * Print vector
- * @param vector
- * @param length
- */
-void printVector(double *vector, int length) {
-    int i;
-    printf("( ");
-    for (i = 0; i < length; i++) {
-        printf("%.1f ", vector[i]);
-    }
-    printf(" )\n");
+    return 0;
 }
+