Fix checkstyle issues

Author: poorva0405

src/main/java/com/thealgorithms/machinelearning/KNearestNeighbors.java

@@ -9,15 +9,17 @@
 /**
  * K-Nearest Neighbors (KNN) classifier.
  *
- * <p>K-Nearest Neighbors is a supervised machine learning algorithm that
+ * <p>
+ * K-Nearest Neighbors is a supervised machine learning algorithm that
  * classifies a sample based on the majority class among its {@code k}
  * nearest training samples using the Euclidean distance metric.
  *
- * <p>The classifier stores the training dataset during the fitting phase and
+ * <p>
+ * The classifier stores the training dataset during the fitting phase and
  * predicts class labels for new samples without building an explicit model.
  *
  * @see <a href="https://en.wikipedia.org/wiki/K-nearest_neighbors_algorithm">
- * K-Nearest Neighbors</a>
+ *      K-Nearest Neighbors</a>
  */
 public final class KNearestNeighbors {
     private final int k;
@@ -38,7 +40,8 @@ public KNearestNeighbors(int k) {
     }
 
     /**
-     * Represents a neighboring training sample and its distance from the test sample.
+     * Represents a neighboring training sample and its distance from the test
+     * sample.
      */
     private static final class Neighbor {
 
@@ -59,11 +62,12 @@ private static final class Neighbor {
     /**
      * Fits the classifier using the provided training dataset.
      *
-     * <p>The training feature vectors and their corresponding class labels are
+     * <p>
+     * The training feature vectors and their corresponding class labels are
      * stored for use during prediction.
      *
      * @param features the training feature vectors
-     * @param labels the corresponding class labels
+     * @param labels   the corresponding class labels
      */
     public void fit(double[][] features, int[] labels) {
 
@@ -106,7 +110,7 @@ public void fit(double[][] features, int[] labels) {
     /**
      * Computes the Euclidean distance between two feature vectors.
      *
-     * @param first the first feature vector
+     * @param first  the first feature vector
      * @param second the second feature vector
      * @return the Euclidean distance between the two vectors
      */
@@ -124,7 +128,8 @@ private static double euclideanDistance(double[] first, double[] second) {
     /**
      * Predicts the class label for a single sample.
      *
-     * <p>The prediction is made by finding the {@code k} nearest neighbors
+     * <p>
+     * The prediction is made by finding the {@code k} nearest neighbors
      * among the training samples and selecting the class with the highest
      * number of votes. In the event of a tie, the smaller class label is
      * returned.
@@ -137,7 +142,7 @@ public int predict(double[] testPoint) {
             throw new IllegalStateException("Classifier has not been fitted.");
         }
 
-        if(testPoint == null) {
+        if (testPoint == null) {
             throw new IllegalArgumentException("Sample cannot be null.");
         }
 
@@ -151,19 +156,18 @@ public int predict(double[] testPoint) {
             double distance = euclideanDistance(trainingFeatures[i], testPoint);
             neighbors.add(new Neighbor(distance, trainingLabels[i]));
         }
-    
 
         neighbors.sort(Comparator.comparingDouble(neighbor -> neighbor.distance));
 
-        Map<Integer, Integer> votes = new HashMap<>(); 
+        Map<Integer, Integer> votes = new HashMap<>();
 
         if (k > trainingFeatures.length) {
             throw new IllegalArgumentException("k cannot be greater than the number of training samples.");
         }
 
-        for (int i = 0; i < k; i++) { 
-            int label = neighbors.get(i).label; 
-            votes.merge(label, 1, Integer::sum); 
+        for (int i = 0; i < k; i++) {
+            int label = neighbors.get(i).label;
+            votes.merge(label, 1, Integer::sum);
         }
 
         int predictedLabel = -1;
@@ -182,7 +186,6 @@ public int predict(double[] testPoint) {
         return predictedLabel;
     }
 
-
     /**
      * Predicts class labels for multiple samples.
      *

src/test/java/com/thealgorithms/machinelearning/KNearestNeighborsTest.java

@@ -6,73 +6,73 @@
 
 import org.junit.jupiter.api.Test;
 
-public class KNearestNeighborsTest {
-    
+class KNearestNeighborsTest {
+
     @Test
     void predictsCorrectClassOnSeparableDataset() {
         double[][] features = {
-            {0, 0},
-            {1, 1},
-            {8, 8},
-            {9, 9},
+                { 0, 0 },
+                { 1, 1 },
+                { 8, 8 },
+                { 9, 9 },
         };
 
-        int[] labels = {0, 0, 1, 1};
+        int[] labels = { 0, 0, 1, 1 };
 
         KNearestNeighbors knn = new KNearestNeighbors(3);
         knn.fit(features, labels);
 
-        assertEquals(0, knn.predict(new double[] {1.5, 1.5}));
-        assertEquals(1, knn.predict(new double[] {8.5, 8.5}));
+        assertEquals(0, knn.predict(new double[] { 1.5, 1.5 }));
+        assertEquals(1, knn.predict(new double[] { 8.5, 8.5 }));
     }
 
     @Test
     void predictsBatchClassesOnSeparableDataset() {
         double[][] features = {
-            {0, 0},
-            {1, 1},
-            {8, 8},
-            {9, 9},
+                { 0, 0 },
+                { 1, 1 },
+                { 8, 8 },
+                { 9, 9 },
         };
 
-        int[] labels = {0, 0, 1, 1};
+        int[] labels = { 0, 0, 1, 1 };
 
         KNearestNeighbors knn = new KNearestNeighbors(3);
         knn.fit(features, labels);
 
-        double[][] samples = {{1.5, 1.5}, {8.5, 8.5}};
+        double[][] samples = { { 1.5, 1.5 }, { 8.5, 8.5 } };
         int[] predictions = knn.predict(samples);
 
-        assertArrayEquals(new int[] {0, 1}, predictions);
+        assertArrayEquals(new int[] { 0, 1 }, predictions);
     }
 
     @Test
-    void throwsExceptionWhenKIsNotPositive() { 
+    void throwsExceptionWhenKIsNotPositive() {
         assertThrows(IllegalArgumentException.class, () -> new KNearestNeighbors(-4));
         assertThrows(IllegalArgumentException.class, () -> new KNearestNeighbors(0));
     }
 
     @Test
     void throwsExceptionWhenKIsGreaterThanNumberOfTrainingSamples() {
         double[][] features = {
-            {0, 0},
-            {1, 1},
-            {8, 8},
-            {9, 9},
+                { 0, 0 },
+                { 1, 1 },
+                { 8, 8 },
+                { 9, 9 },
         };
 
-        int[] labels = {0, 0, 1, 1};
+        int[] labels = { 0, 0, 1, 1 };
         KNearestNeighbors knn = new KNearestNeighbors(7);
         knn.fit(features, labels);
 
-        assertThrows(IllegalArgumentException.class, () -> knn.predict(new double[] {1.5, 1.5}));
+        assertThrows(IllegalArgumentException.class, () -> knn.predict(new double[] { 1.5, 1.5 }));
     }
 
     @Test
     void nullFeaturesArrayThrowsIllegalArgumentException() {
         KNearestNeighbors knn = new KNearestNeighbors(1);
-        
-        assertThrows(IllegalArgumentException.class, () -> knn.fit(null, new int[] {0, 1}));
+
+        assertThrows(IllegalArgumentException.class, () -> knn.fit(null, new int[] { 0, 1 }));
     }
 
     @Test
@@ -85,62 +85,66 @@ void emptyFeaturesArrayThrowsIllegalArgumentException() {
     @Test
     void nullLabelsArrayThrowsIllegalArgumentException() {
         KNearestNeighbors knn = new KNearestNeighbors(1);
-        
-        assertThrows(IllegalArgumentException.class, () -> knn.fit(new double[][] {{1, 1}, {2, 2}}, null));
+
+        assertThrows(IllegalArgumentException.class, () -> knn.fit(new double[][] { { 1, 1 }, { 2, 2 } }, null));
     }
 
     @Test
     void emptyLabelsArrayThrowsIllegalArgumentException() {
         KNearestNeighbors knn = new KNearestNeighbors(1);
-        
-        assertThrows(IllegalArgumentException.class, () -> knn.fit(new double[][] {{1, 1}, {2, 2}}, new int[] {}));
+
+        assertThrows(IllegalArgumentException.class,
+                () -> knn.fit(new double[][] { { 1, 1 }, { 2, 2 } }, new int[] {}));
     }
 
     @Test
     void mismatchedFeatureAndLabelLengthsThrowsIllegalArgumentException() {
         KNearestNeighbors knn = new KNearestNeighbors(3);
-        
-        assertThrows(IllegalArgumentException.class, () -> knn.fit(new double[][] {{0, 0}, {1, 1}, {8, 8}, {9, 9}}, new int[] {0, 0, 1}));
+
+        assertThrows(IllegalArgumentException.class,
+                () -> knn.fit(new double[][] { { 0, 0 }, { 1, 1 }, { 8, 8 }, { 9, 9 } }, new int[] { 0, 0, 1 }));
     }
 
     @Test
     void emptyFeatureVectorThrowsIllegalArgumentException() {
         KNearestNeighbors knn = new KNearestNeighbors(1);
 
-        assertThrows(IllegalArgumentException.class,() -> knn.fit(new double[][] {{}}, new int[] {0}));
+        assertThrows(IllegalArgumentException.class, () -> knn.fit(new double[][] { {} }, new int[] { 0 }));
     }
 
     @Test
     void nullFeatureSampleThrowsIllegalArgumentException() {
         KNearestNeighbors knn = new KNearestNeighbors(2);
-        
-        assertThrows(IllegalArgumentException.class, () -> knn.fit(new double[][] {{0, 0}, null, {8, 8}}, new int[] {0, 0, 1}));
+
+        assertThrows(IllegalArgumentException.class,
+                () -> knn.fit(new double[][] { { 0, 0 }, null, { 8, 8 } }, new int[] { 0, 0, 1 }));
     }
 
     @Test
     void mismatchedDimensionThrowsIllegalArgumentException() {
         KNearestNeighbors knn = new KNearestNeighbors(2);
-        
-        assertThrows(IllegalArgumentException.class, () -> knn.fit(new double[][] {{0, 0}, {1, 1, 2}, {8, 8}}, new int[] {0, 0, 1}));
+
+        assertThrows(IllegalArgumentException.class,
+                () -> knn.fit(new double[][] { { 0, 0 }, { 1, 1, 2 }, { 8, 8 } }, new int[] { 0, 0, 1 }));
     }
 
     @Test
     void predictBeforeFitThrowsIllegalStateException() {
         KNearestNeighbors knn = new KNearestNeighbors(3);
 
-        assertThrows(IllegalStateException.class, () -> knn.predict(new double[] {1, 1}));
+        assertThrows(IllegalStateException.class, () -> knn.predict(new double[] { 1, 1 }));
     }
 
     @Test
     void nullTestPointThrowsIllegalArgumentException() {
         double[][] features = {
-            {0, 0},
-            {1, 1},
-            {8, 8},
-            {9, 9},
+                { 0, 0 },
+                { 1, 1 },
+                { 8, 8 },
+                { 9, 9 },
         };
 
-        int[] labels = {0, 0, 1, 1};
+        int[] labels = { 0, 0, 1, 1 };
 
         KNearestNeighbors knn = new KNearestNeighbors(3);
         knn.fit(features, labels);
@@ -152,69 +156,70 @@ void nullTestPointThrowsIllegalArgumentException() {
     @Test
     void mismatchedTestPointLengthThrowsIllegalArgumentException() {
         double[][] features = {
-            {0, 0},
-            {1, 1},
-            {8, 8},
-            {9, 9},
+                { 0, 0 },
+                { 1, 1 },
+                { 8, 8 },
+                { 9, 9 },
         };
 
-        int[] labels = {0, 0, 1, 1};
+        int[] labels = { 0, 0, 1, 1 };
 
         KNearestNeighbors knn = new KNearestNeighbors(3);
         knn.fit(features, labels);
 
-        assertThrows(IllegalArgumentException.class, () -> knn.predict(new double[] {1.5, 1.5, 1.5}));
+        assertThrows(IllegalArgumentException.class, () -> knn.predict(new double[] { 1.5, 1.5, 1.5 }));
     }
 
     @Test
     void tieBreakReturnsSmallerLabel() {
         double[][] features = {
-            {0, 0},
-            {0, 2},
-            {2, 0},
-            {2, 2}
+                { 0, 0 },
+                { 0, 2 },
+                { 2, 0 },
+                { 2, 2 }
         };
 
-        int[] labels = {0, 1, 0, 1};
+        int[] labels = { 0, 1, 0, 1 };
 
         KNearestNeighbors knn = new KNearestNeighbors(4);
         knn.fit(features, labels);
 
-        assertEquals(0, knn.predict(new double[] {1, 1}));
+        assertEquals(0, knn.predict(new double[] { 1, 1 }));
     }
 
     @Test
     void nullBatchSampleThrowsIllegalArgumentException() {
         double[][] features = {
-            {0, 0},
-            {1, 1},
-            {8, 8},
-            {9, 9},
+                { 0, 0 },
+                { 1, 1 },
+                { 8, 8 },
+                { 9, 9 },
         };
 
-        int[] labels = {0, 0, 1, 1};
+        int[] labels = { 0, 0, 1, 1 };
 
         KNearestNeighbors knn = new KNearestNeighbors(3);
         knn.fit(features, labels);
 
-        assertThrows(IllegalArgumentException.class, () -> knn.predict(new double[][] {{1.5, 1.5}, null}));
+        assertThrows(IllegalArgumentException.class, () -> knn.predict(new double[][] { { 1.5, 1.5 }, null }));
     }
 
     @Test
     void invalidBatchSampleThrowsIllegalArgumentException() {
         double[][] features = {
-            {0, 0},
-            {1, 1},
-            {8, 8},
-            {9, 9},
+                { 0, 0 },
+                { 1, 1 },
+                { 8, 8 },
+                { 9, 9 },
         };
 
-        int[] labels = {0, 0, 1, 1};
+        int[] labels = { 0, 0, 1, 1 };
 
         KNearestNeighbors knn = new KNearestNeighbors(3);
         knn.fit(features, labels);
 
-        assertThrows(IllegalArgumentException.class, () -> knn.predict(new double[][] {{1.5, 1.5}, {8.5, 8.5, 8.5}}));
+        assertThrows(IllegalArgumentException.class,
+                () -> knn.predict(new double[][] { { 1.5, 1.5 }, { 8.5, 8.5, 8.5 } }));
     }
 
-}
+}