Merge branch 'master' into kruskal-mst

Author: anandraj095

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

@@ -0,0 +1,48 @@
+package com.thealgorithms.maths;
+
+/**
+ * In mathematics, the extended Euclidean algorithm is an extension to the
+ * Euclidean algorithm, and computes, in addition to the greatest common divisor
+ * (gcd) of integers a and b, also the coefficients of Bézout's identity, which
+ * are integers x and y such that ax + by = gcd(a, b).
+ *
+ * <p>
+ * For more details, see
+ * https://en.wikipedia.org/wiki/Extended_Euclidean_algorithm
+ */
+public final class ExtendedEuclideanAlgorithm {
+
+    private ExtendedEuclideanAlgorithm() {
+    }
+
+    /**
+     * This method implements the extended Euclidean algorithm.
+     *
+     * @param a The first number.
+     * @param b The second number.
+     * @return An array of three integers:
+     *         <ul>
+     *         <li>Index 0: The greatest common divisor (gcd) of a and b.</li>
+     *         <li>Index 1: The value of x in the equation ax + by = gcd(a, b).</li>
+     *         <li>Index 2: The value of y in the equation ax + by = gcd(a, b).</li>
+     *         </ul>
+     */
+    public static long[] extendedGCD(long a, long b) {
+        if (b == 0) {
+            // Base case: gcd(a, 0) = a. The equation is a*1 + 0*0 = a.
+            return new long[] {a, 1, 0};
+        }
+
+        // Recursive call
+        long[] result = extendedGCD(b, a % b);
+        long gcd = result[0];
+        long x1 = result[1];
+        long y1 = result[2];
+
+        // Update coefficients using the results from the recursive call
+        long x = y1;
+        long y = x1 - a / b * y1;
+
+        return new long[] {gcd, x, y};
+    }
+}

src/main/java/com/thealgorithms/physics/ThinLens.java

@@ -0,0 +1,74 @@
+package com.thealgorithms.physics;
+
+/**
+ * Implements the Thin Lens Formula used in ray optics:
+ *
+ * <pre>
+ *     1/f = 1/v + 1/u
+ * </pre>
+ *
+ * where:
+ * <ul>
+ *   <li>f = focal length</li>
+ *   <li>u = object distance</li>
+ *   <li>v = image distance</li>
+ * </ul>
+ *
+ * Uses the Cartesian sign convention.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Thin_lens">Thin Lens</a>
+ */
+public final class ThinLens {
+
+    private ThinLens() {
+        throw new AssertionError("No instances.");
+    }
+
+    /**
+     * Computes the image distance using the thin lens formula.
+     *
+     * @param focalLength focal length of the lens (f)
+     * @param objectDistance object distance (u)
+     * @return image distance (v)
+     * @throws IllegalArgumentException if focal length or object distance is zero
+     */
+    public static double imageDistance(double focalLength, double objectDistance) {
+
+        if (focalLength == 0 || objectDistance == 0) {
+            throw new IllegalArgumentException("Focal length and object distance must be non-zero.");
+        }
+
+        return 1.0 / ((1.0 / focalLength) - (1.0 / objectDistance));
+    }
+
+    /**
+     * Computes magnification of the image.
+     *
+     * <pre>
+     *     m = v / u
+     * </pre>
+     *
+     * @param imageDistance image distance (v)
+     * @param objectDistance object distance (u)
+     * @return magnification
+     * @throws IllegalArgumentException if object distance is zero
+     */
+    public static double magnification(double imageDistance, double objectDistance) {
+
+        if (objectDistance == 0) {
+            throw new IllegalArgumentException("Object distance must be non-zero.");
+        }
+
+        return imageDistance / objectDistance;
+    }
+
+    /**
+     * Determines whether the image formed is real or virtual.
+     *
+     * @param imageDistance image distance (v)
+     * @return {@code true} if image is real, {@code false} if virtual
+     */
+    public static boolean isRealImage(double imageDistance) {
+        return imageDistance > 0;
+    }
+}

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

@@ -12,10 +12,12 @@ private FibonacciSeries() {
         throw new UnsupportedOperationException("Utility class");
     }
     public static int fibonacci(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("n must be a non-negative integer");
+        }
         if (n <= 1) {
             return n;
-        } else {
-            return fibonacci(n - 1) + fibonacci(n - 2);
         }
+        return fibonacci(n - 1) + fibonacci(n - 2);
     }
 }

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

