Merge branch 'master' into added-mos-algorithm-dice-thrower

Author: BEASTSHRIRAM

src/main/java/com/thealgorithms/conversions/CoordinateConverter.java

@@ -0,0 +1,57 @@
+package com.thealgorithms.conversions;
+
+/**
+ * A utility class to convert between Cartesian and Polar coordinate systems.
+ *
+ * <p>This class provides methods to perform the following conversions:
+ * <ul>
+ *   <li>Cartesian to Polar coordinates</li>
+ *   <li>Polar to Cartesian coordinates</li>
+ * </ul>
+ *
+ * <p>The class is final and cannot be instantiated.
+ */
+public final class CoordinateConverter {
+
+    private CoordinateConverter() {
+        // Prevent instantiation
+    }
+
+    /**
+     * Converts Cartesian coordinates to Polar coordinates.
+     *
+     * @param x the x-coordinate in the Cartesian system; must be a finite number
+     * @param y the y-coordinate in the Cartesian system; must be a finite number
+     * @return an array where the first element is the radius (r) and the second element is the angle (theta) in degrees
+     * @throws IllegalArgumentException if x or y is not a finite number
+     */
+    public static double[] cartesianToPolar(double x, double y) {
+        if (!Double.isFinite(x) || !Double.isFinite(y)) {
+            throw new IllegalArgumentException("x and y must be finite numbers.");
+        }
+        double r = Math.sqrt(x * x + y * y);
+        double theta = Math.toDegrees(Math.atan2(y, x));
+        return new double[] {r, theta};
+    }
+
+    /**
+     * Converts Polar coordinates to Cartesian coordinates.
+     *
+     * @param r the radius in the Polar system; must be non-negative
+     * @param thetaDegrees the angle (theta) in degrees in the Polar system; must be a finite number
+     * @return an array where the first element is the x-coordinate and the second element is the y-coordinate in the Cartesian system
+     * @throws IllegalArgumentException if r is negative or thetaDegrees is not a finite number
+     */
+    public static double[] polarToCartesian(double r, double thetaDegrees) {
+        if (r < 0) {
+            throw new IllegalArgumentException("Radius (r) must be non-negative.");
+        }
+        if (!Double.isFinite(thetaDegrees)) {
+            throw new IllegalArgumentException("Theta (angle) must be a finite number.");
+        }
+        double theta = Math.toRadians(thetaDegrees);
+        double x = r * Math.cos(theta);
+        double y = r * Math.sin(theta);
+        return new double[] {x, y};
+    }
+}

src/main/java/com/thealgorithms/dynamicprogramming/PartitionProblem.java

@@ -1,7 +1,5 @@
 package com.thealgorithms.dynamicprogramming;
-
 import java.util.Arrays;
-
 /**
  * @author Md Asif Joardar
  *

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

@@ -0,0 +1,49 @@
+package com.thealgorithms.geometry;
+/**
+ * This Class implements the Haversine formula to calculate the distance between two points on a sphere (like Earth) from their latitudes and longitudes.
+ *
+ * The Haversine formula is used in navigation and mapping to find the great-circle distance,
+ * which is the shortest distance between two points along the surface of a sphere. It is often
+ * used to calculate the "as the crow flies" distance between two geographical locations.
+ *
+ * The formula is reliable for all distances, including small ones, and avoids issues with
+ * numerical instability that can affect other methods.
+ *
+ * @see "https://en.wikipedia.org/wiki/Haversine_formula" - Wikipedia
+ */
+public final class Haversine {
+
+    // Average radius of Earth in kilometers
+    private static final double EARTH_RADIUS_KM = 6371.0;
+
+    /**
+     * Private constructor to prevent instantiation of this utility class.
+     */
+    private Haversine() {
+    }
+
+    /**
+     * Calculates the great-circle distance between two points on the earth
+     * (specified in decimal degrees).
+     *
+     * @param lat1 Latitude of the first point in decimal degrees.
+     * @param lon1 Longitude of the first point in decimal degrees.
+     * @param lat2 Latitude of the second point in decimal degrees.
+     * @param lon2 Longitude of the second point in decimal degrees.
+     * @return The distance between the two points in kilometers.
+     */
+    public static double haversine(double lat1, double lon1, double lat2, double lon2) {
+        // Convert latitude and longitude from degrees to radians
+        double dLat = Math.toRadians(lat2 - lat1);
+        double dLon = Math.toRadians(lon2 - lon1);
+
+        double lat1Rad = Math.toRadians(lat1);
+        double lat2Rad = Math.toRadians(lat2);
+
+        // Apply the Haversine formula
+        double a = Math.pow(Math.sin(dLat / 2), 2) + Math.pow(Math.sin(dLon / 2), 2) * Math.cos(lat1Rad) * Math.cos(lat2Rad);
+        double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+
+        return EARTH_RADIUS_KM * c;
+    }
+}

