Refactorized ClosestPair.java in order to be compliant with java sun rules

commit divideconquer\ClosesPair.java
Refactorized ClosestPair.java. Finding nearest cartesian points.

Refactorized ClosestPair.java. Finding nearest cartesian points.

Author: MarisaAfuera

divideconquer/ClosestPair.java

@@ -0,0 +1,348 @@
+package divideconquer;
+
+/**
+
+* For a set of points in a coordinates system (10000 maximum), 
+* ClosestPair class calculates the two closest points.
+
+* @author: anonymous 
+* @author: Marisa Afuera
+*/
+
+ public final class ClosestPair {	 
+
+
+	/** Number of points */
+	int numberPoints = 0;
+	/** Input data, maximum 10000. */
+	private Location[] array;
+	/** Minimum point coordinate. */
+	Location point1 = null; 
+	/** Minimum point coordinate. */
+	Location point2 = null; 
+	/** Minimum point length. */
+	private static double minNum = Double.MAX_VALUE; 
+	/** secondCount */
+	private static int secondCount = 0;	
+	
+	/**
+	* Constructor.
+	*/
+	ClosestPair(int points) {
+		numberPoints = points;
+		array = new Location[numberPoints];
+	}
+	
+	/** 
+	  Location class is an auxiliary type to keep points coordinates.
+	 */
+
+	public static class Location {
+
+		double x = 0;
+		double y = 0;
+		
+		/** 
+		 * @param xpar        (IN Parameter)  x coordinate <br/>
+		 * @param ypar        (IN Parameter)  y coordinate <br/>
+		 */
+		
+		Location(final double xpar, final double ypar) { //Save x, y coordinates
+			this.x = xpar;
+			this.y = ypar;
+		}
+
+	}
+	
+	public Location[] createLocation(int numberValues) {
+		return new Location[numberValues];
+		
+	}
+	
+	public Location buildLocation(double x, double y){
+		return new Location(x,y);
+	}
+
+	
+	/** xPartition function: arrange x-axis.
+	 * @param a            (IN Parameter)  array of points <br/>
+	 * @param first        (IN Parameter)  first point <br/>
+	 * @param last         (IN Parameter)  last point <br/>
+	 * @return pivot index
+	 */
+	
+	public int xPartition(
+	        final Location[] a, final int first, final int last) {
+		
+		Location pivot = a[last]; // pivot
+		int pIndex = last;
+		int i = first - 1;
+		Location temp; // Temporarily store value for position transformation
+		for (int j = first; j <= last - 1; j++) {
+			if (a[j].x <= pivot.x) { // Less than or less than pivot
+				i++;
+				temp = a[i]; // array[i] <-> array[j]
+				a[i] = a[j];
+				a[j] = temp;
+			}
+		}
+		i++;
+		temp = a[i]; // array[pivot] <-> array[i]
+		a[i] = a[pIndex];
+		a[pIndex] = temp;
+		return i; // pivot index
+	}
+	
+	/** yPartition function: arrange y-axis.
+	 * @param a            (IN Parameter)  array of points <br/>
+	 * @param first        (IN Parameter)  first point <br/>
+	 * @param last         (IN Parameter)  last point <br/>
+	 * @return pivot index
+	 */
+	
+	public int yPartition(
+			final Location[] a, final int first, final int last) { 
+		
+		Location pivot = a[last]; // pivot
+		int pIndex = last;
+		int i = first - 1;
+		Location temp; // Temporarily store value for position transformation
+		for (int j = first; j <= last - 1; j++) {
+			if (a[j].y <= pivot.y) { // Less than or less than pivot
+				i++;
+				temp = a[i]; // array[i] <-> array[j]
+				a[i] = a[j];
+				a[j] = temp;
+			}
+		}
+		i++;
+		temp = a[i]; // array[pivot] <-> array[i]
+		a[i] = a[pIndex];
+		a[pIndex] = temp;
+		return i; // pivot index
+	}
+	
+	/** xQuickSort function: //x-axis Quick Sorting.
+	 * @param a            (IN Parameter)  array of points <br/>
+	 * @param first        (IN Parameter)  first point <br/>
+	 * @param last         (IN Parameter)  last point <br/>
+	 */
+	
+	public void xQuickSort(
+			   final Location[] a, final int first, final int last) { 
+		
+		if (first < last) {
+			int q = xPartition(a, first, last); // pivot
+			xQuickSort(a, first, q - 1); // Left
+			xQuickSort(a, q + 1, last); // Right
+		}
+	}
+
+	/** yQuickSort function: //y-axis Quick Sorting.
+	 * @param a            (IN Parameter)  array of points <br/>
+	 * @param first        (IN Parameter)  first point <br/>
+	 * @param last         (IN Parameter)  last point <br/>
+	 */
+	
+	public void yQuickSort(
+			    final Location[] a, final int first, final int last) {
+		
+		if (first < last) {
+			int q = yPartition(a, first, last); // pivot
+			yQuickSort(a, first, q - 1); // Left
+			yQuickSort(a, q + 1, last); // Right
+		}
+	}
+
+	/** closestPair function: find closest pair.
+	 * @param a         (IN Parameter) array stored before divide <br/>
+	 * @param indexNum  (IN Parameter) number coordinates divideArray <br/>
+	 * @return minimum distance <br/>
+	 */
+	
+	public double closestPair(final Location[] a, final int indexNum) {
+		
+		Location[] divideArray = new Location[indexNum]; 
+		System.arraycopy(a, 0, divideArray, 0, indexNum); // Copy previous array
+		int totalNum = indexNum; // number of coordinates in the divideArray 
+		int divideX = indexNum / 2; // Intermediate value for divide
+		Location[] leftArray = new Location[divideX]; //divide - left array
+		//divide-right array
+		Location[] rightArray = new Location[totalNum - divideX]; 
+		if (indexNum <= 3) { // If the number of coordinates is 3 or less
+			return bruteForce(divideArray);
+		}
+		//divide-left array
+		System.arraycopy(divideArray, 0, leftArray, 0, divideX);
+		//divide-right array
+		System.arraycopy(
+			divideArray, divideX, rightArray, 0, totalNum - divideX); 
+
+		double minLeftArea = 0; //Minimum length of left array
+		double minRightArea = 0; //Minimum length of right array
+		double minValue = 0; //Minimum lengt
+
+		minLeftArea = closestPair(leftArray, divideX); // recursive closestPair
+		minRightArea = closestPair(rightArray, totalNum - divideX);
+		// window size (= minimum length)
+		minValue = Math.min(minLeftArea, minRightArea); 
+
+		// Create window.  Set the size for creating a window
+		// and creating a new array for the coordinates in the window
+		for (int i = 0; i < totalNum; i++) { 
+			double xGap = Math.abs(divideArray[divideX].x - divideArray[i].x);
+			if (xGap < minValue) {
+				secondCount++; // size of the array
+			} else {
+				if (divideArray[i].x > divideArray[divideX].x) {
+					break;
+				}
+			}
+		}
+		// new array for coordinates in window
+		Location[] firstWindow = new Location[secondCount]; 
+		int k = 0;
+		for (int i = 0; i < totalNum; i++) {
+			double xGap = Math.abs(divideArray[divideX].x - divideArray[i].x);
+			if (xGap < minValue) { // if it's inside a window
+				firstWindow[k] = divideArray[i]; // put in an array
+				k++;
+			} else {
+				if (divideArray[i].x > divideArray[divideX].x) {
+					break;
+				}
+			}
+		}
+		yQuickSort(firstWindow, 0, secondCount - 1); // Sort by y coordinates
+		/* Coordinates in Window */
+		double length = 0;
+		// size comparison within window
+		for (int i = 0; i < secondCount - 1; i++) { 
+			for (int j = (i + 1); j < secondCount; j++) {
+				double xGap = Math.abs(firstWindow[i].x - firstWindow[j].x);
+				double yGap = Math.abs(firstWindow[i].y - firstWindow[j].y);
+				if (yGap < minValue) {
+					length = Math.sqrt(Math.pow(xGap, 2) + Math.pow(yGap, 2));
+					// If measured distance is less than current min distance
+					if (length < minValue) { 
+						// Change minimum distance to current distance
+						minValue = length;
+						// Conditional for registering final coordinate
+						if (length < minNum) { 
+							minNum = length;
+							point1 = firstWindow[i];
+							point2 = firstWindow[j];
+						}
+					}
+				} 
+				else {
+					break;
+				}	
+			}
+		}
+		secondCount = 0;
+		return minValue;
+	}
+
+	/** bruteForce function: When the number of coordinates is less than 3.
+	 * @param arrayParam   (IN Parameter) array stored before divide <br/>
+	 * @return  <br/>
+	 */
+	
+	public double bruteForce(final Location[] arrayParam) {  
+		
+		double minValue = Double.MAX_VALUE; // minimum distance
+		double length = 0; 
+		double xGap = 0; // Difference between x coordinates
+		double yGap = 0; // Difference between y coordinates
+		double result = 0;
+		
+        if (arrayParam.length == 2) {
+        	// Difference between x coordinates
+            xGap = (arrayParam[0].x - arrayParam[1].x);
+            // Difference between y coordinates
+		    yGap = (arrayParam[0].y - arrayParam[1].y);
+		    // distance between coordinates
+		    length = Math.sqrt(Math.pow(xGap, 2) + Math.pow(yGap, 2));
+		    // Conditional statement for registering final coordinate
+		    if (length < minNum) { 
+	    	      minNum = length;
+		   
+		    }	
+		       point1 = arrayParam[0];
+			      point2 = arrayParam[1];
+		      result = length;
+        }
+        if (arrayParam.length == 3) { 
+        	for (int i = 0; i < arrayParam.length - 1; i++) {
+		    	  for (int j = (i + 1); j < arrayParam.length; j++) {
+		    		  // Difference between x coordinates
+			    	  xGap = (arrayParam[i].x - arrayParam[j].x); 
+			    	  // Difference between y coordinates
+				      yGap = (arrayParam[i].y - arrayParam[j].y); 
+				      // distance between coordinates
+				      length = 
+				    	  Math.sqrt(Math.pow(xGap, 2) + Math.pow(yGap, 2)); 
+			          // If measured distance is less than current min distance
+				      if (length < minValue) { 
+				    	  // Change minimum distance to current distance
+				          minValue = length; 
+					      if (length < minNum) { 
+					          // Registering final coordinate
+						      minNum = length;
+						      point1 = arrayParam[i];
+						      point2 = arrayParam[j];
+					      }
+				      }
+			      }
+		      }
+		      result = minValue;
+         
+         }
+         return result; // If only one point returns 0. 
+	}
+
+	/** main function: execute class.
+	 * @param args   (IN Parameter) <br/>
+	 * @throws IOException If an input or output 
+     *                     exception occurred
+	 */
+	
+	public static void main(final String[] args) {
+
+		//Input data consists of one x-coordinate and one y-coordinate		
+		
+		ClosestPair cp = new ClosestPair(12);
+		cp.array[0]=cp.buildLocation(2,3);
+		cp.array[1]=cp.buildLocation(2,16); 
+		cp.array[2]=cp.buildLocation(3,9);		
+		cp.array[3]=cp.buildLocation(6,3);
+		cp.array[4]=cp.buildLocation(7,7);
+		cp.array[5]=cp.buildLocation(19,4);
+		cp.array[6]=cp.buildLocation(10,11);
+		cp.array[7]=cp.buildLocation(15,2);
+		cp.array[8]=cp.buildLocation(15,19);
+		cp.array[9]=cp.buildLocation(16,11);
+		cp.array[10]=cp.buildLocation(17,13);
+		cp.array[11]=cp.buildLocation(9,12);
+				
+		System.out.println("Input data");
+		System.out.println("Number of points: "+ cp.array.length);
+		for (int i=0;i<cp.array.length;i++){
+			System.out.println("x: " + cp.array[i].x + ", y: " + cp.array[i].y);
+		}
+
+		cp.xQuickSort(cp.array, 0, cp.array.length-1); // Sorting by x value
+
+		double result; // minimum distance
+		
+		result = cp.closestPair(cp.array, cp.array.length); 
+		// ClosestPair start
+		// minimum distance coordinates and distance output
+		System.out.println("Output Data"); 
+		System.out.println("(" + cp.point1.x + ", " + cp.point1.y + ")");
+		System.out.println("(" + cp.point2.x + ", " + cp.point2.y + ")");
+		System.out.println("Minimum Distance : " + result);
+
+	}
+}