diff --git a/src/main/java/com/thealgorithms/maths/FibonacciLoop.java b/src/main/java/com/thealgorithms/maths/FibonacciLoop.java
new file mode 100644
index 000000000000..de23a4305c3f
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/FibonacciLoop.java
@@ -0,0 +1,41 @@
+package com.thealgorithms.maths;
+
+import java.math.BigInteger;
+
+/**
+ * This class provides methods for calculating Fibonacci numbers using BigInteger for large values of 'n'.
+ */
+public final class FibonacciLoop {
+
+    private FibonacciLoop() {
+        // Private constructor to prevent instantiation of this utility class.
+    }
+
+    /**
+     * Calculates the nth Fibonacci number.
+     *
+     * @param n The index of the Fibonacci number to calculate.
+     * @return The nth Fibonacci number as a BigInteger.
+     * @throws IllegalArgumentException if the input 'n' is a negative integer.
+     */
+    public static BigInteger compute(final int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input 'n' must be a non-negative integer.");
+        }
+
+        if (n <= 1) {
+            return BigInteger.valueOf(n);
+        }
+
+        BigInteger prev = BigInteger.ZERO;
+        BigInteger current = BigInteger.ONE;
+
+        for (int i = 2; i <= n; i++) {
+            BigInteger next = prev.add(current);
+            prev = current;
+            current = next;
+        }
+
+        return current;
+    }
+}
diff --git a/src/main/java/com/thealgorithms/maths/FibonacciNumberGoldenRation.java b/src/main/java/com/thealgorithms/maths/FibonacciNumberGoldenRation.java
new file mode 100644
index 000000000000..4df37a40f541
--- /dev/null
+++ b/src/main/java/com/thealgorithms/maths/FibonacciNumberGoldenRation.java
@@ -0,0 +1,50 @@
+package com.thealgorithms.maths;
+
+/**
+ * This class provides methods for calculating Fibonacci numbers using Binet's formula.
+ * Binet's formula is based on the golden ratio and allows computing Fibonacci numbers efficiently.
+ *
+ * @see <a href="https://en.wikipedia.org/wiki/Fibonacci_sequence#Binet's_formula">Binet's formula on Wikipedia</a>
+ */
+public final class FibonacciNumberGoldenRation {
+    private FibonacciNumberGoldenRation() {
+        // Private constructor to prevent instantiation of this utility class.
+    }
+
+    /**
+     * Compute the limit for 'n' that fits in a long data type.
+     * Reducing the limit to 70 due to potential floating-point arithmetic errors
+     * that may result in incorrect results for larger inputs.
+     */
+    public static final int MAX_ARG = 70;
+
+    /**
+     * Calculates the nth Fibonacci number using Binet's formula.
+     *
+     * @param n The index of the Fibonacci number to calculate.
+     * @return The nth Fibonacci number as a long.
+     * @throws IllegalArgumentException if the input 'n' is negative or exceeds the range of a long data type.
+     */
+    public static long compute(int n) {
+        if (n < 0) {
+            throw new IllegalArgumentException("Input 'n' must be a non-negative integer.");
+        }
+
+        if (n > MAX_ARG) {
+            throw new IllegalArgumentException("Input 'n' is too big to give accurate result.");
+        }
+
+        if (n <= 1) {
+            return n;
+        }
+
+        // Calculate the nth Fibonacci number using the golden ratio formula
+        final double sqrt5 = Math.sqrt(5);
+        final double phi = (1 + sqrt5) / 2;
+        final double psi = (1 - sqrt5) / 2;
+        final double result = (Math.pow(phi, n) - Math.pow(psi, n)) / sqrt5;
+
+        // Round to the nearest integer and return as a long
+        return Math.round(result);
+    }
+}
diff --git a/src/test/java/com/thealgorithms/maths/FibonacciLoopTest.java b/src/test/java/com/thealgorithms/maths/FibonacciLoopTest.java
new file mode 100644
index 000000000000..93aec39765d4
--- /dev/null
+++ b/src/test/java/com/thealgorithms/maths/FibonacciLoopTest.java
@@ -0,0 +1,36 @@
+package com.thealgorithms.maths;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.math.BigInteger;
+import org.junit.jupiter.api.Test;
+
+public class FibonacciLoopTest {
+    @Test
+    public void checkValueAtZero() {
+        assertEquals(BigInteger.ZERO, FibonacciLoop.compute(0));
+    }
+
+    @Test
+    public void checkValueAtOne() {
+        assertEquals(BigInteger.ONE, FibonacciLoop.compute(1));
+    }
+
+    @Test
+    public void checkValueAtTwo() {
+        assertEquals(BigInteger.ONE, FibonacciLoop.compute(2));
+    }
+
+    @Test
+    public void checkRecurrenceRelation() {
+        for (int i = 0; i < 100; ++i) {
+            assertEquals(FibonacciLoop.compute(i + 2), FibonacciLoop.compute(i + 1).add(FibonacciLoop.compute(i)));
+        }
+    }
+
+    @Test
+    public void checkNegativeInput() {
+        assertThrows(IllegalArgumentException.class, () -> { FibonacciLoop.compute(-1); });
+    }
+}
diff --git a/src/test/java/com/thealgorithms/maths/FibonacciNumberGoldenRationTest.java b/src/test/java/com/thealgorithms/maths/FibonacciNumberGoldenRationTest.java
new file mode 100644
index 000000000000..e3f7bf3e0fed
--- /dev/null
+++ b/src/test/java/com/thealgorithms/maths/FibonacciNumberGoldenRationTest.java
@@ -0,0 +1,29 @@
+package com.thealgorithms.maths;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.math.BigInteger;
+import org.junit.jupiter.api.Test;
+
+public class FibonacciNumberGoldenRationTest {
+
+    @Test
+    public void returnsCorrectValues() {
+        for (int n = 0; n <= FibonacciNumberGoldenRation.MAX_ARG; ++n) {
+            final var actual = FibonacciNumberGoldenRation.compute(n);
+            final var expected = FibonacciLoop.compute(n);
+            assertEquals(expected, BigInteger.valueOf(actual));
+        }
+    }
+
+    @Test
+    public void throwsIllegalArgumentExceptionForNegativeInput() {
+        assertThrows(IllegalArgumentException.class, () -> { FibonacciNumberGoldenRation.compute(-1); });
+    }
+
+    @Test
+    public void throwsIllegalArgumentExceptionForLargeInput() {
+        assertThrows(IllegalArgumentException.class, () -> { FibonacciNumberGoldenRation.compute(FibonacciNumberGoldenRation.MAX_ARG + 1); });
+    }
+}