Solved issue #475

Author: Kushagra9399

oryx-build-commands.txt

@@ -0,0 +1,2 @@
+PlatformWithVersion=Python 
+BuildCommands=conda env create --file environment.yml --prefix ./venv --quiet

pydatastructs/multi_threaded_algorithms/__init__.py

@@ -0,0 +1,51 @@
+import threading
+
+class Fibonacci:
+    """Representation of Fibonacci data structure
+
+    Parameters
+    ----------
+    n : int
+        The index for which to compute the Fibonacci number.
+    backend : str
+        Optional, by default 'python'. Specifies whether to use the Python implementation or another backend.
+    """
+
+    def __init__(self, n, backend='python'):
+        self.n = n
+        self.backend = backend
+        self.result = [None] * (n + 1)  # To store Fibonacci numbers
+        self.threads = []  # List to store thread references
+
+    def fib(self, i):
+        """Calculates the Fibonacci number recursively and stores it in result."""
+        if i <= 1:
+            return i
+        if self.result[i] is not None:
+            return self.result[i]
+        self.result[i] = self.fib(i - 1) + self.fib(i - 2)
+        return self.result[i]
+
+    def threaded_fib(self, i):
+        """Wrapper function to calculate Fibonacci in a thread and store the result."""
+        self.result[i] = self.fib(i)
+
+    def calculate(self):
+        """Calculates the Fibonacci sequence for all numbers up to n using multi-threading."""
+        # Start threads for each Fibonacci number calculation
+        for i in range(self.n + 1):
+            thread = threading.Thread(target=self.threaded_fib, args=(i,))
+            self.threads.append(thread)
+            thread.start()
+
+        # Wait for all threads to complete
+        for thread in self.threads:
+            thread.join()
+
+        # Return the nth Fibonacci number after all threads complete
+        return self.result[self.n]
+
+    @property
+    def sequence(self):
+        """Returns the Fibonacci sequence up to the nth number."""
+        return self.result[:self.n + 1]

pydatastructs/multi_threaded_algorithms/fibonacci.py

@@ -0,0 +1,87 @@
+from pydatastructs.multi_threaded_algorithms.fibonacci import Fibonacci
+import threading
+from pydatastructs.utils.raises_util import raises
+
+
+def test_Fibonacci():
+    # Test for the Fibonacci class with default Python backend
+    f = Fibonacci(20)
+    assert isinstance(f, Fibonacci)
+    assert f.n == 20
+    assert f.calculate() == 6765  # Fibonacci(20)
+
+    # Test with different n values
+    f1 = Fibonacci(7)
+    assert f1.calculate() == 13  # Fibonacci(7)
+
+    f2 = Fibonacci(0)
+    assert f2.calculate() == 0  # Fibonacci(0)
+
+    f3 = Fibonacci(1)
+    assert f3.calculate() == 1  # Fibonacci(1)
+
+    # Test for full Fibonacci sequence up to n
+    assert f.sequence == [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765]
+
+    # Test for larger Fibonacci number
+    f_large = Fibonacci(100)
+    assert f_large.calculate() == 354224848179261915075  # Fibonacci(100)
+
+    # Test for sequence with larger n values
+    assert len(f_large.sequence) == 101  # Fibonacci sequence up to 100 should have 101 elements
+
+def test_Fibonacci_with_threading():
+    # Test for multi-threading Fibonacci calculation for small numbers
+    f_small = Fibonacci(10)
+    result_small = f_small.calculate()
+    assert result_small == 55  # Fibonacci(10)
+
+    # Test for multi-threading Fibonacci calculation with medium size n
+    f_medium = Fibonacci(30)
+    result_medium = f_medium.calculate()
+    assert result_medium == 832040  # Fibonacci(30)
+
+    # Test for multi-threading Fibonacci calculation with large n
+    f_large = Fibonacci(50)
+    result_large = f_large.calculate()
+    assert result_large == 12586269025  # Fibonacci(50)
+
+    # Test the Fibonacci sequence correctness for medium size n
+    assert f_medium.sequence == [
+        0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181,
+        6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229
+    ]
+
+    # Check that sequence length is correct for large n (e.g., Fibonacci(50))
+    assert len(f_large.sequence) == 51  # Fibonacci sequence up to 50 should have 51 elements
+
+    # Test invalid input (n cannot be negative)
+    assert raises(ValueError, lambda: Fibonacci(-5))
+
+    # Test when backend is set to CPP (this part assumes a proper backend, can be skipped if not implemented)
+    f_cpp = Fibonacci(10, backend='cpp')
+    result_cpp = f_cpp.calculate()
+    assert result_cpp == 55  # Fibonacci(10) should be the same result as Python
+
+    # Test if sequence matches expected for small number of terms
+    f_test = Fibonacci(5)
+    assert f_test.sequence == [0, 1, 1, 2, 3, 5]
+
+def test_Fibonacci_with_invalid_backend():
+    # Test when an invalid backend is provided (should raise an error)
+    assert raises(NotImplementedError, lambda: Fibonacci(20, backend='invalid_backend'))
+
+def test_Fibonacci_with_threads():
+    # Test multi-threaded calculation is correct for different n
+    f_threaded = Fibonacci(25)
+    assert f_threaded.calculate() == 75025  # Fibonacci(25)
+    
+    # Validate that the thread pool handles large n correctly
+    f_threaded_large = Fibonacci(40)
+    assert f_threaded_large.calculate() == 102334155  # Fibonacci(40)
+    
+    # Ensure that no threads are left hanging (checks for thread cleanup)
+    threads_before = threading.active_count()
+    f_threaded.calculate()
+    threads_after = threading.active_count()
+    assert threads_before == threads_after  # No new threads should be created unexpectedly