Explorar el Código

implement divide and conquer

tags/1.0.0
Chris Cromer hace 11 meses
padre
commit
6ac113d408
Firmado por: Chris Cromer <chris@cromer.cl> ID de clave GPG: 39CC813FF3C8708A
Se han modificado 4 ficheros con 156 adiciones y 70 borrados
  1. +1
    -1
      src/distance.c
  2. +146
    -53
      src/divide_and_conquer.c
  3. +6
    -13
      src/points.c
  4. +3
    -3
      test/test.c

+ 1
- 1
src/distance.c Ver fichero

@@ -23,5 +23,5 @@
* @return Retorna la distancia entre los 2 puntos
*/
double distance(point_t point1, point_t point2) {
return sqrt(pow(point1.x - point2.x, 2) + pow(point1.y - point2.y, 2));
return pow(point1.x - point2.x, 2) + pow(point1.y - point2.y, 2);
}

+ 146
- 53
src/divide_and_conquer.c Ver fichero

@@ -14,74 +14,167 @@
*/

#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <float.h>
#include "points.h"
#include "brute_force.h"
#include "distance.h"

/**
* Encontrar los 2 puntos más cercano usando el metodo de dividir para conquistar
* @param point_ts Los puntos a calcular
* @param n La cantidad de puntos en el array point_ts
* @param minimum_dist La distancia minimo encontrado
* @return Retorna los 2 puntos mas cercanos
* Comparar 2 double para ver cual es mayor o si son iguales
* @param a El primer double a comparar
* @param b El segundo double a comparar
* @return Retorna 1 si a es mayor de b, -1 si a es menor de b ó 0 si son igual
*/
int compareX(const void* a, const void* b){ //ordena el arreglo de puntos de acuerdo a X
point_t *p1 = (point_t *)a, *p2 = (point_t *)b;
return (p1->x - p2->x);
int compare_double(double a, double b) {
if (a > b) {
return 1;
}
else if (a < b) {
return -1;
}
else {
return 0;
}
}

int compareY(const void* a, const void* b){ //ordena el arreglo de puntos de acuerdo a Y
point_t *p1 = (point_t *)a, *p2 = (point_t *)b;
return (p1->y - p2->y);
/**
* Comparar los el eje x de 2 puntos
* @param a El primer punto a comparar
* @param b El segundo punto a comparar
* @return Retorna la comparación entre los 2 puntos
*/
int compare_x(const void * a, const void * b) {
return compare_double((*(point_t *) a).x, (*(point_t *) b).x);
}

double min(double x, double y){ // Función para encontrar el mayor entre dos valores flotantes
return (x < y)? x : y;
/**
* Comparar los el eje y de 2 puntos
* @param a El primer punto a comparar
* @param b El segundo punto a comparar
* @return Retorna la comparación entre los 2 puntos
*/
int compare_y(const void * a, const void * b) {
return compare_double((*(point_t *) a).y, (*(point_t *) b).y);
}

void stripClosest(point_t *strip, int n, double *minimum_dist, point_t *closest_pair) // Función para encontrar la distancia entre los puntos más cerca del arreglo dado
{
double dist;
qsort(strip, n, sizeof(point_t), compareY);
for (int i = 0; i < n; ++i)
for (int j = i+1; j < n && (strip[j].y - strip[i].y) < *minimum_dist; ++j)
if ((dist = distance(strip[i],strip[j])) < *minimum_dist){
*minimum_dist = dist;
closest_pair[0] = strip[i];
closest_pair[1] = strip[j];
}
}

double closestUtil(point_t *P, int n, double *minimum_dist, point_t *closest_pair){ // Función para encontrar la distancia más corta entre puntos
int mid = n/2;
point_t midpoint_t = P[mid];
// Consider the vertical line passing through the middle point_t
// calculate the smallest distance dl on left of middle point_t and
// dr on right side
double dl = closestUtil(P, mid, minimum_dist, closest_pair);
double dr = closestUtil(P + mid, n-mid, minimum_dist, closest_pair);
double d = min(dl, dr); // Encontrar la distancia minima de dos puntos

/* Crea un arreglo que contiene los puntos cercanos, mas cerca que d*/
point_t strip[n];
int j = 0;
for (int i = 0; i < n; i++)
if (abs(P[i].x - midpoint_t.x) < d)
strip[j] = P[i], j++;

/*Encontrar el punto más cercano en la cinta, retornando el minimo de d y el más cercano
distance es strip[]*/
*minimum_dist = min(d, stripClosest(strip, j, minimum_dist, closest_pair) );
return *minimum_dist;
}
/**
* El algoritmo de encontrar 2 puntos recursivo usando divide and conquer
* @param points_x Los puntos ordenado en el eje x
* @param nx La cantidad de puntos en el array points_y
* @param points_y Los puntos ordenado en el eje y
* @param ny La cantidad de puntos en el array points_y
* @param closest_pair Las 2 pares de puntos mas cercano
* @return Retorna la distance entre los dos puntos mas cercano
*/
double divide_and_conquer_run(point_t *points_x, unsigned int nx, point_t *points_y, unsigned int ny, point_t *closest_pair) {
int left;
int right;
int i;
double mid;
double d = DBL_MAX;
double min_d = DBL_MAX;
double x0;
double x1;
double x;
point_t *closest_pair2;
point_t *points_y2;
if (nx <= 4) {
closest_pair2 = brute_force(points_x, nx, &d);
closest_pair[0] = closest_pair2[0];
closest_pair[1] = closest_pair2[1];
return d;
}

closest_pair2 = malloc(sizeof(point_t) * 2);
points_y2 = malloc(sizeof(point_t) * ny);
mid = points_x[nx / 2].x;

left = -1;
right = ny;
for (i = 0; i < ny; i++) {
if (points_y[i].x < mid) {
points_y2[++left] = points_y[i];
}
else {
points_y2[--right]= points_y[i];
}
}

for (i = ny - 1; right < i; right ++, i--) {
closest_pair2[0] = points_y2[right];
points_y2[right] = points_y2[i];
points_y2[i] = closest_pair2[0];
}

min_d = divide_and_conquer_run(points_x, nx / 2, points_y2, left + 1, closest_pair);
d = divide_and_conquer_run(points_x + nx / 2, nx - nx / 2, points_y2 + left + 1, ny - left - 1, closest_pair2);

if (d < min_d) {
min_d = d;
closest_pair[0] = closest_pair2[0];
closest_pair[1] = closest_pair2[1];
}
d = sqrt(min_d);
free(closest_pair2);

left = -1; right = ny;
for (i = 0; i < ny; i++) {
x = points_y[i].x - mid;
if (x <= -d || x >= d) {
continue;
}
if (x < 0) {
points_y2[++left] = points_y[i];
}
else {
points_y2[--right] = points_y[i];
}
}

while (left >= 0) {
x0 = points_y2[left].y + d;

while (right < ny && points_y2[right].y > x0) {
right ++;
}
if (right >= ny) {
break;
}

x1 = points_y2[left].y - d;
for (i = right; i < ny && points_y2[i].y > x1; i++)
if ((x = distance(points_y2[left], points_y2[i])) < min_d) {
min_d = x;
closest_pair[0] = points_y2[left];
closest_pair[1] = points_y2[i];
}
left--;
}

free(points_y2);
return min_d;
}

/**
* Encontrar los 2 puntos más cercano usando el metodo de dividir para conquistar
* @param point_t Los puntos a calcular
* @param n La cantidad de puntos en el array point_ts
* @param minimum_dist La distancia minimo encontrado
* @return Retorna los 2 puntos mas cercanos
*/
point_t * divide_and_conquer(point_t *points, unsigned int n, double *minimum_dist) {
point_t *closest_pair = malloc(sizeof(point_t) * 2);
qsort(points, n, sizeof(point_t), compareX);
closestUtil(points, n, minimum_dist, closest_pair); //Usa la funcion recursiva closestUtil para encontrar la distancia minima
point_t *points_x = malloc(sizeof(point_t) * n);
point_t *points_y = malloc(sizeof(point_t) * n);
memcpy(points_x, points, sizeof(point_t) * n);
memcpy(points_y, points, sizeof(point_t) * n);
qsort(points_x, n, sizeof(point_t), compare_x);
qsort(points_y, n, sizeof(point_t), compare_y);
*minimum_dist = divide_and_conquer_run(points_x, n, points_y, n, closest_pair);
free(points_x);
free(points_y);
return closest_pair;
}


+ 6
- 13
src/points.c Ver fichero

@@ -18,6 +18,7 @@
#include <getopt.h>
#include <string.h>
#include <float.h>
#include <math.h>
#include "points.h"
#include "distance.h"
#include "timer.h"
@@ -166,26 +167,18 @@ int main (int argc, char **argv) {
end_algorithm();
fprintf(stdout, "point 1: x: %f y: %f\n", closest_points[0].x, closest_points[0].y);
fprintf(stdout, "point 2: x: %f y: %f\n", closest_points[1].x, closest_points[1].y);
fprintf(stdout, "distance: %lf\n\n", dist);
fprintf(stdout, "distance: %lf\n\n", sqrt(dist));
free(closest_points);
closest_points = NULL;
}

if (divide) {
if (n <= 3) {
fprintf(stderr, "Divide and conquer necesita 4 o mas puntos!\nSe utilizará Brute Force como alternativa!\n");
start_algorithm("Brute force corriendo... ", n);
closest_points = brute_force(points, n, &dist);
end_algorithm();
}
else {
start_algorithm("Divide and conquer corriendo... ", n);
closest_points = divide_and_conquer(points, n, &dist);
end_algorithm();
}
start_algorithm("Divide and conquer corriendo... ", n);
closest_points = divide_and_conquer(points, n, &dist);
end_algorithm();
fprintf(stdout, "point 1: x: %f y: %f\n", closest_points[0].x, closest_points[0].y);
fprintf(stdout, "point 2: x: %f y: %f\n", closest_points[1].x, closest_points[1].y);
fprintf(stdout, "distance: %lf\n", dist);
fprintf(stdout, "distance: %lf\n", sqrt(dist));
free(closest_points);
closest_points = NULL;
}

+ 3
- 3
test/test.c Ver fichero

@@ -30,7 +30,7 @@
* @param d2 El segudno double
* @return Retorna 1 si son igual o 0 sino
*/
int compare_double(double d1, double d2) {
inline int compare_double(double d1, double d2) {
double precision = 0.000000001;
if (((d1 - precision) < d2) && ((d1 + precision) > d2)) {
return 1;
@@ -72,7 +72,7 @@ int main(int argc, char **argv) {
fprintf(stdout, "\tbrute force: ");
fflush(stdout);
brute_force(points, n, &dist);
if (compare_double(dist, 0.067687840)) {
if (compare_double(sqrt(dist), 0.067687840)) {
fprintf(stdout, "passed\n");
passed++;
}
@@ -90,7 +90,7 @@ int main(int argc, char **argv) {
fprintf(stdout, "\tdivide and conquer: ");
fflush(stdout);
divide_and_conquer(points, n, &dist);
if (compare_double(dist, 0.067687840)) {
if (compare_double(sqrt(dist), 0.067687840)) {
fprintf(stdout, "passed\n");
passed++;
}

Cargando…
Cancelar
Guardar