src/main/java/com/thealgorithms/recursion/SylvesterSequence.java

@@ -0,0 +1,50 @@
+package com.thealgorithms.recursion;
+
+import java.math.BigInteger;
+
+/**
+ * A utility class for calculating numbers in Sylvester's sequence.
+ *
+ * <p>Sylvester's sequence is a sequence of integers where each term is calculated
+ * using the formula:
+ * <pre>
+ * a(n) = a(n-1) * (a(n-1) - 1) + 1
+ * </pre>
+ * with the first term being 2.
+ *
+ * <p>This class is final and cannot be instantiated.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Sylvester_sequence">Wikipedia: Sylvester sequence</a>
+ */
+public final class SylvesterSequence {
+
+    // Private constructor to prevent instantiation
+    private SylvesterSequence() {
+    }
+
+    /**
+     * Calculates the nth number in Sylvester's sequence.
+     *
+     * <p>The sequence is defined recursively, with the first term being 2:
+     * <pre>
+     * a(1) = 2
+     * a(n) = a(n-1) * (a(n-1) - 1) + 1 for n > 1
+     * </pre>
+     *
+     * @param n the position in the sequence (must be greater than 0)
+     * @return the nth number in Sylvester's sequence
+     * @throws IllegalArgumentException if n is less than or equal to 0
+     */
+    public static BigInteger sylvester(int n) {
+        if (n <= 0) {
+            throw new IllegalArgumentException("sylvester() does not accept negative numbers or zero.");
+        }
+        if (n == 1) {
+            return BigInteger.valueOf(2);
+        } else {
+            BigInteger prev = sylvester(n - 1);
+            // Sylvester sequence formula: a(n) = a(n-1) * (a(n-1) - 1) + 1
+            return prev.multiply(prev.subtract(BigInteger.ONE)).add(BigInteger.ONE);
+        }
+    }
+}

src/test/java/com/thealgorithms/conversions/CoordinateConverterTest.java

@@ -0,0 +1,34 @@
+package com.thealgorithms.conversions;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+public class CoordinateConverterTest {
+
+    @ParameterizedTest
+    @CsvSource({"0, 0, 0, 0", "1, 0, 1, 0", "0, 1, 1, 90", "-1, 0, 1, 180", "0, -1, 1, -90", "3, 4, 5, 53.13010235415599"})
+    void testCartesianToPolar(double x, double y, double expectedR, double expectedTheta) {
+        assertArrayEquals(new double[] {expectedR, expectedTheta}, CoordinateConverter.cartesianToPolar(x, y), 1e-9);
+    }
+
+    @ParameterizedTest
+    @CsvSource({"1, 0, 1, 0", "1, 90, 0, 1", "1, 180, -1, 0", "1, -90, 0, -1", "5, 53.13010235415599, 3, 4"})
+    void testPolarToCartesian(double r, double theta, double expectedX, double expectedY) {
+        assertArrayEquals(new double[] {expectedX, expectedY}, CoordinateConverter.polarToCartesian(r, theta), 1e-9);
+    }
+
+    @ParameterizedTest
+    @CsvSource({"NaN, 1", "1, NaN", "Infinity, 1", "1, Infinity", "-Infinity, 1", "1, -Infinity"})
+    void testCartesianToPolarInvalidInputs(double x, double y) {
+        assertThrows(IllegalArgumentException.class, () -> CoordinateConverter.cartesianToPolar(x, y));
+    }
+
+    @ParameterizedTest
+    @CsvSource({"-1, 0", "1, NaN", "1, Infinity", "1, -Infinity"})
+    void testPolarToCartesianInvalidInputs(double r, double theta) {
+        assertThrows(IllegalArgumentException.class, () -> CoordinateConverter.polarToCartesian(r, theta));
+    }
+}

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