@@ -0,0 +1,47 @@
+package com.thealgorithms.maths;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+public class ExtendedEuclideanAlgorithmTest {
+
+    /**
+     * Verifies that the returned values satisfy Bézout's identity: a*x + b*y =
+     * gcd(a, b)
+     */
+    private void verifyBezoutIdentity(long a, long b, long[] result) {
+        long gcd = result[0];
+        long x = result[1];
+        long y = result[2];
+        assertEquals(a * x + b * y, gcd, "Bézout's identity failed for gcd(" + a + ", " + b + ")");
+    }
+
+    @Test
+    public void testExtendedGCD() {
+        // Test case 1: General case gcd(30, 50) = 10
+        long[] result1 = ExtendedEuclideanAlgorithm.extendedGCD(30, 50);
+        assertEquals(10, result1[0], "Test Case 1 Failed: gcd(30, 50) should be 10");
+        verifyBezoutIdentity(30, 50, result1);
+
+        // Test case 2: Another general case gcd(240, 46) = 2
+        long[] result2 = ExtendedEuclideanAlgorithm.extendedGCD(240, 46);
+        assertEquals(2, result2[0], "Test Case 2 Failed: gcd(240, 46) should be 2");
+        verifyBezoutIdentity(240, 46, result2);
+
+        // Test case 3: Base case where b is 0, gcd(10, 0) = 10
+        long[] result3 = ExtendedEuclideanAlgorithm.extendedGCD(10, 0);
+        assertEquals(10, result3[0], "Test Case 3 Failed: gcd(10, 0) should be 10");
+        verifyBezoutIdentity(10, 0, result3);
+
+        // Test case 4: Numbers are co-prime gcd(17, 13) = 1
+        long[] result4 = ExtendedEuclideanAlgorithm.extendedGCD(17, 13);
+        assertEquals(1, result4[0], "Test Case 4 Failed: gcd(17, 13) should be 1");
+        verifyBezoutIdentity(17, 13, result4);
+
+        // Test case 5: One number is a multiple of the other gcd(100, 20) = 20
+        long[] result5 = ExtendedEuclideanAlgorithm.extendedGCD(100, 20);
+        assertEquals(20, result5[0], "Test Case 5 Failed: gcd(100, 20) should be 20");
+        verifyBezoutIdentity(100, 20, result5);
+    }
+}

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

@@ -6,57 +6,77 @@
 public class GCDTest {
 
     @Test
-    void test1() {
+    void testNegativeAndZeroThrowsException() {
         Assertions.assertThrows(ArithmeticException.class, () -> GCD.gcd(-1, 0));
     }
 
     @Test
-    void test2() {
+    void testPositiveAndNegativeThrowsException() {
         Assertions.assertThrows(ArithmeticException.class, () -> GCD.gcd(10, -2));
     }
 
     @Test
-    void test3() {
+    void testBothNegativeThrowsException() {
         Assertions.assertThrows(ArithmeticException.class, () -> GCD.gcd(-5, -3));
     }
 
     @Test
-    void test4() {
-        Assertions.assertEquals(GCD.gcd(0, 2), 2);
+    void testZeroAndPositiveReturnsPositive() {
+        Assertions.assertEquals(2, GCD.gcd(0, 2));
     }
 
     @Test
-    void test5() {
-        Assertions.assertEquals(GCD.gcd(10, 0), 10);
+    void testPositiveAndZeroReturnsPositive() {
+        Assertions.assertEquals(10, GCD.gcd(10, 0));
     }
 
     @Test
-    void test6() {
-        Assertions.assertEquals(GCD.gcd(1, 0), 1);
+    void testOneAndZeroReturnsOne() {
+        Assertions.assertEquals(1, GCD.gcd(1, 0));
     }
 
     @Test
-    void test7() {
-        Assertions.assertEquals(GCD.gcd(9, 6), 3);
+    void testTwoPositiveNumbers() {
+        Assertions.assertEquals(3, GCD.gcd(9, 6));
     }
 
     @Test
-    void test8() {
-        Assertions.assertEquals(GCD.gcd(48, 18, 30, 12), 6);
+    void testMultipleArgumentsGcd() {
+        Assertions.assertEquals(6, GCD.gcd(48, 18, 30, 12));
     }
 
     @Test
-    void testArrayGcd1() {
-        Assertions.assertEquals(GCD.gcd(new int[] {9, 6}), 3);
+    void testArrayInputGcd() {
+        Assertions.assertEquals(3, GCD.gcd(new int[] {9, 6}));
     }
 
     @Test
-    void testArrayGcd2() {
-        Assertions.assertEquals(GCD.gcd(new int[] {2 * 3 * 5 * 7, 2 * 5 * 5 * 5, 2 * 5 * 11, 5 * 5 * 5 * 13}), 5);
+    void testArrayWithCommonFactor() {
+        Assertions.assertEquals(5, GCD.gcd(new int[] {2 * 3 * 5 * 7, 2 * 5 * 5 * 5, 2 * 5 * 11, 5 * 5 * 5 * 13}));
     }
 
     @Test
-    void testArrayGcdForEmptyInput() {
-        Assertions.assertEquals(GCD.gcd(new int[] {}), 0);
+    void testEmptyArrayReturnsZero() {
+        Assertions.assertEquals(0, GCD.gcd(new int[] {}));
+    }
+
+    @Test
+    void testSameNumbers() {
+        Assertions.assertEquals(7, GCD.gcd(7, 7));
+    }
+
+    @Test
+    void testPrimeNumbersHaveGcdOne() {
+        Assertions.assertEquals(1, GCD.gcd(13, 17));
+    }
+
+    @Test
+    void testSingleElementArrayReturnsElement() {
+        Assertions.assertEquals(42, GCD.gcd(new int[] {42}));
+    }
+
+    @Test
+    void testLargeNumbers() {
+        Assertions.assertEquals(12, GCD.gcd(123456, 789012));
     }
 }

src/test/java/com/thealgorithms/physics/ThinLensTest.java

@@ -0,0 +1,19 @@
+package com.thealgorithms.physics;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import org.junit.jupiter.api.Test;
+
+class ThinLensTest {
+
+    @Test
+    void testConvexLensRealImage() {
+        double v = ThinLens.imageDistance(10, 20);
+        assertEquals(20, v, 1e-6);
+    }
+
+    @Test
+    void testMagnification() {
+        assertEquals(2.0, ThinLens.magnification(20, 10), 1e-6);
+    }
+}