void print_weights(ascii_trie* node) {
if (node != NULL) {
printf("node: %c weight: %d\n", node->key, node->weight);
print_weights(node->next);
print_weights(node->child);
}
}
double run() {
printf("Initialization.\n");
init_memb();
if(verbose) print_memb(&memb);
init_weights();
if(verbose) print_weights(&weights);
beta = 0.0;
double adeq = adequacy();
printf("Adequacy: %.15lf\n", adeq);
double prev_iter_adeq;
double adeq_diff;
size_t iter = 1;
st_matrix prev_memb;
init_st_matrix(&prev_memb, objc, clustc);
do {
printf("Iteration %d:\n", iter);
prev_iter_adeq = adeq;
global_dissim();
compute_membvec();
if(compute_dists()) {
do {
if(verbose) {
printf("Distances:\n");
print_st_matrix(&dists, 10, true);
}
} while(adjust_dists());
}
if(verbose) {
printf("Distances:\n");
print_st_matrix(&dists, 10, true);
}
mtxcpy(&prev_memb, &memb);
update_memb();
if(verbose) print_memb(&memb);
update_weights();
if(verbose) print_weights(&weights);
adeq = adequacy();
printf("Adequacy: %.15lf\n", adeq);
adeq_diff = prev_iter_adeq - adeq;
if(adeq_diff < 0.0) {
adeq_diff = fabs(adeq_diff);
printf("Warn: previous iteration adequacy is greater "
"than current (%.15lf).\n", adeq_diff);
}
if(adeq_diff < epsilon) {
printf("Adequacy difference threshold reached (%.15lf)."
"\n", adeq_diff);
break;
}
if(++iter > max_iter) {
printf("Maximum number of iterations reached.\n");
break;
}
} while(true);
free_st_matrix(&prev_memb);
printf("Beta: %.15lf\n", beta);
return adeq;
}
// Main loop for an instance of the algorithm.
double run() {
size_t i;
size_t j;
size_t k;
printf("Initialization.\n");
init_medoids();
if(verbose) print_medoids(medoids);
for(k = 0; k < clustc; ++k) {
for(j = 0; j < dmatrixc; ++j) {
weights[k][j] = 1.0;
}
}
if(verbose) print_weights(weights);
update_memb();
if(verbose) print_memb(memb);
double prev_adeq = 0.0;
double adeq = adequacy_obj(false);
printf("Adequacy: %.20lf\n", adeq);
double diff = fabs(adeq - prev_adeq);
for(i = 1; i <= max_iter && diff > epsilon; ++i) {
printf("Iteration %d.\n", i);
prev_adeq = adeq;
adequacy_cluster(false);
update_medoids();
adeq = adequacy_cluster(true);
if(verbose) {
print_medoids(medoids);
printf("Adequacy1: %.20lf\n", adeq);
}
adequacy_cluster(false);
update_weights();
adeq = adequacy_cluster(true);
if(verbose) {
print_weights(weights);
printf("Adequacy2: %.20lf\n", adeq);
}
adequacy_obj(false);
update_memb();
adeq = adequacy_obj(true);
if(verbose) print_memb(memb);
printf("Adequacy: %.20lf\n", adeq);
if(dgt(adeq, prev_adeq)) {
printf("Warn: current adequacy is greater than "
"previous iteration (%.20lf)\n",
adeq - prev_adeq);
}
diff = fabs(adeq - prev_adeq);
}
printf("Adequacy difference threshold reached (%.20lf).\n",
diff);
return adeq;
}
int main(void)
{
polyfit_t *cubic_fit = polyfit_create(3);
for (unsigned i = 0; i < 10; i++) {
polyfit_add_point(cubic_fit, i, f(i));
double weights[POLYFIT_NUM_WEIGHTS(3)];
polyfit_get_weights(cubic_fit, weights);
print_weights(weights, POLYFIT_NUM_WEIGHTS(3));
}
printf("f(%f) = %f\n", 3.5, f(3.5));
printf("f(%f) ~ %f\n", 3.5, polyfit_estimate_y(cubic_fit, 3.5));
double cubic_fit_archive[POLYFIT_ARCHIVE_LEN(3)];
polyfit_archive(cubic_fit, cubic_fit_archive);
polyfit_destroy(cubic_fit);
polyfit_t *new_cubic_fit = polyfit_create_from_archive(3, cubic_fit_archive);
printf("f(%f) ~ %f\n", 3.5, polyfit_estimate_y(new_cubic_fit, 3.5));
return 0;
}
int main(int argc, char **argv) {
verbose = true;
FILE *cfgfile = fopen(argv[1], "r");
if(!cfgfile) {
printf("Error: could not open config file.\n");
return 1;
}
fscanf(cfgfile, "%d", &objc);
if(objc <= 0) {
printf("Error: objc <= 0.\n");
fclose(cfgfile);
return 1;
}
// reading labels
int classc;
int labels[objc];
fscanf(cfgfile, "%d", &classc);
size_t i;
for(i = 0; i < objc; ++i) {
fscanf(cfgfile, "%d", &labels[i]);
}
// reading labels end
fscanf(cfgfile, "%d", &dmatrixc);
if(dmatrixc <= 0) {
printf("Error: dmatrixc <= 0.\n");
fclose(cfgfile);
return 1;
}
char filenames[dmatrixc][BUFF_SIZE];
size_t j;
for(j = 0; j < dmatrixc; ++j) {
fscanf(cfgfile, "%s", filenames[j]);
}
char outfilename[BUFF_SIZE];
fscanf(cfgfile, "%s", outfilename);
fscanf(cfgfile, "%d", &clustc);
if(clustc <= 0) {
printf("Error: clustc <= 0.\n");
fclose(cfgfile);
return 1;
}
int insts;
fscanf(cfgfile, "%d", &insts);
if(insts <= 0) {
printf("Error: insts <= 0.\n");
fclose(cfgfile);
return 1;
}
fscanf(cfgfile, "%d", &max_iter);
if(insts <= 0) {
printf("Error: max_iter <= 0.\n");
fclose(cfgfile);
return 1;
}
fscanf(cfgfile, "%lf", &epsilon);
if(dlt(epsilon, 0.0)) {
printf("Error: epsilon < 0.\n");
fclose(cfgfile);
return 1;
}
fscanf(cfgfile, "%lf", &mfuz);
if(dlt(mfuz, 1.0)) {
printf("Error: mfuz < 1.0.\n");
fclose(cfgfile);
return 1;
}
fscanf(cfgfile, "%lf", &qexp);
if(dlt(qexp, 1.0)) {
printf("Error: qexp < 1.0.\n");
fclose(cfgfile);
return 1;
}
fclose(cfgfile);
freopen(outfilename, "w", stdout);
printf("###Configuration summary:###\n");
printf("Number of objects: %d\n", objc);
printf("Number of clusters: %d\n", clustc);
printf("Number of instances: %d\n", insts);
printf("Maximum interations: %d\n", max_iter);
printf("Parameter m: %lf\n", mfuz);
printf("Parameter q: %lf\n", qexp);
printf("############################\n");
st_matrix best_memb;
st_matrix best_dists;
st_matrix best_weights;
// memory allocation start
dmatrix = malloc(sizeof(st_matrix) * dmatrixc);
for(j = 0; j < dmatrixc; ++j) {
init_st_matrix(&dmatrix[j], objc, objc);
}
init_st_matrix(&memb, objc, clustc);
init_st_matrix(&best_memb, objc, clustc);
size_t k;
membvec = malloc(sizeof(st_matrix) * clustc);
global_dmatrix = malloc(sizeof(st_matrix) * clustc);
for(k = 0; k < clustc; ++k) {
init_st_matrix(&membvec[k], objc, 1);
init_st_matrix(&global_dmatrix[k], objc, objc);
}
init_st_matrix(&dists, clustc, objc);
init_st_matrix(&best_dists, clustc, objc);
init_st_matrix(&weights, clustc, dmatrixc);
init_st_matrix(&best_weights, clustc, dmatrixc);
// memory allocation end
for(j = 0; j < dmatrixc; ++j) {
if(!load_data(filenames[j], &dmatrix[j])) {
printf("Error: could not load matrix file.\n");
goto END;
}
}
mfuzval = 1.0 / (mfuz - 1.0);
qexpval = 1.0 / (qexp - 1.0);
double avg_partcoef;
double avg_modpcoef;
double avg_partent;
double avg_aid;
st_matrix dists_t;
init_st_matrix(&dists_t, dists.ncol, dists.nrow);
st_matrix agg_dmatrix;
init_st_matrix(&agg_dmatrix, objc, objc);
silhouet *csil;
silhouet *fsil;
silhouet *ssil;
silhouet *avg_csil;
silhouet *avg_fsil;
silhouet *avg_ssil;
int *pred;
st_matrix *groups;
srand(time(NULL));
size_t best_inst;
double best_inst_adeq;
double cur_inst_adeq;
for(i = 1; i <= insts; ++i) {
printf("Instance %d:\n", i);
cur_inst_adeq = run();
pred = defuz(&memb);
groups = asgroups(pred, objc, classc);
transpose_(&dists_t, &dists);
aggregate_dmatrices(&agg_dmatrix, &weights);
csil = crispsil(groups, &agg_dmatrix);
fsil = fuzzysil(csil, groups, &memb, mfuz);
ssil = simplesil(pred, &dists_t);
if(i == 1) {
avg_partcoef = partcoef(&memb);
avg_modpcoef = modpcoef(&memb);
avg_partent = partent(&memb);
avg_aid = avg_intra_dist(&memb, &dists_t, mfuz);
avg_csil = csil;
avg_fsil = fsil;
avg_ssil = ssil;
} else {
avg_partcoef = (avg_partcoef + partcoef(&memb)) / 2.0;
avg_modpcoef = (avg_modpcoef + modpcoef(&memb)) / 2.0;
avg_partent = (avg_partent + partent(&memb)) / 2.0;
avg_aid = (avg_aid +
avg_intra_dist(&memb, &dists_t, mfuz)) / 2.0;
avg_silhouet(avg_csil, csil);
avg_silhouet(avg_fsil, fsil);
avg_silhouet(avg_ssil, ssil);
free_silhouet(csil);
free(csil);
free_silhouet(fsil);
free(fsil);
free_silhouet(ssil);
free(ssil);
}
free(pred);
free_st_matrix(groups);
free(groups);
if(i == 1 || cur_inst_adeq < best_inst_adeq) {
mtxcpy(&best_memb, &memb);
mtxcpy(&best_dists, &dists);
mtxcpy(&best_weights, &weights);
best_inst_adeq = cur_inst_adeq;
best_inst = i;
}
}
printf("\n");
printf("Best adequacy %.15lf on instance %d.\n", best_inst_adeq,
best_inst);
printf("\n");
print_memb(&best_memb);
print_weights(&best_weights);
pred = defuz(&best_memb);
groups = asgroups(pred, objc, classc);
print_header("Partitions", HEADER_SIZE);
print_groups(groups);
print_header("Average indexes", HEADER_SIZE);
printf("\nPartition coefficient: %.10lf\n", avg_partcoef);
printf("Modified partition coefficient: %.10lf\n", avg_modpcoef);
printf("Partition entropy: %.10lf (max: %.10lf)\n", avg_partent,
log(clustc));
printf("Average intra cluster distance: %.10lf\n", avg_aid);
transpose_(&dists_t, &best_dists);
print_header("Best instance indexes", HEADER_SIZE);
printf("\nPartition coefficient: %.10lf\n", partcoef(&best_memb));
printf("Modified partition coefficient: %.10lf\n",
modpcoef(&best_memb));
printf("Partition entropy: %.10lf (max: %.10lf)\n",
partent(&best_memb), log(clustc));
printf("Average intra cluster distance: %.10lf\n",
avg_intra_dist(&best_memb, &dists_t, mfuz));
print_header("Averaged crisp silhouette", HEADER_SIZE);
print_silhouet(avg_csil);
print_header("Averaged fuzzy silhouette", HEADER_SIZE);
print_silhouet(avg_fsil);
print_header("Averaged simple silhouette", HEADER_SIZE);
print_silhouet(avg_ssil);
aggregate_dmatrices(&agg_dmatrix, &best_weights);
csil = crispsil(groups, &agg_dmatrix);
print_header("Best instance crisp silhouette", HEADER_SIZE);
print_silhouet(csil);
fsil = fuzzysil(csil, groups, &best_memb, mfuz);
print_header("Best instance fuzzy silhouette", HEADER_SIZE);
print_silhouet(fsil);
ssil = simplesil(pred, &dists_t);
print_header("Best instance simple silhouette", HEADER_SIZE);
print_silhouet(ssil);
free_silhouet(avg_csil);
free(avg_csil);
free_silhouet(avg_fsil);
free(avg_fsil);
free_silhouet(avg_ssil);
free(avg_ssil);
free_silhouet(csil);
free(csil);
free_silhouet(fsil);
free(fsil);
free_silhouet(ssil);
free(ssil);
free(pred);
free_st_matrix(groups);
free(groups);
free_st_matrix(&dists_t);
free_st_matrix(&agg_dmatrix);
END:
fclose(stdout);
for(j = 0; j < dmatrixc; ++j) {
free_st_matrix(&dmatrix[j]);
}
free(dmatrix);
free_st_matrix(&memb);
free_st_matrix(&best_memb);
for(k = 0; k < clustc; ++k) {
free_st_matrix(&membvec[k]);
free_st_matrix(&global_dmatrix[k]);
}
free(membvec);
free(global_dmatrix);
free_st_matrix(&dists);
free_st_matrix(&best_dists);
free_st_matrix(&weights);
free_st_matrix(&best_weights);
return 0;
}
static DoubleVector dijkstra(const IntVector &consumers,
const IntVector &resources,
const DoubleVector &weights,
int n)
{
DEBUG(print_weights(weights, n));
DEBUG(print_adjacency(resources, n));
DEBUG(print_adjacency(consumers, n));
DoubleVector lengths(n*n);
/* All distances start as infinite */
for(int i=0; i<n*n; ++i)
{
lengths[i] = R_PosInf;
}
/* Diagonal is 0.0 - no cost to moving nowhere */
for(int i=0; i<n; ++i)
{
lengths[i + i*n] = 0.0;
}
for(int source=0; source<n; ++source)
{
DEBUG(Rprintf("source [%d]\n", source));
BoolVector todo(n, true);
while(TRUE)
{
/* Set u to index of node with smallest entry in dist[todo] */
int u = -1;
for(int i=0; i<n; ++i)
{
if(todo[i])
{
if(-1==u) u = i;
if(lengths[source + n*i] < lengths[source + n*u])
{
u = i;
}
}
}
if(-1==u || !R_FINITE(lengths[source + n*u]))
{
break;
}
todo[u] = false;
DEBUG(Rprintf("u [%d]\n", u));
for(int i=0; i<resources[u]; ++i)
{
const int v = resources[u + (1+i)*n];
const double alt = lengths[source + n*u] + weights[v + u*n];
if(alt<lengths[source + n*v])
{
DEBUG(Rprintf("res v [%d]\n", v));
lengths[source + n*v] = alt;
}
}
for(int i=0; i<consumers[u]; ++i)
{
const int v = consumers[u + (1+i)*n];
const double alt = lengths[source + n*u] + weights[u + v*n];
if(alt<lengths[source + n*v])
{
DEBUG(Rprintf("con v [%d]\n", v));
lengths[source + n*v] = alt;
}
}
}
}
return (lengths);
}
int main(int argc, char **argv)
{
//test_resize("data/bad.jpg");
//test_box();
//test_convolutional_layer();
if(argc < 2){
fprintf(stderr, "usage: %s <function>\n", argv[0]);
return 0;
}
gpu_index = find_int_arg(argc, argv, "-i", 0);
if(find_arg(argc, argv, "-nogpu")) {
gpu_index = -1;
}
#ifndef GPU
gpu_index = -1;
#else
if(gpu_index >= 0){
cuda_set_device(gpu_index);
}
#endif
if (0 == strcmp(argv[1], "average")){
average(argc, argv);
} else if (0 == strcmp(argv[1], "yolo")){
run_yolo(argc, argv);
} else if (0 == strcmp(argv[1], "super")){
run_super(argc, argv);
} else if (0 == strcmp(argv[1], "lsd")){
run_lsd(argc, argv);
} else if (0 == strcmp(argv[1], "detector")){
run_detector(argc, argv);
} else if (0 == strcmp(argv[1], "detect")){
float thresh = find_float_arg(argc, argv, "-thresh", .5);
char *filename = (argc > 4) ? argv[4]: 0;
char *outfile = find_char_arg(argc, argv, "-out", 0);
int fullscreen = find_arg(argc, argv, "-fullscreen");
test_detector("cfg/coco.data", argv[2], argv[3], filename, thresh, .5, outfile, fullscreen);
} else if (0 == strcmp(argv[1], "cifar")){
run_cifar(argc, argv);
} else if (0 == strcmp(argv[1], "go")){
run_go(argc, argv);
} else if (0 == strcmp(argv[1], "rnn")){
run_char_rnn(argc, argv);
} else if (0 == strcmp(argv[1], "coco")){
run_coco(argc, argv);
} else if (0 == strcmp(argv[1], "classify")){
predict_classifier("cfg/imagenet1k.data", argv[2], argv[3], argv[4], 5);
} else if (0 == strcmp(argv[1], "classifier")){
run_classifier(argc, argv);
} else if (0 == strcmp(argv[1], "regressor")){
run_regressor(argc, argv);
} else if (0 == strcmp(argv[1], "isegmenter")){
run_isegmenter(argc, argv);
} else if (0 == strcmp(argv[1], "segmenter")){
run_segmenter(argc, argv);
} else if (0 == strcmp(argv[1], "art")){
run_art(argc, argv);
} else if (0 == strcmp(argv[1], "tag")){
run_tag(argc, argv);
} else if (0 == strcmp(argv[1], "3d")){
composite_3d(argv[2], argv[3], argv[4], (argc > 5) ? atof(argv[5]) : 0);
} else if (0 == strcmp(argv[1], "test")){
test_resize(argv[2]);
} else if (0 == strcmp(argv[1], "nightmare")){
run_nightmare(argc, argv);
} else if (0 == strcmp(argv[1], "rgbgr")){
rgbgr_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "reset")){
reset_normalize_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "denormalize")){
denormalize_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "statistics")){
statistics_net(argv[2], argv[3]);
} else if (0 == strcmp(argv[1], "normalize")){
normalize_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "rescale")){
rescale_net(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "ops")){
operations(argv[2]);
} else if (0 == strcmp(argv[1], "speed")){
speed(argv[2], (argc > 3 && argv[3]) ? atoi(argv[3]) : 0);
} else if (0 == strcmp(argv[1], "oneoff")){
oneoff(argv[2], argv[3], argv[4]);
} else if (0 == strcmp(argv[1], "oneoff2")){
oneoff2(argv[2], argv[3], argv[4], atoi(argv[5]));
} else if (0 == strcmp(argv[1], "print")){
print_weights(argv[2], argv[3], atoi(argv[4]));
} else if (0 == strcmp(argv[1], "partial")){
partial(argv[2], argv[3], argv[4], atoi(argv[5]));
} else if (0 == strcmp(argv[1], "average")){
average(argc, argv);
} else if (0 == strcmp(argv[1], "visualize")){
visualize(argv[2], (argc > 3) ? argv[3] : 0);
} else if (0 == strcmp(argv[1], "mkimg")){
mkimg(argv[2], argv[3], atoi(argv[4]), atoi(argv[5]), atoi(argv[6]), argv[7]);
} else if (0 == strcmp(argv[1], "imtest")){
test_resize(argv[2]);
} else {
fprintf(stderr, "Not an option: %s\n", argv[1]);
}
return 0;
}
int main(int argc, char **argv) {
verbose = false;
int insts;
// Opening and reading config file.
FILE *cfgfile = fopen(argv[1], "r");
if(!cfgfile) {
printf("Error: could not open config file.\n");
return 1;
}
fscanf(cfgfile, "%d", &objc);
if(objc <= 0) {
printf("Error: objc <= 0.\n");
return 2;
}
int labels[objc];
// reading labels
int classc;
fscanf(cfgfile, "%d", &classc);
size_t i;
for(i = 0; i < objc; ++i) {
fscanf(cfgfile, "%d", &labels[i]);
}
// reading labels end
fscanf(cfgfile, "%d", &dmatrixc);
if(dmatrixc <= 0) {
printf("Error: dmatrixc <= 0.\n");
return 2;
}
char dmtx_file_name[dmatrixc][BUFF_SIZE];
size_t j;
for(j = 0; j < dmatrixc; ++j) {
fscanf(cfgfile, "%s", dmtx_file_name[j]);
}
char out_file_name[BUFF_SIZE];
fscanf(cfgfile, "%s", out_file_name);
fscanf(cfgfile, "%d", &clustc);
if(clustc <= 0) {
printf("Error: clustc <= 0.\n");
return 2;
}
fscanf(cfgfile, "%d", &medoids_card);
if(medoids_card <= 0) {
printf("Error: medoids_card <= 0.\n");
return 2;
}
fscanf(cfgfile, "%d", &insts);
if(insts <= 0) {
printf("Error: insts <= 0.\n");
return 2;
}
fscanf(cfgfile, "%lf", &theta);
if(dlt(theta, 0.0)) {
printf("Error: theta < 0.\n");
return 2;
}
fscanf(cfgfile, "%d", &max_iter);
fscanf(cfgfile, "%lf", &epsilon);
if(dlt(epsilon, 0.0)) {
printf("Error: epsilon < 0.\n");
return 2;
}
fscanf(cfgfile, "%lf", &mfuz);
if(!dgt(mfuz, 0.0)) {
printf("Error: mfuz <= 0.\n");
return 2;
}
fclose(cfgfile);
// Done reading config file.
freopen(out_file_name, "w", stdout);
mfuzval = 1.0 / (mfuz - 1.0);
printf("######Config summary:######\n");
printf("Number of clusters: %d.\n", clustc);
printf("Medoids cardinality: %d.\n", medoids_card);
printf("Number of iterations: %d.\n", max_iter);
printf("Epsilon: %.15lf.\n", epsilon);
printf("Theta: %.15lf.\n", theta);
printf("Parameter m: %.15lf.\n", mfuz);
printf("Number of instances: %d.\n", insts);
printf("###########################\n");
size_t k;
// Allocating memory start
parc_cluster_adeq = malloc(sizeof(double) * clustc);
parc_obj_adeq = malloc(sizeof(double) * objc);
dmatrix = malloc(sizeof(double **) * dmatrixc);
for(j = 0; j < dmatrixc; ++j) {
dmatrix[j] = malloc(sizeof(double *) * objc);
for(i = 0; i < objc; ++i) {
dmatrix[j][i] = malloc(sizeof(double) * objc);
}
}
medoids = malloc(sizeof(size_t **) * clustc);
size_t ***best_medoids = malloc(sizeof(size_t **) * clustc);
for(k = 0; k < clustc; ++k) {
medoids[k] = malloc(sizeof(size_t *) * dmatrixc);
best_medoids[k] = malloc(sizeof(size_t *) * dmatrixc);
for(j = 0; j < dmatrixc; ++j) {
medoids[k][j] = malloc(sizeof(size_t) * medoids_card);
best_medoids[k][j] = malloc(sizeof(size_t) * medoids_card);
}
}
weights = malloc(sizeof(double *) * clustc);
double **best_weights = malloc(sizeof(double *) * clustc);
for(k = 0; k < clustc; ++k) {
weights[k] = malloc(sizeof(double) * dmatrixc);
best_weights[k] = malloc(sizeof(double) * dmatrixc);
}
memb = malloc(sizeof(double *) * objc);
double **best_memb = malloc(sizeof(double *) * objc);
for(i = 0; i < objc; ++i) {
memb[i] = malloc(sizeof(double) * clustc);
best_memb[i] = malloc(sizeof(double) * clustc);
}
// Allocating memory end
for(j = 0; j < dmatrixc; ++j) {
if(!load_data(dmtx_file_name[j], dmatrix[j], objc, objc)) {
printf("Error: could not load %s.\n", dmtx_file_name[j]);
goto END;
}
}
size_t best_inst;
double best_inst_adeq;
double cur_inst_adeq;
srand(time(NULL)); // Random seed.
// Start main program loop.
for(i = 1; i <= insts; ++i) {
printf("Instance %u:\n", i);
cur_inst_adeq = run();
if(i == 1 || cur_inst_adeq < best_inst_adeq) {
// Saves the best configuration based on the adequacy.
mtxcpy_d(best_memb, memb, objc, clustc);
mtxcpy_d(best_weights, weights, clustc, dmatrixc);
for(k = 0; k < clustc; ++k) {
mtxcpy_size_t(best_medoids[k], medoids[k], dmatrixc,
medoids_card);
}
best_inst_adeq = cur_inst_adeq;
best_inst = i;
}
}
// Print the best configuration, confusion matrix and the CR
// index.
printf("\n");
printf("Best adequacy %.15lf on instance %d.\n",
best_inst_adeq, best_inst);
printf("\n");
print_medoids(best_medoids);
printf("\n");
print_memb(best_memb);
printf("\n");
print_weights(best_weights);
printf("\n");
global_energy();
printf("\n");
int *pred = defuz(memb, objc, clustc);
print_groups(pred, objc, clustc);
double **confmtx = confusion(pred, labels, objc);
printf("\nConfusion matrix (class x predicted):\n");
print_mtx_d(confmtx, classc, classc, 0);
++classc;
for(i = 0; i < classc; ++i) {
free(confmtx[i]);
}
free(confmtx);
printf("Corrected Rand: %.7lf\n", corand(pred, labels, objc));
free(pred);
// Freeing memory.
END:
fclose(stdout);
for(i = 0; i < dmatrixc; ++i) {
for(j = 0; j < objc; ++j) {
free(dmatrix[i][j]);
}
free(dmatrix[i]);
}
free(dmatrix);
for(k = 0; k < clustc; ++k) {
for(j = 0; j < dmatrixc; ++j) {
free(medoids[k][j]);
free(best_medoids[k][j]);
}
free(medoids[k]);
free(best_medoids[k]);
free(weights[k]);
free(best_weights[k]);
}
free(medoids);
free(best_medoids);
free(weights);
free(best_weights);
for(i = 0; i < objc; ++i) {
free(memb[i]);
free(best_memb[i]);
}
free(memb);
free(best_memb);
free(parc_cluster_adeq);
free(parc_obj_adeq);
return 0;
}
