├── LICENSE
├── Makefile
├── README.md
├── agglomerate.c
├── ahc.png
├── ahc_tree.png
└── example.txt


/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Gagarine Yaikhom
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
1 | agglomerate: agglomerate.c
2 | 	gcc -std=c99 -o agglomerate agglomerate.c -lm
3 | 
4 | clean:
5 | 	rm -f agglomerate
6 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Agglomerative Hierarchical Clustering
 2 | 
 3 | Implements the
 4 | [Agglomerative Hierarchical Clustering](http://en.wikipedia.org/wiki/Hierarchical_clustering)
 5 | algorithm.
 6 | 
 7 | ## Usage
 8 | 
 9 | To run the clustering program, you need to supply the following
10 | parameters on the command line:
11 | 
12 | * Input file that contains the items to be clustered.
13 | * Number of disjointed clusters that we wish to extract.
14 | * _Linkage criteria_ to use when calculating the _distance metric_.
15 | 
16 |     * `s` - Single linkage (default)
17 |     * `c` - Complete linkage
18 |     * `a` - Average linkage
19 |     * `t` - Centroid linkage
20 | 
21 | For instance, the following is an example run:
22 | 
23 |     $ ./agglomerate example.txt 3 s
24 | 
25 | In this example, we are running the hierarchical agglomerative
26 | clustering on the items in the input file `example.txt`. We are asking
27 | the program to generate `3` disjointed clusters using the
28 | _single-linkage_ distance metric.
29 | 
30 | ### The input file
31 | 
32 | The input file contains the items to be clustered.
33 | 
34 |     <number of items to cluster>
35 |     <label string>| <x-axis value> <y-axis value>
36 |     ...
37 | 
38 | For instance, the following is a valid input. It contains 12 data
39 | points, where each data point is referred to by its label and has
40 | coordinates in the two-dimensional [Euclidean
41 | plane](http://en.wikipedia.org/wiki/Euclidean_plane).
42 | 
43 |     12
44 |     A| 1.0 1.0
45 |     B| 2.0 1.0
46 |     C| 2.0 2.0
47 |     D| 4.0 5.0
48 |     E| 5.0 4.0
49 |     F| 5.0 5.0
50 |     G| 5.0 6.0
51 |     H| 6.0 5.0
52 |     I| 9.0 9.0
53 |     J| 10.0 9.0
54 |     K| 10.0 10.0
55 |     L| 11.0 9.0
56 | 
57 | After running the clustering algorithm, we get the following hierarchy:
58 | 
59 | ![Example agglomerative hierarchical clustering](ahc.png)
60 | 
61 | The cluster hierarchy may be represented by the binary tree:
62 | 
63 | ![Example clustering as a binary tree](ahc_tree.png)
64 | 


--------------------------------------------------------------------------------
/agglomerate.c:
--------------------------------------------------------------------------------
  1 | /**
  2 |  * Copyright 2014 Gagarine Yaikhom (MIT License)
  3 |  *
  4 |  * Implements Agglomerative Hierarchical Clustering algorithm.
  5 |  */
  6 | #include <float.h>
  7 | #include <math.h>
  8 | #include <stdio.h>
  9 | #include <stdlib.h>
 10 | #include <string.h>
 11 | 
 12 | #define NOT_USED  0 /* node is currently not used */
 13 | #define LEAF_NODE 1 /* node contains a leaf node */
 14 | #define A_MERGER  2 /* node contains a merged pair of root clusters */
 15 | #define MAX_LABEL_LEN 16
 16 | 
 17 | #define AVERAGE_LINKAGE  'a' /* choose average distance */
 18 | #define CENTROID_LINKAGE 't' /* choose distance between cluster centroids */
 19 | #define COMPLETE_LINKAGE 'c' /* choose maximum distance */
 20 | #define SINGLE_LINKAGE   's' /* choose minimum distance */
 21 | 
 22 | #define alloc_mem(N, T) (T *) calloc(N, sizeof(T))
 23 | #define alloc_fail(M) fprintf(stderr,                                   \
 24 |                               "Failed to allocate memory for %s.\n", M)
 25 | #define read_fail(M) fprintf(stderr, "Failed to read %s from file.\n", M)
 26 | #define invalid_node(I) fprintf(stderr,                                 \
 27 |                                 "Invalid cluster node at index %d.\n", I)
 28 | 
 29 | typedef struct cluster_s cluster_t;
 30 | typedef struct cluster_node_s cluster_node_t;
 31 | typedef struct neighbour_s neighbour_t;
 32 | typedef struct item_s item_t;
 33 | 
 34 | float (*distance_fptr)(float **, const int *, const int *, int, int);
 35 | 
 36 | typedef struct coord_s {
 37 |         float x, y;
 38 | } coord_t;
 39 | 
 40 | struct cluster_s {
 41 |         int num_items; /* number of items that was clustered */
 42 |         int num_clusters; /* current number of root clusters */
 43 |         int num_nodes; /* number of leaf and merged clusters */
 44 |         cluster_node_t *nodes; /* leaf and merged clusters */
 45 |         float **distances; /* distance between leaves */
 46 | };
 47 | 
 48 | struct cluster_node_s {
 49 |         int type; /* type of the cluster node */
 50 |         int is_root; /* true if cluster hasn't merged with another */
 51 |         int height; /* height of node from the bottom */
 52 |         coord_t centroid; /* centroid of this cluster */
 53 |         char *label; /* label of a leaf node */
 54 |         int *merged; /* indexes of root clusters merged */
 55 |         int num_items; /* number of leaf nodes inside new cluster */
 56 |         int *items; /* array of leaf nodes indices inside merged clusters */
 57 |         neighbour_t *neighbours; /* sorted linked list of distances to roots */
 58 | };
 59 | 
 60 | struct neighbour_s {
 61 |         int target; /* the index of cluster node representing neighbour */
 62 |         float distance; /* distance between the nodes */
 63 |         neighbour_t *next, *prev; /* linked list entries */
 64 | };
 65 | 
 66 | struct item_s {
 67 |         coord_t coord; /* coordinate of the input data point */
 68 |         char label[MAX_LABEL_LEN]; /* label of the input data point */
 69 | };
 70 | 
 71 | float euclidean_distance(const coord_t *a, const coord_t *b)
 72 | {
 73 |         return sqrt(pow(a->x - b->x, 2) + pow(a->y - b->y, 2));
 74 | }
 75 | 
 76 | void fill_euclidean_distances(float **matrix, int num_items,
 77 |                               const item_t items[])
 78 | {
 79 |         for (int i = 0; i < num_items; ++i)
 80 |                 for (int j = 0; j < num_items; ++j) {
 81 |                         matrix[i][j] =
 82 |                                 euclidean_distance(&(items[i].coord),
 83 |                                                    &(items[j].coord));
 84 |                         matrix[j][i] = matrix[i][j];
 85 |                 }
 86 | }
 87 | 
 88 | float **generate_distance_matrix(int num_items, const item_t items[])
 89 | {
 90 |         float **matrix = alloc_mem(num_items, float *);
 91 |         if (matrix) {
 92 |                 for (int i = 0; i < num_items; ++i) {
 93 |                         matrix[i] = alloc_mem(num_items, float);
 94 |                         if (!matrix[i]) {
 95 |                                 alloc_fail("distance matrix row");
 96 |                                 num_items = i;
 97 |                                 for (i = 0; i < num_items; ++i)
 98 |                                         free(matrix[i]);
 99 |                                 free(matrix);
100 |                                 matrix = NULL;
101 |                                 break;
102 |                         }
103 |                 }
104 |                 if (matrix)
105 |                         fill_euclidean_distances(matrix, num_items, items);
106 |         } else
107 |                 alloc_fail("distance matrix");
108 |         return matrix;
109 | }
110 | 
111 | float single_linkage(float **distances, const int a[],
112 |                      const int b[], int m, int n)
113 | {
114 |         float min = FLT_MAX, d;
115 |         for (int i = 0; i < m; ++i)
116 |                 for (int j = 0; j < n; ++j) {
117 |                         d = distances[a[i]][b[j]];
118 |                         if (d < min)
119 |                                 min = d;
120 |                 }
121 |         return min;
122 | }
123 | 
124 | float complete_linkage(float **distances, const int a[],
125 |                        const int b[], int m, int n)
126 | {
127 |         float d, max = 0.0 /* assuming distances are positive */;
128 |         for (int i = 0; i < m; ++i)
129 |                 for (int j = 0; j < n; ++j) {
130 |                         d = distances[a[i]][b[j]];
131 |                         if (d > max)
132 |                                 max = d;
133 |                 }
134 |         return max;
135 | }
136 | 
137 | float average_linkage(float **distances, const int a[],
138 |                       const int b[], int m, int n)
139 | {
140 |         float total = 0.0;
141 |         for (int i = 0; i < m; ++i)
142 |                 for (int j = 0; j < n; ++j)
143 |                         total += distances[a[i]][b[j]];
144 |         return total / (m * n);
145 | }
146 | 
147 | float centroid_linkage(float **distances, const int a[],
148 |                        const int b[], int m, int n)
149 | {
150 |         return 0; /* empty function */
151 | }
152 | 
153 | float get_distance(cluster_t *cluster, int index, int target)
154 | {
155 |         /* if both are leaves, just use the distances matrix */
156 |         if (index < cluster->num_items && target < cluster->num_items)
157 |                 return cluster->distances[index][target];
158 |         else {
159 |                 cluster_node_t *a = &(cluster->nodes[index]);
160 |                 cluster_node_t *b = &(cluster->nodes[target]);
161 |                 if (distance_fptr == centroid_linkage)
162 |                         return euclidean_distance(&(a->centroid),
163 |                                                   &(b->centroid));
164 |                 else return distance_fptr(cluster->distances,
165 |                                           a->items, b->items,
166 |                                           a->num_items, b->num_items);
167 |         }
168 | }
169 | 
170 | void free_neighbours(neighbour_t *node)
171 | {
172 |         neighbour_t *t;
173 |         while (node) {
174 |                 t = node->next;
175 |                 free(node);
176 |                 node = t;
177 |         }
178 | }
179 | 
180 | void free_cluster_nodes(cluster_t *cluster)
181 | {
182 |         for (int i = 0; i < cluster->num_nodes; ++i) {
183 |                 cluster_node_t *node = &(cluster->nodes[i]);
184 |                 if (node->label)
185 |                         free(node->label);
186 |                 if (node->merged)
187 |                         free(node->merged);
188 |                 if (node->items)
189 |                         free(node->items);
190 |                 if (node->neighbours)
191 |                         free_neighbours(node->neighbours);
192 |         }
193 |         free(cluster->nodes);
194 | }
195 | 
196 | void free_cluster(cluster_t * cluster)
197 | {
198 |         if (cluster) {
199 |                 if (cluster->nodes)
200 |                         free_cluster_nodes(cluster);
201 |                 if (cluster->distances) {
202 |                         for (int i = 0; i < cluster->num_items; ++i)
203 |                                 free(cluster->distances[i]);
204 |                         free(cluster->distances);
205 |                 }
206 |                 free(cluster);
207 |         }
208 | }
209 | 
210 | void insert_before(neighbour_t *current, neighbour_t *neighbours,
211 |                    cluster_node_t *node)
212 | {
213 |         neighbours->next = current;
214 |         if (current->prev) {
215 |                 current->prev->next = neighbours;
216 |                 neighbours->prev = current->prev;
217 |         } else
218 |                 node->neighbours = neighbours;
219 |         current->prev = neighbours;
220 | }
221 | 
222 | void insert_after(neighbour_t *current, neighbour_t *neighbours)
223 | {
224 |         neighbours->prev = current;
225 |         current->next = neighbours;
226 | }
227 | 
228 | void insert_sorted(cluster_node_t *node, neighbour_t *neighbours)
229 | {
230 |         neighbour_t *temp = node->neighbours;
231 |         while (temp->next) {
232 |                 if (temp->distance >= neighbours->distance) {
233 |                         insert_before(temp, neighbours, node);
234 |                         return;
235 |                 }
236 |                 temp = temp->next;
237 |         }
238 |         if (neighbours->distance < temp->distance)
239 |                 insert_before(temp, neighbours, node);
240 |         else
241 |                 insert_after(temp, neighbours);
242 | }
243 | 
244 | 
245 | neighbour_t *add_neighbour(cluster_t *cluster, int index, int target)
246 | {
247 |         neighbour_t *neighbour = alloc_mem(1, neighbour_t);
248 |         if (neighbour) {
249 |                 neighbour->target = target;
250 |                 neighbour->distance = get_distance(cluster, index, target);
251 |                 cluster_node_t *node = &(cluster->nodes[index]);
252 |                 if (node->neighbours)
253 |                         insert_sorted(node, neighbour);
254 |                 else
255 |                         node->neighbours = neighbour;
256 |         } else
257 |                 alloc_fail("neighbour node");
258 |         return neighbour;
259 | }
260 | 
261 | cluster_t *update_neighbours(cluster_t *cluster, int index)
262 | {
263 |         cluster_node_t *node = &(cluster->nodes[index]);
264 |         if (node->type == NOT_USED) {
265 |                 invalid_node(index);
266 |                 cluster = NULL;
267 |         } else {
268 |                 int root_clusters_seen = 1, target = index;
269 |                 while (root_clusters_seen < cluster->num_clusters) {
270 |                         cluster_node_t *temp = &(cluster->nodes[--target]);
271 |                         if (temp->type == NOT_USED) {
272 |                                 invalid_node(index);
273 |                                 cluster = NULL;
274 |                                 break;
275 |                         }
276 |                         if (temp->is_root) {
277 |                                 ++root_clusters_seen;
278 |                                 add_neighbour(cluster, index, target);
279 |                         }
280 |                 }
281 |         }
282 |         return cluster;
283 | }
284 | 
285 | #define init_leaf(cluster, node, item, len)             \
286 |         do {                                            \
287 |                 strncpy(node->label, item->label, len); \
288 |                 node->centroid = item->coord;           \
289 |                 node->type = LEAF_NODE;                 \
290 |                 node->is_root = 1;                      \
291 |                 node->height = 0;                       \
292 |                 node->num_items = 1;                    \
293 |                 node->items[0] = cluster->num_nodes++;  \
294 |         } while (0)                                     \
295 | 
296 | cluster_node_t *add_leaf(cluster_t *cluster, const item_t *item)
297 | {
298 |         cluster_node_t *leaf = &(cluster->nodes[cluster->num_nodes]);
299 |         int len = strlen(item->label) + 1;
300 |         leaf->label = alloc_mem(len, char);
301 |         if (leaf->label) {
302 |                 leaf->items = alloc_mem(1, int);
303 |                 if (leaf->items) {
304 |                         init_leaf(cluster, leaf, item, len);
305 |                         cluster->num_clusters++;
306 |                 } else {
307 |                         alloc_fail("node items");
308 |                         free(leaf->label);
309 |                         leaf = NULL;
310 |                 }
311 |         } else {
312 |                 alloc_fail("node label");
313 |                 leaf = NULL;
314 |         }
315 |         return leaf;
316 | }
317 | 
318 | #undef init_leaf
319 | 
320 | cluster_t *add_leaves(cluster_t *cluster, item_t *items)
321 | {
322 |         for (int i = 0; i < cluster->num_items; ++i) {
323 |                 if (add_leaf(cluster, &items[i]))
324 |                         update_neighbours(cluster, i);
325 |                 else {
326 |                         cluster = NULL;
327 |                         break;
328 |                 }
329 |         }
330 |         return cluster;
331 | }
332 | 
333 | void print_cluster_items(cluster_t *cluster, int index)
334 | {
335 |         cluster_node_t *node = &(cluster->nodes[index]);
336 |         fprintf(stdout, "Items: ");
337 |         if (node->num_items > 0) {
338 |                 fprintf(stdout, "%s", cluster->nodes[node->items[0]].label);
339 |                 for (int i = 1; i < node->num_items; ++i)
340 |                         fprintf(stdout, ", %s",
341 |                                 cluster->nodes[node->items[i]].label);
342 |         }
343 |         fprintf(stdout, "\n");
344 | }
345 | 
346 | void print_cluster_node(cluster_t *cluster, int index)
347 | {
348 |         cluster_node_t *node = &(cluster->nodes[index]);
349 |         fprintf(stdout, "Node %d - height: %d, centroid: (%5.3f, %5.3f)\n",
350 |                 index, node->height, node->centroid.x, node->centroid.y);
351 |         if (node->label)
352 |                 fprintf(stdout, "\tLeaf: %s\n\t", node->label);
353 |         else
354 |                 fprintf(stdout, "\tMerged: %d, %d\n\t",
355 |                         node->merged[0], node->merged[1]);
356 |         print_cluster_items(cluster, index);
357 |         fprintf(stdout, "\tNeighbours: ");
358 |         neighbour_t *t = node->neighbours;
359 |         while (t) {
360 |                 fprintf(stdout, "\n\t\t%2d: %5.3f", t->target, t->distance);
361 |                 t = t->next;
362 |         }
363 |         fprintf(stdout, "\n");
364 | }
365 | 
366 | void merge_items(cluster_t *cluster, cluster_node_t *node,
367 |                  cluster_node_t **to_merge)
368 | {
369 |         node->type = A_MERGER;
370 |         node->is_root = 1;
371 |         node->height = -1;
372 | 
373 |         /* copy leaf indexes from merged clusters */
374 |         int k = 0, idx;
375 |         coord_t centroid = { .x = 0.0, .y = 0.0 };
376 |         for (int i = 0; i < 2; ++i) {
377 |                 cluster_node_t *t = to_merge[i];
378 |                 t->is_root = 0; /* no longer root: merged */
379 |                 if (node->height == -1 ||
380 |                     node->height < t->height)
381 |                         node->height = t->height;
382 |                 for (int j = 0; j < t->num_items; ++j) {
383 |                         idx = t->items[j];
384 |                         node->items[k++] = idx;
385 |                 }
386 |                 centroid.x += t->num_items * t->centroid.x;
387 |                 centroid.y += t->num_items * t->centroid.y;
388 |         }
389 |         /* calculate centroid */
390 |         node->centroid.x = centroid.x / k;
391 |         node->centroid.y = centroid.y / k;
392 |         node->height++;
393 | }
394 | 
395 | #define merge_to_one(cluster, to_merge, node, node_idx)         \
396 |         do {                                                    \
397 |                 node->num_items = to_merge[0]->num_items +      \
398 |                         to_merge[1]->num_items;                 \
399 |                 node->items = alloc_mem(node->num_items, int);  \
400 |                 if (node->items) {                              \
401 |                         merge_items(cluster, node, to_merge);   \
402 |                         cluster->num_nodes++;                   \
403 |                         cluster->num_clusters--;                \
404 |                         update_neighbours(cluster, node_idx);   \
405 |                 } else {                                        \
406 |                         alloc_fail("array of merged items");    \
407 |                         free(node->merged);                     \
408 |                         node = NULL;                            \
409 |                 }                                               \
410 |         } while(0)                                              \
411 | 
412 | cluster_node_t *merge(cluster_t *cluster, int first, int second)
413 | {
414 |         int new_idx = cluster->num_nodes;
415 |         cluster_node_t *node = &(cluster->nodes[new_idx]);
416 |         node->merged = alloc_mem(2, int);
417 |         if (node->merged) {
418 |                 cluster_node_t *to_merge[2] = {
419 |                         &(cluster->nodes[first]),
420 |                         &(cluster->nodes[second])
421 |                 };
422 |                 node->merged[0] = first;
423 |                 node->merged[1] = second;
424 |                 merge_to_one(cluster, to_merge, node, new_idx);
425 |         } else {
426 |                 alloc_fail("array of merged nodes");
427 |                 node = NULL;
428 |         }
429 |         return node;
430 | }
431 | 
432 | #undef merge_to_one
433 | 
434 | void find_best_distance_neighbour(cluster_node_t *nodes,
435 |                                   int node_idx,
436 |                                   neighbour_t *neighbour,
437 |                                   float *best_distance,
438 |                                   int *first, int *second)
439 | {
440 |         while (neighbour) {
441 |                 if (nodes[neighbour->target].is_root) {
442 |                         if (*first == -1 ||
443 |                             neighbour->distance < *best_distance) {
444 |                                 *first = node_idx;
445 |                                 *second = neighbour->target;
446 |                                 *best_distance = neighbour->distance;
447 |                         }
448 |                         break;
449 |                 }
450 |                 neighbour = neighbour->next;
451 |         }
452 | }
453 | 
454 | 
455 | int find_clusters_to_merge(cluster_t *cluster, int *first, int *second)
456 | {
457 |         float best_distance = 0.0;
458 |         int root_clusters_seen = 0;
459 |         int j = cluster->num_nodes; /* traverse hierarchy top-down */
460 |         *first = -1;
461 |         while (root_clusters_seen < cluster->num_clusters) {
462 |                 cluster_node_t *node = &(cluster->nodes[--j]);
463 |                 if (node->type == NOT_USED || !node->is_root)
464 |                         continue;
465 |                 ++root_clusters_seen;
466 |                 find_best_distance_neighbour(cluster->nodes, j,
467 |                                              node->neighbours,
468 |                                              &best_distance,
469 |                                              first, second);
470 |         }
471 |         return *first;
472 | }
473 | 
474 | cluster_t *merge_clusters(cluster_t *cluster)
475 | {
476 |         int first, second;
477 |         while (cluster->num_clusters > 1) {
478 |                 if (find_clusters_to_merge(cluster, &first, &second) != -1)
479 |                         merge(cluster, first, second);
480 |         }
481 |         return cluster;
482 | }
483 | 
484 | #define init_cluster(cluster, num_items, items)                         \
485 |         do {                                                            \
486 |                 cluster->distances =                                    \
487 |                         generate_distance_matrix(num_items, items);     \
488 |                 if (!cluster->distances)                                \
489 |                         goto cleanup;                                   \
490 |                 cluster->num_items = num_items;                         \
491 |                 cluster->num_nodes = 0;                                 \
492 |                 cluster->num_clusters = 0;                              \
493 |                 if (add_leaves(cluster, items))                         \
494 |                         merge_clusters(cluster);                        \
495 |                 else                                                    \
496 |                         goto cleanup;                                   \
497 |         } while (0)                                                     \
498 | 
499 | cluster_t *agglomerate(int num_items, item_t *items)
500 | {
501 |         cluster_t *cluster = alloc_mem(1, cluster_t);
502 |         if (cluster) {
503 |                 cluster->nodes = alloc_mem(2 * num_items - 1, cluster_node_t);
504 |                 if (cluster->nodes)
505 |                         init_cluster(cluster, num_items, items);
506 |                 else {
507 |                         alloc_fail("cluster nodes");
508 |                         goto cleanup;
509 |                 }
510 |         } else
511 |                 alloc_fail("cluster");
512 |         goto done;
513 | 
514 | cleanup:
515 |         free_cluster(cluster);
516 |         cluster = NULL;
517 | 
518 | done:
519 |         return cluster;
520 | }
521 | 
522 | #undef init_cluster
523 | 
524 | int print_root_children(cluster_t *cluster, int i, int nodes_to_discard)
525 | {
526 |         cluster_node_t *node = &(cluster->nodes[i]);
527 |         int roots_found = 0;
528 |         if (node->type == A_MERGER) {
529 |                 for (int j = 0; j < 2; ++j) {
530 |                         int t = node->merged[j];
531 |                         if (t < nodes_to_discard) {
532 |                                 print_cluster_items(cluster, t);
533 |                                 ++roots_found;
534 |                         }
535 |                 }
536 |         }
537 |         return roots_found;
538 | }
539 | 
540 | void get_k_clusters(cluster_t *cluster, int k)
541 | {
542 |         if (k < 1)
543 |                 return;
544 |         if (k > cluster->num_items)
545 |                 k = cluster->num_items;
546 | 
547 |         int i = cluster->num_nodes - 1;
548 |         int roots_found = 0;
549 |         int nodes_to_discard = cluster->num_nodes - k + 1;
550 |         while (k) {
551 |                 if (i < nodes_to_discard) {
552 |                         print_cluster_items(cluster, i);
553 |                         roots_found = 1;
554 |                 } else
555 |                         roots_found = print_root_children(cluster, i,
556 |                                                           nodes_to_discard);
557 |                 k -= roots_found;
558 |                 --i;
559 |         }
560 | }
561 | 
562 | void print_cluster(cluster_t *cluster)
563 | {
564 |         for (int i = 0; i < cluster->num_nodes; ++i)
565 |                 print_cluster_node(cluster, i);
566 | }
567 | 
568 | int read_items(int count, item_t *items, FILE *f)
569 | {
570 |         for (int i = 0; i < count; ++i) {
571 |                 item_t *t = &(items[i]);
572 |                 if (fscanf(f, "%[^|]| %10f %10f\n",
573 |                            t->label, &(t->coord.x),
574 |                            &(t->coord.y)))
575 |                         continue;
576 |                 read_fail("item line");
577 |                 return i;
578 |         }
579 |         return count;
580 | }
581 | 
582 | int read_items_from_file(item_t **items, FILE *f)
583 | {
584 |         int count, r;
585 |         r = fscanf(f, "%5d\n", &count);
586 |         if (r == 0) {
587 |                 read_fail("number of lines");
588 |                 return 0;
589 |         }
590 |         if (count) {
591 |                 *items = alloc_mem(count, item_t);
592 |                 if (*items) {
593 |                         if (read_items(count, *items, f) != count)
594 |                                 free(items);
595 |                 } else
596 |                         alloc_fail("items array");
597 |         }
598 |         return count;
599 | }
600 | 
601 | void set_linkage(char linkage_type)
602 | {
603 |         switch (linkage_type) {
604 |         case AVERAGE_LINKAGE:
605 |                 distance_fptr = average_linkage;
606 |                 break;
607 |         case COMPLETE_LINKAGE:
608 |                 distance_fptr = complete_linkage;
609 |                 break;
610 |         case CENTROID_LINKAGE:
611 |                 distance_fptr = centroid_linkage;
612 |                 break;
613 |         case SINGLE_LINKAGE:
614 |         default: distance_fptr = single_linkage;
615 |         }
616 | }
617 | 
618 | int process_input(item_t **items, const char *fname)
619 | {
620 |         int count = 0;
621 |         FILE *f = fopen(fname, "r");
622 |         if (f) {
623 |                 count = read_items_from_file(items, f);
624 |                 fclose(f);
625 |         } else
626 |                 fprintf(stderr, "Failed to open input file %s.\n", fname);
627 |         return count;
628 | }
629 | 
630 | int main(int argc, char **argv)
631 | {
632 |         if (argc != 4) {
633 |                 fprintf(stderr, "Usage: %s <input file> <num clusters> "
634 |                         "<linkage type>\n", argv[0]);
635 |                 exit(1);
636 |         } else {
637 |                 item_t *items = NULL;
638 |                 int num_items = process_input(&items, argv[1]);
639 |                 set_linkage(argv[3][0]);
640 |                 if (num_items) {
641 |                         cluster_t *cluster = agglomerate(num_items, items);
642 |                         free(items);
643 | 
644 |                         if (cluster) {
645 |                                 fprintf(stdout, "CLUSTER HIERARCHY\n"
646 |                                         "--------------------\n");
647 |                                 print_cluster(cluster);
648 | 
649 |                                 int k = atoi(argv[2]);
650 |                                 fprintf(stdout, "\n\n%d CLUSTERS\n"
651 |                                         "--------------------\n", k);
652 |                                 get_k_clusters(cluster, k);
653 |                                 free_cluster(cluster);
654 |                         }
655 |                 }
656 |         }
657 |         return 0;
658 | }
659 | 


--------------------------------------------------------------------------------
/ahc.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gyaikhom/agglomerative-hierarchical-clustering/32d88e76365fa81e8e19d6385180580b81df9dba/ahc.png


--------------------------------------------------------------------------------
/ahc_tree.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gyaikhom/agglomerative-hierarchical-clustering/32d88e76365fa81e8e19d6385180580b81df9dba/ahc_tree.png


--------------------------------------------------------------------------------
/example.txt:
--------------------------------------------------------------------------------
 1 | 12
 2 | A| 1.0 1.0
 3 | B| 2.0 1.0
 4 | C| 2.0 2.0
 5 | D| 4.0 5.0
 6 | E| 5.0 4.0
 7 | F| 5.0 5.0
 8 | G| 5.0 6.0
 9 | H| 6.0 5.0
10 | I| 9.0 9.0
11 | J| 10.0 9.0
12 | K| 10.0 10.0
13 | L| 11.0 9.0
14 | 


--------------------------------------------------------------------------------