ADD: cluster structure and beginning of logic

src/cluster.c

+#include "cluster.h"
+#include "vector.h"
+
+
+cluster_int_t* cluster_create_int(vector_int_t* center) {
+	cluster_int_t* cluster = malloc(sizeof(cluster_int_t));
+	if (NULL == cluster) return NULL;
+	cluster->center = center;
+	cluster->points = list_points_create_int();
+}
+
+cluster_fpt_t* cluster_create_fpt(vector_fpt_t* center) {
+	cluster_fpt_t* cluster = malloc(sizeof(cluster_fpt_t));
+	if (NULL == cluster) return NULL;
+	cluster->center = center;
+	cluster->points = list_points_create_fpt();
+}
+
+
+void cluster_destroy_int(cluster_int_t* cluster) {
+	if (NULL == cluster) return;
+	vector_destroy_int(cluster->center);
+	list_points_destroy_int(cluster->points, false);
+	free(cluster);
+}
+
+void cluster_destroy_fpt(cluster_fpt_t* cluster) {
+	if (NULL == cluster) return;
+	vector_destroy_fpt(cluster->center);
+	list_points_destroy_fpt(cluster->points, false);
+	free(cluster);
+}
+
+
+void cluster_add_point_int(cluster_int_t* cluster, point_int_t* point) {
+	//TODO
+	if (NULL == cluster || NULL == point) return;
+	if (NULL == cluster->center) {
+		cluster->center = vector_copy_int(point->vector);
+	} else {
+		vector_int_t* delta = vector_copy_int(point->vector);
+		vector_div_inplace_int(delta, cluster->points->size);
+		vector_add_inplace_int(cluster->center, *delta);
+		vector_destroy_int(delta);
+	}
+}
+
+void cluster_add_point_fpt(cluster_fpt_t* cluster, point_fpt_t* point) {
+	//TODO
+	if (NULL == cluster || NULL == point) return;
+	if (NULL == cluster->center) {
+		cluster->center = vector_copy_fpt(point->vector);
+	} else {
+		vector_fpt_t* delta = vector_copy_fpt(point->vector);
+		vector_div_inplace_fpt(delta, cluster->points->size);
+		vector_add_inplace_fpt(cluster->center, *delta);
+		vector_destroy_fpt(delta);
+	}
+}
+
+
+void cluster_update_center_int(cluster_int_t* cluster) {
+	//TODO
+}
+
+void cluster_update_center_fpt(cluster_fpt_t* cluster) {
+	//TODO
+}
+
+
+void cluster_reset_int(cluster_int_t* cluster) {
+	//TODO
+	list_points_destroy_int(cluster->points, false);
+	cluster->points = list_points_create_int();
+}
+
+void cluster_reset_fpt(cluster_fpt_t* cluster) {
+	//TODO
+	list_points_destroy_fpt(cluster->points, false);
+	cluster->points = list_points_create_fpt();
+}

src/cluster.h

+#ifndef PROG_KMEANS_CLUSTER_H
+#define PROG_KMEANS_CLUSTER_H
+
+#include <stdlib.h>
+#include "linkedlist.h"
+#include "point.h"
+#include "vector.h"
+
+
+typedef struct cluster_int {
+	vector_int_t* center;
+	list_points_int_t* points;
+} cluster_int_t;
+
+typedef struct cluster_fpt {
+	vector_fpt_t* center;
+	list_points_fpt_t* points;
+} cluster_fpt_t;
+
+
+cluster_int_t* cluster_create_int(vector_int_t* center);
+
+cluster_fpt_t* cluster_create_fpt(vector_fpt_t* center);
+
+
+void cluster_destroy_int(cluster_int_t* center);
+
+void cluster_destroy_fpt(cluster_fpt_t* center);
+
+
+void cluster_add_point_int(cluster_int_t* cluster, point_int_t* point);
+
+void cluster_add_point_fpt(cluster_fpt_t* cluster, point_fpt_t* point);
+
+
+void cluster_update_center_int(cluster_int_t* cluster);
+
+void cluster_update_center_fpt(cluster_fpt_t* cluster);
+
+
+void cluster_reset_int(cluster_int_t* cluster);
+
+void cluster_reset_fpt(cluster_fpt_t* cluster);
+
+
+#endif //PROG_KMEANS_CLUSTER_H

src/distance.c

-//
-// by Boris Stefanovic on 24/05/22
-//
-
 #include "distance.h"
 #include <math.h>
 #include "common.h"

src/distance.h

-//
-// by Boris Stefanovic on 24/05/22
-//
-
 #ifndef PROG_KMEANS_DISTANCE_H
 #define PROG_KMEANS_DISTANCE_H
 

src/linkedlist.c

@@ -4,20 +4,20 @@
 #include "point.h"
 
 
