Merge branch 'master' into refactor/Convolution

Author: alxkm

src/main/java/com/thealgorithms/bitmanipulation/OnesComplement.java

@@ -12,15 +12,24 @@ public final class OnesComplement {
     private OnesComplement() {
     }
 
-    // Function to get the 1's complement of a binary number
+    /**
+     * Returns the 1's complement of a binary string.
+     *
+     * @param binary A string representing a binary number (e.g., "1010").
+     * @return A string representing the 1's complement.
+     * @throws IllegalArgumentException if the input is null or contains characters other than '0' or '1'.
+     */
     public static String onesComplement(String binary) {
-        StringBuilder complement = new StringBuilder();
-        // Invert each bit to get the 1's complement
-        for (int i = 0; i < binary.length(); i++) {
-            if (binary.charAt(i) == '0') {
-                complement.append('1');
-            } else {
-                complement.append('0');
+        if (binary == null || binary.isEmpty()) {
+            throw new IllegalArgumentException("Input must be a non-empty binary string.");
+        }
+
+        StringBuilder complement = new StringBuilder(binary.length());
+        for (char bit : binary.toCharArray()) {
+            switch (bit) {
+                case '0' -> complement.append('1');
+                case '1' -> complement.append('0');
+                default -> throw new IllegalArgumentException("Input must contain only '0' and '1'. Found: " + bit);
             }
         }
         return complement.toString();

src/main/java/com/thealgorithms/maths/Ceil.java

@@ -1,23 +1,34 @@
 package com.thealgorithms.maths;
 
+/**
+ * Utility class to compute the ceiling of a given number.
+ */
 public final class Ceil {
+
     private Ceil() {
     }
 
     /**
-     * Returns the smallest (closest to negative infinity)
+     * Returns the smallest double value that is greater than or equal to the input.
+     * Equivalent to mathematical ⌈x⌉ (ceiling function).
      *
-     * @param number the number
-     * @return the smallest (closest to negative infinity) of given
-     * {@code number}
+     * @param number the number to ceil
+     * @return the smallest double greater than or equal to {@code number}
      */
     public static double ceil(double number) {
-        if (number - (int) number == 0) {
+        if (Double.isNaN(number) || Double.isInfinite(number) || number == 0.0 || number < Integer.MIN_VALUE || number > Integer.MAX_VALUE) {
             return number;
-        } else if (number - (int) number > 0) {
-            return (int) (number + 1);
+        }
+
+        if (number < 0.0 && number > -1.0) {
+            return -0.0;
+        }
+
+        long intPart = (long) number;
+        if (number > 0 && number != intPart) {
+            return intPart + 1.0;
         } else {
-            return (int) number;
+            return intPart;
         }
     }
 }

src/test/java/com/thealgorithms/bitmanipulation/OnesComplementTest.java

@@ -1,8 +1,12 @@
 package com.thealgorithms.bitmanipulation;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.NullAndEmptySource;
 
 /**
  * Test case for Highest Set Bit
@@ -39,9 +43,16 @@ public void testOnesComplementMixedBits() {
         assertEquals("1001", OnesComplement.onesComplement("0110"));
     }
 
+    @ParameterizedTest
+    @NullAndEmptySource
+    public void testOnesComplementNullOrEmptyInputThrowsException(String input) {
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> OnesComplement.onesComplement(input));
+        assertEquals("Input must be a non-empty binary string.", exception.getMessage());
+    }
+
     @Test
-    public void testOnesComplementEmptyString() {
-        // Test empty string scenario
-        assertEquals("", OnesComplement.onesComplement(""));
+    public void testOnesComplementInvalidCharactersThrowsException() {
+        Exception exception = assertThrows(IllegalArgumentException.class, () -> OnesComplement.onesComplement("10a1"));
+        assertTrue(exception.getMessage().startsWith("Input must contain only '0' and '1'"));
     }
 }

src/test/java/com/thealgorithms/maths/CeilTest.java

@@ -2,16 +2,30 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 
-import org.junit.jupiter.api.Test;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.MethodSource;
 
 public class CeilTest {
 
-    @Test
-    void testCeil() {
-        assertEquals(8, Ceil.ceil(7.057));
-        assertEquals(8, Ceil.ceil(7.004));
-        assertEquals(-13, Ceil.ceil(-13.004));
-        assertEquals(1, Ceil.ceil(.98));
-        assertEquals(-11, Ceil.ceil(-11.357));
+    @ParameterizedTest
+    @CsvSource({"7.057, 8", "7.004, 8", "-13.004, -13", "0.98, 1", "-11.357, -11"})
+    void testCeil(double input, int expected) {
+        assertEquals(expected, Ceil.ceil(input));
+    }
+
+    @ParameterizedTest
+    @MethodSource("edgeCaseProvider")
+    void testEdgeCases(TestData data) {
+        assertEquals(Ceil.ceil(data.input), data.expected);
+    }
+
+    record TestData(double input, double expected) {
+    }
+
+    static Stream<TestData> edgeCaseProvider() {
+        return Stream.of(new TestData(Double.MAX_VALUE, Double.MAX_VALUE), new TestData(Double.MIN_VALUE, Math.ceil(Double.MIN_VALUE)), new TestData(0.0, Math.ceil(0.0)), new TestData(-0.0, Math.ceil(-0.0)), new TestData(Double.NaN, Math.ceil(Double.NaN)),
+            new TestData(Double.NEGATIVE_INFINITY, Math.ceil(Double.NEGATIVE_INFINITY)), new TestData(Double.POSITIVE_INFINITY, Math.ceil(Double.POSITIVE_INFINITY)));
     }
 }