Fix Checkstyle violations: remove trailing spaces, fix formatting

Author: motalib-code

src/main/java/com/thealgorithms/geometry/RotatingCalipers.java

@@ -4,64 +4,66 @@
 
 /**
  * Implementation of the Rotating Calipers algorithm for convex polygons.
- * 
+ *
  * The Rotating Calipers algorithm is used to compute various geometric properties
  * of convex polygons efficiently, including:
  * - Diameter: the largest distance between any two points
  * - Width: the smallest distance between two parallel lines enclosing the polygon
  * - Minimum-area bounding rectangle: the rectangle with minimal area that encloses all points
- * 
+ *
  * Time complexity: O(n) where n is the number of vertices in the convex polygon
- * 
+ *
  * Reference: Shamos, M. I. (1978). Computational Geometry.
- * 
+ *
  * @author TheAlgorithms
  */
 public final class RotatingCalipers {
-    
+
     private RotatingCalipers() {
         // Utility class
     }
-    
+
     /**
      * Represents a pair of points.
      */
     public static final class PointPair {
         public final Point first;
         public final Point second;
         public final double distance;
-        
+
         public PointPair(Point first, Point second) {
             this.first = first;
             this.second = second;
             this.distance = euclideanDistance(first, second);
         }
-        
+
         @Override
         public String toString() {
             return String.format("PointPair{%s, %s, distance=%.2f}", first, second, distance);
         }
     }
-    
+
     /**
      * Represents a rectangle defined by four points.
      */
     public static final class Rectangle {
         public final Point[] vertices;
         public final double area;
-        
+
         public Rectangle(Point[] vertices) {
             this.vertices = vertices.clone();
             this.area = calculateArea(vertices);
         }
-        
+
         private static double calculateArea(Point[] vertices) {
-            if (vertices.length != 4) return 0;
+            if (vertices.length != 4) {
+                return 0;
+            }
             double width = euclideanDistance(vertices[0], vertices[1]);
             double height = euclideanDistance(vertices[1], vertices[2]);
             return width * height;
         }
-        
+
         @Override
         public String toString() {
             return String.format("Rectangle{area=%.2f}", area);
@@ -71,7 +73,7 @@ public String toString() {
     /**
      * Computes the diameter of a convex polygon using rotating calipers.
      * The diameter is the maximum distance between any two vertices.
-     * 
+     *
      * @param convexHull List of points representing the convex hull in counter-clockwise order
      * @return PointPair containing the two points that form the diameter
      * @throws IllegalArgumentException if the hull has fewer than 2 points
@@ -80,14 +82,14 @@ public static PointPair diameter(List<Point> convexHull) {
         if (convexHull.size() < 2) {
             throw new IllegalArgumentException("Convex hull must have at least 2 points");
         }
-        
+
         if (convexHull.size() == 2) {
             return new PointPair(convexHull.get(0), convexHull.get(1));
         }
-        
+
         // Find maximum distance between all pairs of points
         PointPair maxPair = new PointPair(convexHull.get(0), convexHull.get(1));
-        
+
         for (int i = 0; i < convexHull.size(); i++) {
             for (int j = i + 1; j < convexHull.size(); j++) {
                 PointPair candidate = new PointPair(convexHull.get(i), convexHull.get(j));
@@ -96,14 +98,14 @@ public static PointPair diameter(List<Point> convexHull) {
                 }
             }
         }
-        
+
         return maxPair;
     }
 
     /**
      * Computes the width of a convex polygon using rotating calipers.
      * The width is the minimum distance between two parallel supporting lines.
-     * 
+     *
      * @param convexHull List of points representing the convex hull in counter-clockwise order
      * @return The minimum width of the polygon
      * @throws IllegalArgumentException if the hull has fewer than 3 points
@@ -112,15 +114,15 @@ public static double width(List<Point> convexHull) {
         if (convexHull.size() < 3) {
             throw new IllegalArgumentException("Convex hull must have at least 3 points for width calculation");
         }
-        
+
         int n = convexHull.size();
         double minWidth = Double.MAX_VALUE;
-        
+
         int j = 1;
         for (int i = 0; i < n; i++) {
             Point p1 = convexHull.get(i);
             Point p2 = convexHull.get((i + 1) % n);
-            
+
             // Find the farthest point from edge p1-p2
             while (true) {
                 int nextJ = (j + 1) % n;
@@ -130,17 +132,17 @@ public static double width(List<Point> convexHull) {
                     break;
                 }
             }
-            
+
             double currentWidth = distanceToLine(p1, p2, convexHull.get(j));
             minWidth = Math.min(minWidth, currentWidth);
         }
-        
+
         return minWidth;
     }
 
     /**
      * Computes the minimum-area bounding rectangle of a convex polygon.
-     * 
+     *
      * @param convexHull List of points representing the convex hull in counter-clockwise order
      * @return Rectangle with minimum area that encloses all points
      * @throws IllegalArgumentException if the hull has fewer than 3 points
@@ -149,24 +151,24 @@ public static Rectangle minimumBoundingRectangle(List<Point> convexHull) {
         if (convexHull.size() < 3) {
             throw new IllegalArgumentException("Convex hull must have at least 3 points");
         }
-        
+
         int n = convexHull.size();
         Rectangle minRect = null;
         double minArea = Double.MAX_VALUE;
-        
+
         for (int i = 0; i < n; i++) {
             Point p1 = convexHull.get(i);
             Point p2 = convexHull.get((i + 1) % n);
-            
+
             // Create rectangle aligned with edge p1-p2
             Rectangle rect = createAlignedRectangle(convexHull, p1, p2);
-            
+
             if (rect.area < minArea) {
                 minArea = rect.area;
                 minRect = rect;
             }
         }
-        
+
         return minRect;
     }
 
@@ -178,40 +180,43 @@ private static Rectangle createAlignedRectangle(List<Point> points, Point p1, Po
         double dx = p2.x() - p1.x();
         double dy = p2.y() - p1.y();
         double length = Math.sqrt(dx * dx + dy * dy);
-        
+
         if (length == 0) {
             // Degenerate case
             return new Rectangle(new Point[]{p1, p1, p1, p1});
         }
-        
+
         // Unit vectors
         double ux = dx / length;
         double uy = dy / length;
         double vx = -uy;  // Perpendicular vector
         double vy = ux;
-        
-        double minU = 0, maxU = 0, minV = 0, maxV = 0;
-        
+
+        double minU = 0;
+        double maxU = 0;
+        double minV = 0;
+        double maxV = 0;
+
         for (Point p : points) {
             double u = (p.x() - p1.x()) * ux + (p.y() - p1.y()) * uy;
             double v = (p.x() - p1.x()) * vx + (p.y() - p1.y()) * vy;
-            
+
             minU = Math.min(minU, u);
             maxU = Math.max(maxU, u);
             minV = Math.min(minV, v);
             maxV = Math.max(maxV, v);
         }
-        
+
         // Calculate rectangle corners
         Point[] corners = new Point[4];
         corners[0] = new Point((int) Math.round(p1.x() + minU * ux + minV * vx), (int) Math.round(p1.y() + minU * uy + minV * vy));
         corners[1] = new Point((int) Math.round(p1.x() + maxU * ux + minV * vx), (int) Math.round(p1.y() + maxU * uy + minV * vy));
         corners[2] = new Point((int) Math.round(p1.x() + maxU * ux + maxV * vx), (int) Math.round(p1.y() + maxU * uy + maxV * vy));
         corners[3] = new Point((int) Math.round(p1.x() + minU * ux + maxV * vx), (int) Math.round(p1.y() + minU * uy + maxV * vy));
-        
+
         return new Rectangle(corners);
     }
-    
+
     /**
      * Calculates the Euclidean distance between two points.
      */
@@ -220,21 +225,21 @@ private static double euclideanDistance(Point p1, Point p2) {
         double dy = p1.y() - p2.y();
         return Math.sqrt(dx * dx + dy * dy);
     }
-    
+
     /**
      * Calculates the perpendicular distance from a point to a line defined by two points.
      */
     private static double distanceToLine(Point lineStart, Point lineEnd, Point point) {
         double dx = lineEnd.x() - lineStart.x();
         double dy = lineEnd.y() - lineStart.y();
-        
+
         if (dx == 0 && dy == 0) {
             return euclideanDistance(lineStart, point);
         }
-        
+
         double numerator = Math.abs(dy * point.x() - dx * point.y() + lineEnd.x() * lineStart.y() - lineEnd.y() * lineStart.x());
         double denominator = Math.sqrt(dx * dx + dy * dy);
-        
+
         return numerator / denominator;
     }
-}
+}

src/test/java/com/thealgorithms/geometry/RotatingCalipersTest.java

@@ -19,7 +19,7 @@ void testDiameterSimpleTriangle() {
             new Point(3, 4),
             new Point(0, 4)
         );
-        
+
         RotatingCalipers.PointPair diameter = RotatingCalipers.diameter(triangle);
         assertEquals(5.0, diameter.distance, EPSILON);
     }
@@ -32,7 +32,7 @@ void testDiameterSquare() {
             new Point(2, 2),
             new Point(0, 2)
         );
-        
+
         RotatingCalipers.PointPair diameter = RotatingCalipers.diameter(square);
         assertEquals(Math.sqrt(8), diameter.distance, EPSILON);
     }
