Project-Algorithms/update.cpp at master · Hepic/Project-Algorithms · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
#include<iostream>
#include<cstdlib>
#include"cluster.h"
#include"curve.h"
#include"distances.h"
#include"help_functions.h"
#include"binary_mean_tree.h"
#include"update.h"

doubleswap_update_centroid(const vector<const Curve*> &centroids, int old_centr, int new_centr, const vector<int> &assign, const vector<double> &close_dist, const vector<double> &close_dist_sec, constchar *metric) {
double value = 0;

for (int i = 0; i < (int)assign.size(); ++i) {
if ((i != old_centr && (centroids[assign[i]]->get_int_id() == i)) || i == new_centr) {
continue;
 }

double dist = compute_distance(input_curves[i], input_curves[new_centr], metric);

if (centroids[assign[i]]->get_int_id() != old_centr) {
 value += min(dist, close_dist[i]);
 } else {
 value += min(dist, close_dist_sec[i]);
 }
 }

return value;
}

boolPAM_update(vector<const Curve*> &centroids, double value, const vector<vector<int> > &clusters, constchar *metric) {
 vector<double> close_dist((int)input_curves.size(), -1), close_dist_sec((int)input_curves.size(), -1);
 vector<int> assign((int)input_curves.size());

double min_value = value;
int p_new_cent, p_clust;

for (int i = 0; i < (int)input_curves.size(); ++i) {
for (int j = 0; j < (int)centroids.size(); ++j) {
double dist = compute_distance(input_curves[i], *centroids[j], metric);

if (close_dist[i] == -1 || dist < close_dist[i]) {
 close_dist_sec[i] = close_dist[i];
 close_dist[i] = dist;
 assign[i] = j;
 } elseif (close_dist_sec[i] == -1 || close_dist_sec[i] < dist) {
 close_dist_sec[i] = dist;
 }
 }
 }

for (int i = 0; i < (int)clusters.size(); ++i) {
for (int j = 0; j < (int)clusters[i].size(); ++j) {
if (clusters[i][j] == centroids[i]->get_int_id()) {
continue;
 }

double new_value = swap_update_centroid(centroids, centroids[i]->get_int_id(), clusters[i][j], assign, close_dist, close_dist_sec, metric);

if (new_value < min_value) {
 min_value = new_value;
 p_new_cent = clusters[i][j];
 p_clust = i;
 }
 }
 }

if (value > min_value) {
 centroids[p_clust] = &input_curves[p_new_cent];
returntrue;
 }

returnfalse;
}

boolmean_frechet_update(vector<const Curve*> &centroids, const vector<vector<int> > &clusters) {
bool check = false;

for (int i = 0; i < (int)clusters.size(); ++i) {
 BinaryMeanTree tree(clusters[i]);
const Curve *mean_curve = tree.get_mean();

if (!centroids[i]->equal_curves(*mean_curve)) {
 centroids[i] = mean_curve;
 check = true;
 }
 }

return check;
}