-list_points_node_int_t* list_points_create_node_int(vector_int_t* vec) {
+list_points_node_int_t* list_points_node_create_int(vector_int_t* vec) {
 	list_points_node_int_t* node = malloc(sizeof(list_points_node_int_t));
 	if (NULL == node) return NULL;
-	point_int_t* point = point_int_create(vec);
+	point_int_t* point = point_create_int(vec);
 	if (NULL == point) return NULL;
 	node->point = point;
 	node->next = NULL;
 	return node;
 }
 
-list_points_node_fpt_t* list_points_create_node_fpt(vector_fpt_t* vec) {
+list_points_node_fpt_t* list_points_node_create_fpt(vector_fpt_t* vec) {
 	list_points_node_fpt_t* node = malloc(sizeof(list_points_node_fpt_t));
 	if (NULL == node) return NULL;
-	point_fpt_t* point = point_fpt_create(vec);
+	point_fpt_t* point = point_create_fpt(vec);
 	if (NULL == point) return NULL;
 	node->point = point;
 	node->next = NULL;
@@ -25,15 +25,15 @@ list_points_node_fpt_t* list_points_create_node_fpt(vector_fpt_t* vec) {
 }
 
 
-void list_points_destroy_node_int(list_points_node_int_t* node, const bool full) {
+void list_points_node_destroy_int(list_points_node_int_t* node, const bool full) {
 	if (NULL == node) return;
-	if (full) point_int_destroy(node->point);
+	if (full) point_destroy_int(node->point);
 	free(node);
 }
 
-void list_points_destroy_node_fpt(list_points_node_fpt_t* node, const bool full) {
+void list_points_node_destroy_fpt(list_points_node_fpt_t* node, const bool full) {
 	if (NULL == node) return;
-	if (full) point_fpt_destroy(node->point);
+	if (full) point_destroy_fpt(node->point);
 	free(node);
 }
 
@@ -64,7 +64,7 @@ void list_points_destroy_int(list_points_int_t* list, const bool full) {
 	list_points_node_int_t* node;
 	while ((node = list->head) != NULL) {
 		list->head = node->next;
-		list_points_destroy_node_int(node, full);
+		list_points_node_destroy_int(node, full);
 	}
 	free(list);
 }
@@ -74,7 +74,7 @@ void list_points_destroy_fpt(list_points_fpt_t* list, const bool full) {
 	list_points_node_fpt_t* node;
 	while ((node = list->head) != NULL) {
 		list->head = node->next;
-		list_points_destroy_node_fpt(node, full);
+		list_points_node_destroy_fpt(node, full);
 	}
 	free(list);
 }
@@ -82,7 +82,7 @@ void list_points_destroy_fpt(list_points_fpt_t* list, const bool full) {
 
 void list_points_append_int(list_points_int_t* list, vector_int_t* vector) {
 	if (NULL == vector) return;
-	list_points_node_int_t* node = list_points_create_node_int(vector);
+	list_points_node_int_t* node = list_points_node_create_int(vector);
 	if (NULL == list->head) {  // if list is empty
 		list->head = node;
 		list->tail = list->head;
@@ -95,7 +95,7 @@ void list_points_append_int(list_points_int_t* list, vector_int_t* vector) {
 
 void list_points_append_fpt(list_points_fpt_t* list, vector_fpt_t* vector) {
 	if (NULL == vector) return;
-	list_points_node_fpt_t* node = list_points_create_node_fpt(vector);
+	list_points_node_fpt_t* node = list_points_node_create_fpt(vector);
 	if (NULL == list->head) {  // if list is empty
 		list->head = node;
 		list->tail = list->head;

src/linkedlist.h

-//
-// by Boris Stefanovic on 31/05/22
-//
-
 #ifndef PROG_KMEANS_LINKEDLIST_H
 #define PROG_KMEANS_LINKEDLIST_H
 
@@ -15,33 +11,33 @@ typedef struct list_points_node_int {
 	struct list_points_node_int* next;
 } list_points_node_int_t;
 
-typedef struct list_points_int {
-	list_points_node_int_t* head;
-	list_points_node_int_t* tail;
-	size_t size;
-} list_points_int_t;
-
-
 typedef struct list_points_node_fpt {
 	point_fpt_t* point;
 	struct list_points_node_fpt* next;
 } list_points_node_fpt_t;
 
-typedef struct list_points_fpt {
-	list_points_node_fpt_t* head;
-	list_points_node_fpt_t* tail;
-	size_t size;
-} list_points_fpt_t;
 
+list_points_node_int_t* list_points_node_create_int(vector_int_t* vec);
 
-list_points_node_int_t* list_points_create_node_int(vector_int_t* vec);
+list_points_node_fpt_t* list_points_node_create_fpt(vector_fpt_t* vec);
 
-list_points_node_fpt_t* list_points_create_node_fpt(vector_fpt_t* vec);
 
+void list_points_node_destroy_int(list_points_node_int_t* node, const bool full);
 
-void list_points_destroy_node_int(list_points_node_int_t* node, const bool full);
+void list_points_node_destroy_fpt(list_points_node_fpt_t* node, const bool full);
 
-void list_points_destroy_node_fpt(list_points_node_fpt_t* node, const bool full);
+
+typedef struct list_points_int {
+	list_points_node_int_t* head;
+	list_points_node_int_t* tail;
+	size_t size;
+} list_points_int_t;
+
+typedef struct list_points_fpt {
+	list_points_node_fpt_t* head;
+	list_points_node_fpt_t* tail;
+	size_t size;
+} list_points_fpt_t;
 
 
 list_points_int_t* list_points_create_int();

src/point.c

@@ -3,7 +3,7 @@
 #include "vector.h"
 
 
-point_int_t* point_int_create(vector_int_t* vector) {
+point_int_t* point_create_int(vector_int_t* vector) {
 	point_int_t* point = malloc(sizeof(point_int_t));
 	if (NULL == point) return NULL;
 	point->vector = vector;
@@ -11,8 +11,7 @@ point_int_t* point_int_create(vector_int_t* vector) {
 	return point;
 }
 
-
-point_fpt_t* point_fpt_create(vector_fpt_t* vector) {
+point_fpt_t* point_create_fpt(vector_fpt_t* vector) {
 	point_fpt_t* point = malloc(sizeof(point_fpt_t));
 	if (NULL == point) return NULL;
 	point->vector = vector;
@@ -21,15 +20,14 @@ point_fpt_t* point_fpt_create(vector_fpt_t* vector) {
 }
 
 
-void point_int_destroy(point_int_t* cp) {
+void point_destroy_int(point_int_t* cp) {
 	if (NULL == cp) return;
-	vector_int_destroy(cp->vector);
+	vector_destroy_int(cp->vector);
 	free(cp);
 }
 
-
-void point_fpt_destroy(point_fpt_t* cp) {
+void point_destroy_fpt(point_fpt_t* cp) {
 	if (NULL == cp) return;
-	vector_fpt_destroy(cp->vector);
+	vector_destroy_fpt(cp->vector);
 	free(cp);
 }

src/point.h

-#ifndef PROG_KMEANS_CLUSTER_H
-#define PROG_KMEANS_CLUSTER_H
+#ifndef PROG_KMEANS_POINT_H
+#define PROG_KMEANS_POINT_H
 
 #include "vector.h"
 
@@ -9,21 +9,20 @@ typedef struct point_int {
 	vector_int_t* cluster;
 } point_int_t;
 
-
 typedef struct point_fpt {
 	vector_fpt_t* vector;
 	vector_fpt_t* cluster;
 } point_fpt_t;
 
 
-point_int_t* point_int_create(vector_int_t* vector);
+point_int_t* point_create_int(vector_int_t* vector);
 
-point_fpt_t* point_fpt_create(vector_fpt_t* vector);
+point_fpt_t* point_create_fpt(vector_fpt_t* vector);
 
 
-void point_int_destroy(point_int_t* cp);
+void point_destroy_int(point_int_t* cp);
 
-void point_fpt_destroy(point_fpt_t* cp);
+void point_destroy_fpt(point_fpt_t* cp);
 
 
-#endif //PROG_KMEANS_CLUSTER_H
+#endif //PROG_KMEANS_POINT_H

src/vector.c

@@ -87,3 +87,27 @@ void vector_print_to_file_fpt(FILE* file, const vector_fpt_t* v) {
 	for (size_t i = 1; i < v->dim; ++i) fprintf(file, " , %lf", v->data[i]);
 	fprintf(file, "\n");
 }
+
+
+void vector_add_inplace_int(vector_int_t* v, const vector_int_t a) {
+	if (NULL == v) return;
+	const size_t dim = v->dim < a.dim ? v->dim : a.dim;
+	for (size_t i = 0; i < dim; ++i) v->data[i] += a.data[i];
+}
+
+void vector_add_inplace_fpt(vector_fpt_t* v, const vector_fpt_t a) {
+	if (NULL == v) return;
+	const size_t dim = v->dim < a.dim ? v->dim : a.dim;
+	for (size_t i = 0; i < dim; ++i) v->data[i] += a.data[i];
+}
+
+
+void vector_div_inplace_int(vector_int_t* v, const int_t a) {
+	if (NULL == v) return;
+	for (size_t i = 0; i < v->dim; ++i) v->data[i] /= a;
+}
+
+void vector_div_inplace_fpt(vector_fpt_t* v, const fpt_t a) {
+	if (NULL == v) return;
+	for (size_t i = 0; i < v->dim; ++i) v->data[i] /= a;
+}

src/vector.h

@@ -44,4 +44,14 @@ void vector_print_to_file_int(FILE* file, const vector_int_t* v);
 void vector_print_to_file_fpt(FILE* file, const vector_fpt_t* v);
 
 
+void vector_add_inplace_int(vector_int_t* v, const vector_int_t a);
+
+void vector_add_inplace_fpt(vector_fpt_t* v, const vector_fpt_t a);
+
+
+void vector_div_inplace_int(vector_int_t* v, const int_t a);
+
+void vector_div_inplace_fpt(vector_fpt_t* v, const fpt_t a);
+
+
 #endif //PROG_KMEANS_VECTOR_H