@@ -43,7 +43,7 @@ void testDiameterTwoPoints() {
             new Point(0, 0),
             new Point(3, 4)
         );
-        
+
         RotatingCalipers.PointPair diameter = RotatingCalipers.diameter(twoPoints);
         assertEquals(5.0, diameter.distance, EPSILON);
     }
@@ -61,7 +61,7 @@ void testWidthTriangle() {
             new Point(4, 0),
             new Point(2, 3)
         );
-        
+
         double width = RotatingCalipers.width(triangle);
         assertTrue(width > 0);
         assertTrue(width <= 4.0); // Width should be less than or equal to base
@@ -75,7 +75,7 @@ void testWidthSquare() {
             new Point(2, 2),
             new Point(0, 2)
         );
-        
+
         double width = RotatingCalipers.width(square);
         assertEquals(2.0, width, EPSILON);
     }
@@ -96,7 +96,7 @@ void testMinimumBoundingRectangleTriangle() {
             new Point(4, 0),
             new Point(2, 3)
         );
-        
+
         RotatingCalipers.Rectangle rect = RotatingCalipers.minimumBoundingRectangle(triangle);
         assertTrue(rect.area > 0);
         assertTrue(rect.area <= 12.0); // Should be less than axis-aligned bounding box
@@ -110,7 +110,7 @@ void testMinimumBoundingRectangleSquare() {
             new Point(2, 2),
             new Point(0, 2)
         );
