limpieza 101

src/divide_and_conquer.c

@@ -35,35 +35,35 @@ int compareY(const void* a, const void* b){     //ordena el arreglo de puntos de
 	    return (p1->y - p2->y); 
 }
 
-float min(float x, float y){  // Función para encontrar el mayor entre dos valores flotantes
+double min(double x, double y){  // Función para encontrar el mayor entre dos valores flotantes
 	return (x < y)? x : y; 
 }
 
-float stripClosest(point_t strip[], int size, float d) // Función para encontrar la distancia entre los puntos más cerca del arreglo dado
+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
 { 
-	    float min = d;  // inicializa en la distancia minima d
+	  	double dist;
+	    qsort(strip, n, sizeof(point_t), compareY);  
 	  
-	    qsort(strip, size, sizeof(point_t), compareY);  
-	  
-	    for (int i = 0; i < size; ++i) 
-	        for (int j = i+1; j < size && (strip[j].y - strip[i].y) < min; ++j) 
-	            if (distance(strip[i],strip[j]) < min) 
-	                min = dist(strip[i], strip[j]); 
-	  
-	    return min; 
+	    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];
+	            }
 } 
 
-float closestUtil(point_t P[], int n){ // Función para encontrar la distancia más corta entre puntos
+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 
-		    float dl = closestUtil(P, mid); 
-		    float dr = closestUtil(P + mid, n-mid); 
+		    double dl = closestUtil(P, mid, minimum_dist, closest_pair); 
+		    double dr = closestUtil(P + mid, n-mid, minimum_dist, closest_pair); 
 		  
-		    float d = min(dl, dr); // Encontrar la distancia minima de dos puntos
+		    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]; 
@@ -74,13 +74,15 @@ float closestUtil(point_t P[], int n){ // Función para encontrar la distancia m
 
 		    /*Encontrar el punto más cercano en la cinta, retornando el minimo de d y el más cercano 
 		    	distance es strip[]*/
-		    return min(d, stripClosest(strip, j, d) ); 
+		    *minimum_dist = min(d, stripClosest(strip, j, minimum_dist, closest_pair) );
+		    return *minimum_dist;
 } 
 
 point_t * divide_and_conquer(point_t *points, unsigned int n, double *minimum_dist) {
 	point_t *closest_pair = malloc(sizeof(point_t) * 2);
-	qsort(P, n, sizeof(point_t), compareX); 
-	return closestUtil(P, n); //Usa la funcion recursiva closestUtil para encontrar la distancia minima
+	qsort(points, n, sizeof(point_t), compareX); 
+	closestUtil(points, n, minimum_dist, closest_pair); //Usa la funcion recursiva closestUtil para encontrar la distancia minima
+	return closest_pair;
 }