Adding more objective functions and test cases

Author: sandeepkunkunuru

rao_algorithms/__init__.py

@@ -1,13 +1,31 @@
 from .algorithms import BMR_algorithm, BWR_algorithm
 from .optimization import run_optimization, save_convergence_curve
-from .objective_functions import objective_function, constraint_1, constraint_2
+from .objective_functions import (
+    objective_function, 
+    rastrigin_function, 
+    ackley_function, 
+    rosenbrock_function, 
+    constraint_1, 
+    constraint_2, 
+    nonlinear_objective_function,
+    constraint_3,
+    constraint_4,
+    constraint_5
+)
 
 __all__ = [
     'BMR_algorithm',
     'BWR_algorithm',
     'run_optimization',
     'save_convergence_curve',
     'objective_function',
+    'rastrigin_function',
+    'ackley_function',
+    'rosenbrock_function',
     'constraint_1',
     'constraint_2',
+    'nonlinear_objective_function',
+    'constraint_3',
+    'constraint_4',
+    'constraint_5',
 ]

rao_algorithms/objective_functions.py

@@ -1,13 +1,45 @@
 import numpy as np
 
-# Sphere function (default objective)
+# Sphere function (from previous implementation)
 def objective_function(x):
     return np.sum(x**2)
 
+# Rastrigin function
+def rastrigin_function(x):
+    return 10 * len(x) + np.sum(x**2 - 10 * np.cos(2 * np.pi * x))
+
+# Ackley function
+def ackley_function(x):
+    a = 20
+    b = 0.2
+    c = 2 * np.pi
+    n = len(x)
+    s1 = -a * np.exp(-b * np.sqrt(np.sum(x**2) / n))
+    s2 = -np.exp(np.sum(np.cos(c * x)) / n)
+    return s1 + s2 + a + np.exp(1)
+
+# Rosenbrock function
+def rosenbrock_function(x):
+    return np.sum(100 * (x[1:] - x[:-1]**2)**2 + (x[:-1] - 1)**2)
+
 # Example constraint: x[0] + x[1] <= 10
 def constraint_1(x):
     return x[0] + x[1] - 10  # Must be <= 0
 
 # Example constraint: x[0] >= x[1]
 def constraint_2(x):
     return -(x[0] - x[1])  # Must be <= 0 (x[0] >= x[1])
+
+# Example: A nonlinear constrained optimization problem
+def nonlinear_objective_function(x):
+    return x[0]**2 + x[1]**2 + x[0]*x[1] - 10*x[0] - 15*x[1]
+
+# Constraints
+def constraint_3(x):
+    return 25 - (x[0]**2 + x[1]**2)  # Circle constraint: x[0]^2 + x[1]^2 <= 25
+
+def constraint_4(x):
+    return x[0] - 5  # Must be <= 5
+
+def constraint_5(x):
+    return x[1] - 5  # Must be <= 5

setup.py

@@ -8,7 +8,7 @@ def read_file(filename):
 
 setup(
     name='rao_algorithms',
-    version='0.2.0',
+    version='0.2.1',
     author='Samdeep Kunkunuru',
     author_email='[email protected]',
     description='BMR and BWR optimization algorithms with constraint handling',

tests/test_algorithms.py

@@ -1,14 +1,14 @@
 import unittest
 import numpy as np
-from rao_algorithms import BMR_algorithm, BWR_algorithm, objective_function, constraint_1, constraint_2
+from rao_algorithms import BMR_algorithm, BWR_algorithm, run_optimization, objective_function, rastrigin_function, ackley_function, rosenbrock_function, constraint_1, constraint_2
 
 class TestOptimizationAlgorithms(unittest.TestCase):
 
     def setUp(self):
-        self.bounds = np.array([[-100, 100]] * 2)
+        self.bounds = np.array([[-100, 100]] * 2)  # Change as needed for higher dimensional problems
         self.num_iterations = 100
         self.population_size = 50
-        self.num_variables = 2
+        self.num_variables = 2  # You can increase this for higher-dimensional tests
 
     def test_bmr_unconstrained(self):
         best_solution, _ = BMR_algorithm(self.bounds, self.num_iterations, self.population_size, self.num_variables, objective_function)
@@ -18,6 +18,18 @@ def test_bwr_unconstrained(self):
         best_solution, _ = BWR_algorithm(self.bounds, self.num_iterations, self.population_size, self.num_variables, objective_function)
         self.assertIsInstance(best_solution, np.ndarray)
 
+    def test_bmr_rastrigin(self):
+        best_solution, _ = BMR_algorithm(self.bounds, self.num_iterations, self.population_size, self.num_variables, rastrigin_function)
+        self.assertIsInstance(best_solution, np.ndarray)
+
+    def test_bwr_ackley(self):
+        best_solution, _ = BWR_algorithm(self.bounds, self.num_iterations, self.population_size, self.num_variables, ackley_function)
+        self.assertIsInstance(best_solution, np.ndarray)
+
+    def test_bmr_rosenbrock(self):
+        best_solution, _ = BMR_algorithm(self.bounds, self.num_iterations, self.population_size, self.num_variables, rosenbrock_function)
+        self.assertIsInstance(best_solution, np.ndarray)
+
     def test_bmr_constrained(self):
         constraints = [constraint_1, constraint_2]
         best_solution, _ = BMR_algorithm(self.bounds, self.num_iterations, self.population_size, self.num_variables, objective_function, constraints)
@@ -28,5 +40,20 @@ def test_bwr_constrained(self):
         best_solution, _ = BWR_algorithm(self.bounds, self.num_iterations, self.population_size, self.num_variables, objective_function, constraints)
         self.assertIsInstance(best_solution, np.ndarray)
 
+    def test_multiple_runs(self):
+        """Run BMR multiple times and calculate mean and standard deviation."""
+        num_runs = 30
+        results = []
+
+        for _ in range(num_runs):
+            best_solution, _ = BMR_algorithm(self.bounds, self.num_iterations, self.population_size, self.num_variables, objective_function)
+            results.append(np.sum(best_solution**2))  # Sum of squares for comparison
+
+        mean_result = np.mean(results)
+        std_result = np.std(results)
+
+        self.assertGreaterEqual(mean_result, 0)
+        print(f"BMR Mean: {mean_result}, Std Dev: {std_result}")
+
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()