Dev: Added Germain and Safe prime utility class (#6611)

* feat: add Germain and Safe prime utility class with unit tests

* refactor the code

* fixed identified bugs

* fixed identified remaining bugs

---------

Co-authored-by: Deniz Altunkapan <93663085+DenizAltunkapan@users.noreply.github.com>

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

@@ -0,0 +1,63 @@
+package com.thealgorithms.maths;
+
+import com.thealgorithms.maths.Prime.PrimeCheck;
+
+/**
+ * A utility class to check whether a number is a Germain prime or a Safe prime.
+ *
+ * <p>This class provides methods to:
+ * <ul>
+ *   <li>Check if a number is a Germain prime</li>
+ *   <li>Check if a number is a Safe prime</li>
+ * </ul>
+ *
+ * <p>Definitions:
+ * <ul>
+ *   <li>A Germain prime is a prime number p such that 2p + 1 is also prime.</li>
+ *   <li>A Safe prime is a prime number p such that (p - 1) / 2 is also prime.</li>
+ * </ul>
+ *
+ * <p>This class is final and cannot be instantiated.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Safe_and_Sophie_Germain_primes">Wikipedia: Safe and Sophie Germain primes</a>
+ */
+public final class GermainPrimeAndSafePrime {
+
+    // Private constructor to prevent instantiation
+    private GermainPrimeAndSafePrime() {
+    }
+
+    /**
+     * Checks if a number is a Germain prime.
+     *
+     * <p>A Germain prime is a prime number p such that 2p + 1 is also prime.
+     *
+     * @param number the number to check; must be a positive integer
+     * @return {@code true} if the number is a Germain prime, {@code false} otherwise
+     * @throws IllegalArgumentException if the input number is less than 1
+     */
+    public static boolean isGermainPrime(int number) {
+        if (number < 1) {
+            throw new IllegalArgumentException("Input value must be a positive integer. Input value: " + number);
+        }
+        // A number is a Germain prime if it is prime and 2 * number + 1 is also prime
+        return PrimeCheck.isPrime(number) && PrimeCheck.isPrime(2 * number + 1);
+    }
+
+    /**
+     * Checks if a number is a Safe prime.
+     *
+     * <p>A Safe prime is a prime number p such that (p - 1) / 2 is also prime.
+     *
+     * @param number the number to check; must be a positive integer
+     * @return {@code true} if the number is a Safe prime, {@code false} otherwise
+     * @throws IllegalArgumentException if the input number is less than 1
+     */
+    public static boolean isSafePrime(int number) {
+        if (number < 1) {
+            throw new IllegalArgumentException("Input value must be a positive integer. Input value: " + number);
+        }
+        // A number is a Safe prime if it is prime, (number - 1) is even, and (number - 1) / 2 is prime
+        return ((number - 1) % 2 == 0) && PrimeCheck.isPrime(number) && PrimeCheck.isPrime((number - 1) / 2);
+    }
+}

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

@@ -0,0 +1,49 @@
+package com.thealgorithms.maths;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+class GermainPrimeAndSafePrimeTest {
+
+    static Stream<Arguments> provideNumbersForGermainPrimes() {
+        return Stream.of(Arguments.of(2, Boolean.TRUE), Arguments.of(3, Boolean.TRUE), Arguments.of(5, Boolean.TRUE), Arguments.of(11, Boolean.TRUE), Arguments.of(23, Boolean.TRUE), Arguments.of(293, Boolean.TRUE), Arguments.of(4, Boolean.FALSE), Arguments.of(7, Boolean.FALSE),
+            Arguments.of(9, Boolean.FALSE), Arguments.of(1, Boolean.FALSE));
+    }
+
+    static Stream<Arguments> provideNumbersForSafePrimes() {
+        return Stream.of(Arguments.of(5, Boolean.TRUE), Arguments.of(7, Boolean.TRUE), Arguments.of(11, Boolean.TRUE), Arguments.of(23, Boolean.TRUE), Arguments.of(1283, Boolean.TRUE), Arguments.of(4, Boolean.FALSE), Arguments.of(13, Boolean.FALSE), Arguments.of(9, Boolean.FALSE),
+            Arguments.of(1, Boolean.FALSE));
+    }
+
+    static Stream<Integer> provideNegativeNumbers() {
+        return Stream.of(-10, -1, 0);
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideNumbersForGermainPrimes")
+    @DisplayName("Check whether a number is a Germain prime")
+    void testValidGermainPrimes(int number, boolean expected) {
+        assertEquals(expected, GermainPrimeAndSafePrime.isGermainPrime(number));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideNumbersForSafePrimes")
+    @DisplayName("Check whether a number is a Safe prime")
+    void testValidSafePrimes(int number, boolean expected) {
+        assertEquals(expected, GermainPrimeAndSafePrime.isSafePrime(number));
+    }
+
+    @ParameterizedTest
+    @MethodSource("provideNegativeNumbers")
+    @DisplayName("Negative numbers and zero should throw IllegalArgumentException")
+    void testNegativeNumbersThrowException(int number) {
+        assertThrows(IllegalArgumentException.class, () -> GermainPrimeAndSafePrime.isGermainPrime(number));
+        assertThrows(IllegalArgumentException.class, () -> GermainPrimeAndSafePrime.isSafePrime(number));
+    }
+}