Multiple additions.

Restructured a bit and mostly added new files.

Author: Carlos Miranda

.gitignore

@@ -1,8 +1,18 @@
-# Ignore eclipse files
+# Editors files
+## Eclipse
 /java/.metadata
 /java/**/.project
 /java/**/.settings
 /java/**/.classpath
 
-# Ignore binaries
+## Vi
+**/*.swp
+
+# Binaries
 **/bin/
+
+# Residual objects
+**/*.o
+
+# Notes to myself
+**/notes

c/representations/adjacencylist.c renamed to c/adjacency_list/adjacency_list.c

@@ -1,29 +1,15 @@
 #include <stdio.h>
 #include <stdlib.h>
 
-typedef struct Node {
-    int dest;
-    struct Node *next;
-} Node;
-
-typedef struct AdjList {
-    Node *head;
-} AdjList;
-
-typedef struct Graph {
-    int V;
-    AdjList *array;
-} Graph;
-
 Node *newNode(int dest) {
     Node *node = (Node *) malloc(sizeof(Node));
     node->dest = dest;
     node->next = NULL;
     return node;
 }
 
-Graph *createGraph(int V) {
-    Graph *graph = (Graph *) malloc(sizeof(Graph));
+graph *create_graph(int V) {
+    graph *graph = (graph *) malloc(sizeof(graph));
     graph->V = V;
 
     graph->array = (AdjList *) malloc(V * sizeof(AdjList));
@@ -36,7 +22,7 @@ Graph *createGraph(int V) {
     return graph;
 }
 
-void addEdge(Graph *graph, int src, int dest) {
+void add_edge(graph *graph, int src, int dest) {
     Node *node = newNode(dest);
     node->next = graph->array[src].head;
     graph->array[src].head = node;
@@ -46,10 +32,10 @@ void addEdge(Graph *graph, int src, int dest) {
     graph->array[dest].head = node;
 }
 
-void printGraph(Graph *graph) {
-    int v;
-    for (v = 0; v < graph->V; v += 1) {
-        Node *pCrawl = graph->array[v].head;
+void print_graph(graph *g) {
+    int i;
+    for (i = 0; i < g->nb_vertices; i += 1) {
+        node *pcrawl = graph->list[i].head;
         printf("\n Adjacency list of vertex %d\n head ", v);
         while (pCrawl) {
             printf("-> %d", pCrawl->dest);
@@ -60,16 +46,18 @@ void printGraph(Graph *graph) {
 }
 
 int main(void) {
-    int V = 5;
-    Graph *graph = createGraph(V);
-    addEdge(graph, 0, 1);
-    addEdge(graph, 0, 4);
-    addEdge(graph, 1, 2);
-    addEdge(graph, 1, 3);
-    addEdge(graph, 1, 4);
-    addEdge(graph, 2, 3);
-    addEdge(graph, 3, 4);
+    int nb_vertices = 5;
+
+    graph *g = create_graph(nb_vertices);
+
+    add_edge(g, 0, 1);
+    add_edge(g, 0, 4);
+    add_edge(g, 1, 2);
+    add_edge(g, 1, 3);
+    add_edge(g, 1, 4);
+    add_edge(g, 2, 3);
+    add_edge(g, 3, 4);
 
-    printGraph(graph);
+    print_graph(g);
     return 0;
 }

c/adjacency_list/adjacency_list.h

@@ -0,0 +1,18 @@
+#ifndef ADJACENCY_LIST_H
+#define ADJACENCY_LIST_H
+
+#include "../common/linked_list.h"
+
+typedef struct graph {
+    size_t nb_vertices;
+    linked_list *vertices;
+} graph;
+
+graph *create_graph(size_t);
+void destroy_graph(graph *);
+
+label add_vertex(graph *, vertex_val);
+void add_edge(graph *, unsigned int, unsigned int);
+void print_graph(graph *);
+
+#endif

c/adjacency_matrix/adjacencymatrix.c

@@ -0,0 +1,57 @@
+#include "adjacencymatrix.h"
+
+
+graph *init_graph_with_weights(size_t nb_vertices, double **weights) {
+    
+    unsigned int i, j;
+    graph *g = (graph *) malloc(sizeof(graph));
+    g->nb_vertices = nb_vertices;
+    g->weights = (double **) malloc(sizeof(double *) * nb_vertices);
+    for (i = 0; i < nb_vertices; i += 1) {
+        g->weights[i] = (double *) malloc(sizeof(double) * nb_vertices);
+        for (j = 0; j < nb_vertices; j += 1) {
+            g->weights[i][j] = weights[i][j];
+        }
+    }
+    return g;
+
+}
+
+graph *init_graph(size_t nb_vertices) {
+
+    unsigned int i, j;
+    graph *g = (graph *) malloc(sizeof(graph));
+    g->nb_vertices = nb_vertices;
+    g->weights = (double **) malloc(sizeof(double *) * nb_vertices);
+    for (i = 0; i < nb_vertices; i += 1) {
+        g->weights[i] = (double *) malloc(sizeof(double) * nb_vertices); 
+        for (j = 0; j < nb_vertices; j += 1) {
+            g->weights[i][j] = 0.0;
+        }
+    }
+    return g;
+
+}
+
+void add_edge(graph * const g, unsigned int v1, unsigned int v2, double weight) {
+    if (v1 < g->nb_vertices && v2 < g->nb_vertices) {
+        g->weights[v1][v2] = weight;
+    }
+}
+
+void remove_edge(graph * const g, unsigned int v1, unsigned int v2) {
+    add_edge(g, v1, v2, 0.0);
+}
+
+
+void print_graph(const graph * const g) {
+
+    unsigned int i, j;
+    for (i = 0; i < g->nb_vertices; i+= 1) {
+        for (j = 0; j < g->nb_vertices; j += 1) {
+            printf("\t%lf", g->weights[i][j]);
+        }
+        printf("\n");
+    }
+
+}

c/adjacency_matrix/adjacencymatrix.h

@@ -0,0 +1,15 @@
+#ifndef ADJACENCY_MATRIX_H
+#define ADJACENCY_MATRIX_H
+
+typedef struct graph {
+    size_t nb_vertices;
+    double **weights;
+} graph;
+
+graph *init_graph_with_weights(size_t nb_vertices, double **weights);
+graph *init_graph(size_t nb_vertices);
+void add_edge(graph * const g, unsigned int v1, unsigned int v2, double weight);
+void remove_edge(graph * const g, unsigned int v1, unsigned v2);
+void print_graph(const graph * const g);
+
+#endif

c/common/linked_list.c

@@ -0,0 +1,14 @@
+#include "list.h"
+
+void insert_first(linked_list, node_val);
+void insert_last(linked_list, node_val);
+void insert_before(linked_list, node_val, node_val);
+void insert_after(linked_list, node_val, node_val);
+
+void remove_first(linked_list);
+void remove_last(linked_list);
+void remove_once(linked_list, node_val);
+void remove_all(linked_list, node_val);
+
+int contains(linked_list, node_val);
+int count(linked_list, node_val);

c/common/linked_list.h

@@ -0,0 +1,31 @@
+#ifndef LINKED_LIST_H
+#define LINKED_LIST_H
+
+typedef struct node {
+    double value;
+    unsigned int id;
+    struct node *next;
+} node;
+
+typedef struct linked_list {
+    size_t id_count;
+    node *head;
+} linked_list;
+
+linked_list *init_ll();
+void destroy_ll(linked_list*);
+
+void insert_first(linked_list, unsigned int, double);
+void insert_last(linked_list, unsigned int, double);
+void insert_before(linked_list, unsigned int, unsigned int, double);
+void insert_after(linked_list, unsigned int, unsigned int, double);
+
+void remove_first(linked_list);
+void remove_last(linked_list);
+void remove_by_id(linked_list, unsigned int);
+void remove_by_value(linked_list, double);
+
+int contains(linked_list, double);
+int count(linked_list, double);
+
+#endif

c/representations/adjacencylist.h renamed to c/common/matrix.c

@@ -0,0 +1,143 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "incidence_matrix.h"
+
+// Private prototypes
+int check_edge(const matrix * const m, index v1, index v2);
+
+// Interface implementation
+
+matrix *load(FILE * const inf) {
+    
+    // Check input argument
+    if (inf == NULL) return NULL;
+
+    // Allocate matrix struct and helper variables
+    matrix *m = (matrix *) malloc(sizeof(matrix));
+    unsigned int i, j, v1, v2, nb_vertices, nb_edges;
+    float tmp;
+
+    // Read first line of the file as number of vertices and edges
+    fscanf(inf, "%u %u", &nb_vertices, &nb_edges);
+    if (nb_vertices > MAX_VERTICES || nb_edges > MAX_EDGES) return NULL;
+
+    // Set up matrix structure
+    m->lines = nb_vertices;
+    m->columns = nb_edges;
+    m->values = (float **) malloc(sizeof(float *));
+    for (i = 0; i < nb_vertices; i += 1) {
+        m->values[i] = (float *) malloc(sizeof(float) * nb_edges);
+        //memset(m->values[i], 0.0f, nb_edges * sizeof(float));
+    }
+    m->unused_edges = NULL;
+    m->nb_unused = 0;
+
+    // Set up matrix values
+    for (i = 0; i < nb_edges; i += 1) {
+        fscanf(inf, "%u %u %f", &v1, &v2, &tmp);
+        m->values[v1][i] = m->values[v2][i] = tmp;
+        for (j = 0; j < nb_vertices; j += 1) {
+            if (j != v1 && j != v2) {
+                m->values[j][i] = 0.0;
+            }
+        }
+    }
+
+    return m;
+
+}
+
+void save(FILE * const outf, const matrix * const m) {
+
+    // Check output file
+    if (outf == NULL) return;
+
+    // Helper variables
+    unsigned int i, v1 = 0, v2;
+
+    // Print first line as number of vertices and number of edges
+    fprintf(outf, "%u\t%u\n", m->lines, m->columns);
+
+    // Print all (vertex1, vertex2, value) triples
+    for (i = 0; i < m->columns; i += 1) {
+        while (v1 < m->lines && m->values[v1][i] == 0.0) v1 += 1;
+        // Case of an unused edge entry
+        if (v1 == m->lines) continue;
+        v2 = v1 + 1;
+        while (m->values[v2][i] == 0.0) v2 += 1;
+        fprintf(outf, "%u\t%u\t%f\n", v1, v2, m->values[v1][i]); 
+        fprintf(outf, "%u\t%u\t%f\n", v2, v1, m->values[v2][i]); 
+    }
+}
+
+
+bool adjacent(const matrix * const m, index v1, index v2) {
+    
+    unsigned int i = 0;
+    int found = 0, v1_found = 0;
+    while (!found) {
+        while (i < m->columns && !m->values[v1][i]) i += 1;
+        if (i < m->columns && m->values[v2][i] != 0.0) {
+            found = 1;
+        } else if (i >= m->columns) {
+            found = -1;
+        }
+    }
+
+    return (found == 1 ? true : false);
+    
+}
+
+index add_vertex(matrix * const m) {
+
+    m->lines += 1;
+    m->values = (float **) realloc(m->values, m->lines * sizeof(float *));
+
+    return m->lines - 1;
+
+}
+
+void remove_vertex(matrix * const m, index vertex) {
+
+    // Remove all edges from/to the vertex to remove
+    
+    // Swap last vertex with vertex to remove
+
+    // Truncate matrix
+    
+}
+
+void add_edge(matrix * const m, index v1, index v2, float value) {
+    if (!check_edge(m, v1, v2) || adjacent(m, v1, v2)) return;
+    
+    unsigned int i;
+
+    if (m->unused_edges == NULL) {
+        m->columns += 1;
+        for (i = 0; i < m->lines; i += 1) {
+            m->values[i] = (float *) realloc(m->values[i], m->columns * sizeof(float));
+            m->values[i][m->columns - 1] = 0.0f;
+        }
+    } else {
+        m->nb_unused -= 1;
+        m->values[v1][m->unused_edges[m->nb_unused]] = value;
+        m->values[v2][m->unused_edges[m->nb_unused]] = value;
+        if (m->nb_unused == 0) {
+            free(m->unused_edges);
+        } else {
+            m->unused_edges = (unsigned int *) realloc(m->unused_edges, m->nb_unused * sizeof(unsigned int));
+        }
+   }
+
+}
+
+void remove_edge(matrix * const m, index v1, index v2) {
+    if (!check_edge(m, v1, v2)) return;
+}
+
+
+int check_edge(const matrix * const m, index v1, index v2) {
+    return v1 >= m->lines && v2 >= m->lines;
+}
+