Add tests

.github/workflows/test.yml

@@ -13,7 +13,7 @@ jobs:
     strategy:
       matrix:
         os: [ubuntu-latest, windows-latest, macos-latest]
-        python-version: ['3.9', '3.10']
+        python-version: ['3.9', '3.10', '3.11', '3.12']
     defaults:
       run:
         shell: bash

examples/run.py

@@ -1,9 +1,5 @@
-import numpy as np
 from fireflyalgorithm import FireflyAlgorithm
-
-
-def sphere(x):
-    return np.sum(x ** 2)
+from fireflyalgorithm.problems import sphere
 
 
 FA = FireflyAlgorithm()

fireflyalgorithm/problems.py

@@ -56,7 +56,7 @@ def katsuura(x):
     dim = len(x)
     k = np.atleast_2d(np.arange(1, 33)).T
     i = np.arange(0, dim * 1)
-    inner = np.round(2**k * x) * (2 ** (-k))
+    inner = np.round(2**k * x) * (2.0 ** (-k))
     return np.prod(np.sum(inner, axis=0) * (i + 1) + 1)
 
 
@@ -165,7 +165,9 @@ def schaffer4(x):
 
 def schwefel(x):
     dim = len(x)
-    return 418.9829 * dim - np.sum(x * np.sin(np.sqrt(np.abs(x))))
+    return 418.982887272433799807913601398 * dim - np.sum(
+        x * np.sin(np.sqrt(np.abs(x)))
+    )
 
 
 def schwefel21(x):

tests/test_firefly.py

@@ -1,15 +1,10 @@
 from unittest import TestCase
-
-import numpy as np
 from fireflyalgorithm import FireflyAlgorithm
-
-def sphere(x):
-    return np.sum(x ** 2)
+from fireflyalgorithm.problems import sphere
 
 
 class TestFA(TestCase):
-
     def test_algorithm(self):
-        FA = FireflyAlgorithm()
-        best = FA.run(function=sphere, dim=10, lb=-5, ub=5, max_evals=10000)
+        algorithm = FireflyAlgorithm()
+        best = algorithm.run(function=sphere, dim=10, lb=-5, ub=5, max_evals=10000)
         self.assertLess(best, 5)

tests/test_problems.py