-        
+
         RotatingCalipers.Rectangle rect = RotatingCalipers.minimumBoundingRectangle(square);
         assertEquals(4.0, rect.area, EPSILON);
     }
@@ -135,13 +135,13 @@ void testComplexPolygon() {
             new Point(0, 3),
             new Point(0, 1)
         );
-        
+
         RotatingCalipers.PointPair diameter = RotatingCalipers.diameter(hexagon);
         assertTrue(diameter.distance > 0);
-        
+
         double width = RotatingCalipers.width(hexagon);
         assertTrue(width > 0);
-        
+
         RotatingCalipers.Rectangle rect = RotatingCalipers.minimumBoundingRectangle(hexagon);
         assertTrue(rect.area > 0);
     }
@@ -151,7 +151,7 @@ void testPointPairToString() {
         Point p1 = new Point(0, 0);
         Point p2 = new Point(3, 4);
         RotatingCalipers.PointPair pair = new RotatingCalipers.PointPair(p1, p2);
-        
+
         String expected = "PointPair{(0, 0), (3, 4), distance=5.00}";
         assertEquals(expected, pair.toString());
     }
@@ -165,7 +165,7 @@ void testRectangleToString() {
             new Point(0, 2)
         };
         RotatingCalipers.Rectangle rect = new RotatingCalipers.Rectangle(vertices);
-        
+
         assertTrue(rect.toString().contains("Rectangle{area="));
     }
 
@@ -183,7 +183,7 @@ void testDegenerateCase() {
             new Point(1, 1),
             new Point(1, 1)
         );
-        
+
         RotatingCalipers.Rectangle rect = RotatingCalipers.minimumBoundingRectangle(samePoints);
         assertEquals(0.0, rect.area, EPSILON);
     }