@@ -0,0 +1,60 @@
+package com.thealgorithms.geometry;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+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;
+
+/**
+ * Unit tests for the Haversine formula implementation.
+ * This class uses parameterized tests to verify the distance calculation
+ * between various geographical coordinates.
+ */
+final class HaversineTest {
+
+    // A small tolerance for comparing double values, since floating-point
+    // arithmetic is not always exact. A 1km tolerance is reasonable for these distances.
+    private static final double DELTA = 1.0;
+
+    /**
+     * Provides test cases for the haversine distance calculation.
+     * Each argument contains: lat1, lon1, lat2, lon2, and the expected distance in kilometers.
+     *
+     * @return a stream of arguments for the parameterized test.
+     */
+    static Stream<Arguments> haversineTestProvider() {
+        return Stream.of(
+            // Case 1: Distance between Paris, France and Tokyo, Japan
+            Arguments.of(48.8566, 2.3522, 35.6895, 139.6917, 9712.0),
+
+            // Case 2: Distance between New York, USA and London, UK
+            Arguments.of(40.7128, -74.0060, 51.5074, -0.1278, 5570.0),
+
+            // Case 3: Zero distance (same point)
+            Arguments.of(52.5200, 13.4050, 52.5200, 13.4050, 0.0),
+
+            // Case 4: Antipodal points (opposite sides of the Earth)
+            // Should be approximately half the Earth's circumference (PI * radius)
+            Arguments.of(0.0, 0.0, 0.0, 180.0, 20015.0));
+    }
+
+    /**
+     * Tests the haversine method with various sets of coordinates.
+     *
+     * @param lat1             Latitude of the first point.
+     * @param lon1             Longitude of the first point.
+     * @param lat2             Latitude of the second point.
+     * @param lon2             Longitude of the second point.
+     * @param expectedDistance The expected distance in kilometers.
+     */
+    @ParameterizedTest
+    @MethodSource("haversineTestProvider")
+    @DisplayName("Test Haversine distance calculation for various coordinates")
+    void testHaversine(double lat1, double lon1, double lat2, double lon2, double expectedDistance) {
+        double actualDistance = Haversine.haversine(lat1, lon1, lat2, lon2);
+        assertEquals(expectedDistance, actualDistance, DELTA);
+    }
+}

src/test/java/com/thealgorithms/recursion/SylvesterSequenceTest.java

@@ -0,0 +1,51 @@
+package com.thealgorithms.recursion;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.math.BigInteger;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+class SylvesterSequenceTest {
+
+    /**
+     * Provides test cases for valid Sylvester sequence numbers.
+     * Format: { n, expectedValue }
+     */
+    static Stream<Object[]> validSylvesterNumbers() {
+        return Stream.of(new Object[] {1, BigInteger.valueOf(2)}, new Object[] {2, BigInteger.valueOf(3)}, new Object[] {3, BigInteger.valueOf(7)}, new Object[] {4, BigInteger.valueOf(43)}, new Object[] {5, BigInteger.valueOf(1807)}, new Object[] {6, new BigInteger("3263443")},
+            new Object[] {7, new BigInteger("10650056950807")}, new Object[] {8, new BigInteger("113423713055421844361000443")});
+    }
+
+    @ParameterizedTest
+    @MethodSource("validSylvesterNumbers")
+    void testSylvesterValidNumbers(int n, BigInteger expected) {
+        assertEquals(expected, SylvesterSequence.sylvester(n), "Sylvester sequence value mismatch for n=" + n);
+    }
+
+    /**
+     * Test edge case for n <= 0 which should throw IllegalArgumentException
+     */
+    @ParameterizedTest
+    @ValueSource(ints = {0, -1, -10, -100})
+    void testSylvesterInvalidZero(int n) {
+        assertThrows(IllegalArgumentException.class, () -> SylvesterSequence.sylvester(n));
+    }
+
+    /**
+     * Test a larger number to ensure no overflow occurs.
+     */
+    @Test
+    void testSylvesterLargeNumber() {
+        int n = 10;
+        BigInteger result = SylvesterSequence.sylvester(n);
+        assertNotNull(result);
+        assertTrue(result.compareTo(BigInteger.ZERO) > 0, "Result should be positive");
+    }
+}