@@ -0,0 +1,214 @@
+from unittest import TestCase
+import numpy as np
+from fireflyalgorithm.problems import (
+    get_problem,
+    ackley,
+    alpine1,
+    alpine2,
+    cigar,
+    cosine_mixture,
+    csendes,
+    dixon_price,
+    griewank,
+    katsuura,
+    levy,
+    michalewicz,
+    perm1,
+    perm2,
+    pinter,
+    powell,
+    quing,
+    quintic,
+    rastrigin,
+    rosenbrock,
+    salomon,
+    schaffer2,
+    schaffer4,
+    schwefel,
+    schwefel21,
+    schwefel22,
+    sphere,
+    step,
+    step2,
+    styblinski_tang,
+    trid,
+    weierstrass,
+    whitley,
+    zakharov,
+)
+
+
+class TestProblems(TestCase):
+    def test_problem_factory(self):
+        self.assertRaises(KeyError, get_problem, "spherekjl2")
+        self.assertEqual(get_problem("ackley"), ackley)
+        self.assertEqual(get_problem("alpine1"), alpine1)
+        self.assertEqual(get_problem("alpine2"), alpine2)
+        self.assertEqual(get_problem("cigar"), cigar)
+        self.assertEqual(get_problem("cosine_mixture"), cosine_mixture)
+        self.assertEqual(get_problem("csendes"), csendes)
+        self.assertEqual(get_problem("dixon_price"), dixon_price)
+        self.assertEqual(get_problem("griewank"), griewank)
+        self.assertEqual(get_problem("katsuura"), katsuura)
+        self.assertEqual(get_problem("levy"), levy)
+        self.assertEqual(get_problem("michalewicz"), michalewicz)
+        self.assertEqual(get_problem("perm1"), perm1)
+        self.assertEqual(get_problem("perm2"), perm2)
+        self.assertEqual(get_problem("pinter"), pinter)
+        self.assertEqual(get_problem("powell"), powell)
+        self.assertEqual(get_problem("quing"), quing)
+        self.assertEqual(get_problem("quintic"), quintic)
+        self.assertEqual(get_problem("rastrigin"), rastrigin)
+        self.assertEqual(get_problem("rosenbrock"), rosenbrock)
+        self.assertEqual(get_problem("salomon"), salomon)
+        self.assertEqual(get_problem("schaffer2"), schaffer2)
+        self.assertEqual(get_problem("schaffer4"), schaffer4)
+        self.assertEqual(get_problem("schwefel"), schwefel)
+        self.assertEqual(get_problem("schwefel21"), schwefel21)
+        self.assertEqual(get_problem("schwefel22"), schwefel22)
+        self.assertEqual(get_problem("sphere"), sphere)
+        self.assertEqual(get_problem("step"), step)
+        self.assertEqual(get_problem("step2"), step2)
+        self.assertEqual(get_problem("styblinski_tang"), styblinski_tang)
+        self.assertEqual(get_problem("trid"), trid)
+        self.assertEqual(get_problem("weierstrass"), weierstrass)
+        self.assertEqual(get_problem("whitley"), whitley)
+        self.assertEqual(get_problem("zakharov"), zakharov)
+
+    def test_ackley(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(ackley(x), 0.0)
+
+    def test_alpine1(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(alpine1(x), 0.0)
+
+    def test_alpine2(self):
+        x = np.full(5, 7.9170526982459462172)
+        self.assertAlmostEqual(alpine2(x), 2.8081311800070053291**5)
+
+    def test_cigar(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(cigar(x), 0.0)
+
+    def test_cosine_mixture(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(cosine_mixture(x), -0.5)
+
+    def test_csendes(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(csendes(x), 0.0)
+
+    def test_dixon_price(self):
+        x = np.array([2 ** -((2**i - 2) / 2**i) for i in range(1, 6)])
+        self.assertAlmostEqual(dixon_price(x), 0.0)
+
+    def test_griewank(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(griewank(x), 0.0)
+
+    def test_katsuura(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(katsuura(x), 1.0)
+
+    def test_levy(self):
+        x = np.full(5, 1)
+        self.assertAlmostEqual(levy(x), 0.0)
+
+    def test_michalewicz(self):
+        x = np.array([2.20290552014618, 1.57079632677565])
+        self.assertAlmostEqual(michalewicz(x), -1.80130341009855321)
+
+    def test_perm1(self):
+        x = np.arange(1, 6)
+        self.assertAlmostEqual(perm1(x), 0.0)
+
+    def test_perm2(self):
+        x = 1 / np.arange(1, 6)
+        self.assertAlmostEqual(perm2(x), 0.0)
+
+    def test_pinter(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(pinter(x), 0.0)
+
+    def test_powell(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(powell(x), 0.0)
+
+    def test_quing(self):
+        x = np.sqrt(np.arange(1, 6))
+        self.assertAlmostEqual(quing(x), 0.0)
+
+    def test_quintic(self):
+        x = np.full(5, -1)
+        self.assertAlmostEqual(quintic(x), 0.0)
+
+    def test_rastrigin(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(rastrigin(x), 0.0)
+
+    def test_rosenbrock(self):
+        x = np.full(5, 1)
+        self.assertAlmostEqual(rosenbrock(x), 0.0)
+
+    def test_salomon(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(rastrigin(x), 0.0)
+
+    def test_schaffer2(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(schaffer2(x), 0.0)
+
+    def test_schaffer4(self):
+        x1 = np.array([0, 1.253131828792882])
+        x2 = np.array([0, -1.253131828792882])
+        x3 = np.array([1.253131828792882, 0])
+        x4 = np.array([-1.253131828792882, 0])
+        self.assertAlmostEqual(schaffer4(x1), 0.292578632035980)
+        self.assertAlmostEqual(schaffer4(x2), 0.292578632035980)
+        self.assertAlmostEqual(schaffer4(x3), 0.292578632035980)
+        self.assertAlmostEqual(schaffer4(x4), 0.292578632035980)
+
+    def test_schwefel(self):
+        x = np.full(5, 420.968746)
+        self.assertAlmostEqual(schwefel(x), 0.0)
+
+    def test_schwefel21(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(schwefel21(x), 0.0)
+
+    def test_schwefel22(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(schwefel22(x), 0.0)
+
+    def test_sphere(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(sphere(x), 0.0)
+
+    def test_step(self):
+        x = np.full(5, 0.5)
+        self.assertAlmostEqual(step(x), 0.0)
+
+    def test_step2(self):
+        x = np.full(5, 0.5)
+        self.assertAlmostEqual(step(x), 0.0)
+
+    def test_styblinski_tang(self):
+        x = np.full(5, -2.903534018185960)
+        self.assertAlmostEqual(styblinski_tang(x), -39.16616570377142 * 5)
+
+    def test_trid(self):
+        x = np.array([6, 10, 12, 12, 10, 6])
+        self.assertAlmostEqual(trid(x), -50)
+
+    def test_weierstrass(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(weierstrass(x), 0.0)
+
+    def test_whitley(self):
+        x = np.full(5, 1)
+        self.assertAlmostEqual(whitley(x), 0.0)
+
+    def test_zakharov(self):
+        x = np.zeros(5)
+        self.assertAlmostEqual(zakharov(x), 0.0)