Changeset 339

Timestamp:

07/21/10 10:33:45 (6 years ago)

Author:

altafang

Message:

Adding more test problems and tests to the Mystic test suite. Added comparison of a simple constrained QP to scipy's constrained optimizer.

Location:

branches/alta/mystic-0.2a1

Files:

• mystic_test_suite.py (modified) (4 diffs)
• test_constraints_cvxopt_qp.py (modified) (2 diffs)
• test_problems_unconstrained.py (modified) (1 diff)

branches/alta/mystic-0.2a1/mystic_test_suite.py

@@ -4 +4 @@
 
 import unittest
+from math import *
 
 disp = True # Flag for whether to display number of iterations and 
@@ -1469 +1470 @@
 #---------------------------------------------------------------------------------
 
+##############################################################################
+
 class TestVenkataraman91(unittest.TestCase):
     """Test the optimization found in Example 9.1, page 442, in
@@ -1656 +1659 @@
     # Note: No CRT becaues that requires a solver that uses solver.population.
 
+##############################################################################
+
+class TestSchwefel(unittest.TestCase):
+    """Test Schwefel's function in 2 dimensions."""
+
+    def setUp(self):
+        from test_problems_unconstrained import schwefel
+        self.costfunction = schwefel
+        self.ND = 2
+        self.expected = [420.9687]*self.ND
+        self.min = [-500.0]*self.ND
+        self.max = [500.0]*self.ND
+        self.maxiter = 10000
+        self.nplaces = -1 # Precision of answer
+
+    def _run_solver(self, **kwds):
+        from mystic import Sow
+        import numpy
+        from mystic.tools import random_seed
+        random_seed(123)
+        esow = Sow()
+        ssow = Sow() 
+
+        solver = self.solver
+        solver.SetRandomInitialPoints(self.min, self.max)
+        solver.SetEvaluationLimits(maxiter=self.maxiter)
+        solver.SetStrictRanges(self.min, self.max)
+        solver.Solve(self.costfunction, self.term, EvaluationMonitor=esow,\
+                     StepMonitor=ssow, **kwds)
+        sol = solver.Solution()
+
+        # Verify solution is close to expected
+        for i in range(len(sol)):
+            self.assertAlmostEqual(sol[i], self.expected[i], self.nplaces)
+
+        if disp:
+            # Print the number of iterations and function evaluations
+            iters = len(ssow.x)
+            func_evals = len(esow.x)
+            print "\nNumber of iterations = ", iters
+            print "Number of function evaluations = ", func_evals
+
+    def test_DifferentialEvolutionSolver_VTR(self): # Default for this solver
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = VTR()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver_COG(self):
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = COG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver_NCOG(self):
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = NCOG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver_CRT(self):
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import CandidateRelativeTolerance as CRT
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = CRT()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+#--------------------------------------------------------------------------
+
+    def test_DifferentialEvolutionSolver2_VTR(self): # Default for this solver
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = VTR()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver2_COG(self):
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = COG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver2_NCOG(self):
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = NCOG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver2_CRT(self):
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import CandidateRelativeTolerance as CRT
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = CRT()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+#-------------------------------------------------------------------------
+
+    def test_NelderMeadSimplexSolver_CRT(self): # Default for this solver
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import CandidateRelativeTolerance as CRT
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = CRT()#tol)
+        self._run_solver()
+
+    def test_NelderMeadSimplexSolver_VTR(self): 
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = VTR()#tol)
+        self._run_solver()
+
+    def test_NelderMeadSimplexSolver_COG(self): 
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = COG()#tol)
+        self._run_solver()
+
+    def test_NelderMeadSimplexSolver_NCOG(self): 
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = NCOG()#tol)
+        self._run_solver()
+
+#--------------------------------------------------------------------------
+
+    def test_PowellDirectionalSolver_NCOG(self): # Default for this solver
+        from scipy_optimize import PowellDirectionalSolver
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.solver = PowellDirectionalSolver(self.ND)
+        self.term = NCOG()#tol)
+        self._run_solver()
+
+    def test_PowellDirectionalSolver_COG(self): 
+        from scipy_optimize import PowellDirectionalSolver
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.solver = PowellDirectionalSolver(self.ND)
+        self.term = COG()#tol)
+        self._run_solver()
+
+    def test_PowellDirectionalSolver_VTR(self): 
+        from scipy_optimize import PowellDirectionalSolver
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.solver = PowellDirectionalSolver(self.ND)
+        self.term = VTR()#tol)
+        self._run_solver()
+
+    # Note: No CRT becaues that requires a solver that uses solver.population.
+
+##############################################################################
+
+class TestEasom(unittest.TestCase):
+    """Test Easom's function."""
+
+    def setUp(self):
+        from test_problems_unconstrained import easom
+        self.costfunction = easom
+        self.ND = 2
+        self.expected = [pi]*self.ND
+        self.min = [-100.]*self.ND
+        self.max = [100.]*self.ND
+        self.maxiter = 10000
+        self.nplaces = -1 # Precision of answer
+
+    def _run_solver(self, **kwds):
+        from mystic import Sow
+        import numpy
+        from mystic.tools import random_seed
+        random_seed(123)
+        esow = Sow()
+        ssow = Sow() 
+
+        solver = self.solver
+        solver.SetRandomInitialPoints(self.min, self.max)
+        solver.SetEvaluationLimits(maxiter=self.maxiter)
+        solver.SetStrictRanges(self.min, self.max)
+        solver.Solve(self.costfunction, self.term, EvaluationMonitor=esow,\
+                     StepMonitor=ssow, **kwds)
+        sol = solver.Solution()
+
+        # Verify solution is close to expected
+        for i in range(len(sol)):
+            self.assertAlmostEqual(sol[i], self.expected[i], self.nplaces)
+
+        if disp:
+            # Print the number of iterations and function evaluations
+            iters = len(ssow.x)
+            func_evals = len(esow.x)
+            print "\nNumber of iterations = ", iters
+            print "Number of function evaluations = ", func_evals
+
+    def test_DifferentialEvolutionSolver_VTR(self): # Default for this solver
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = VTR()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver_COG(self):
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = COG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver_NCOG(self):
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = NCOG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver_CRT(self):
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import CandidateRelativeTolerance as CRT
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = CRT()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+#--------------------------------------------------------------------------
+
+    def test_DifferentialEvolutionSolver2_VTR(self): # Default for this solver
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = VTR()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver2_COG(self):
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = COG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver2_NCOG(self):
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = NCOG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver2_CRT(self):
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import CandidateRelativeTolerance as CRT
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = CRT()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+#-------------------------------------------------------------------------
+
+    def test_NelderMeadSimplexSolver_CRT(self): # Default for this solver
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import CandidateRelativeTolerance as CRT
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = CRT()#tol)
+        self._run_solver()
+
+    def test_NelderMeadSimplexSolver_VTR(self): 
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = VTR()#tol)
+        self._run_solver()
+
+    def test_NelderMeadSimplexSolver_COG(self): 
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = COG()#tol)
+        self._run_solver()
+
+    def test_NelderMeadSimplexSolver_NCOG(self): 
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = NCOG()#tol)
+        self._run_solver()
+
+#--------------------------------------------------------------------------
+
+    def test_PowellDirectionalSolver_NCOG(self): # Default for this solver
+        from scipy_optimize import PowellDirectionalSolver
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.solver = PowellDirectionalSolver(self.ND)
+        self.term = NCOG()#tol)
+        self._run_solver()
+
+    def test_PowellDirectionalSolver_COG(self): 
+        from scipy_optimize import PowellDirectionalSolver
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.solver = PowellDirectionalSolver(self.ND)
+        self.term = COG()#tol)
+        self._run_solver()
+
+    def test_PowellDirectionalSolver_VTR(self): 
+        from scipy_optimize import PowellDirectionalSolver
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.solver = PowellDirectionalSolver(self.ND)
+        self.term = VTR()#tol)
+        self._run_solver()
+
+    # Note: No CRT becaues that requires a solver that uses solver.population.
+
+##############################################################################
+
+class TestRotatedEllipsoid(unittest.TestCase):
+    """Test the rotated ellipsoid function in 2 dimensions."""
+
+    def setUp(self):
+        from test_problems_unconstrained import rotated_ellipsoid
+        self.costfunction = rotated_ellipsoid
+        self.ND = 2
+        self.expected = [0.]*self.ND
+        self.min = [-65.536]*self.ND
+        self.max = [65.536]*self.ND
+        self.maxiter = 10000
+        self.nplaces = -1 # Precision of answer
+
+    def _run_solver(self, **kwds):
+        from mystic import Sow
+        import numpy
+        from mystic.tools import random_seed
+        random_seed(123)
+        esow = Sow()
+        ssow = Sow() 
+
+        solver = self.solver
+        solver.SetRandomInitialPoints(self.min, self.max)
+        solver.SetEvaluationLimits(maxiter=self.maxiter)
+        solver.SetStrictRanges(self.min, self.max)
+        solver.Solve(self.costfunction, self.term, EvaluationMonitor=esow,\
+                     StepMonitor=ssow, **kwds)
+        sol = solver.Solution()
+
+        # Verify solution is close to expected
+        for i in range(len(sol)):
+            self.assertAlmostEqual(sol[i], self.expected[i], self.nplaces)
+
+        if disp:
+            # Print the number of iterations and function evaluations
+            iters = len(ssow.x)
+            func_evals = len(esow.x)
+            print "\nNumber of iterations = ", iters
+            print "Number of function evaluations = ", func_evals
+
+    def test_DifferentialEvolutionSolver_VTR(self): # Default for this solver
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = VTR()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver_COG(self):
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = COG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver_NCOG(self):
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = NCOG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver_CRT(self):
+        from differential_evolution import DifferentialEvolutionSolver
+        from mystic.termination import CandidateRelativeTolerance as CRT
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver(self.ND, self.NP)
+        self.term = CRT()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+#--------------------------------------------------------------------------
+
+    def test_DifferentialEvolutionSolver2_VTR(self): # Default for this solver
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = VTR()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver2_COG(self):
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = COG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver2_NCOG(self):
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.NP = 100
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = NCOG()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+    def test_DifferentialEvolutionSolver2_CRT(self):
+        from differential_evolution import DifferentialEvolutionSolver2
+        from mystic.termination import CandidateRelativeTolerance as CRT
+        tol = 1e-7
+        self.NP = 100 
+        self.solver = DifferentialEvolutionSolver2(self.ND, self.NP)
+        self.term = CRT()#tol)
+        from mystic.strategy import Rand1Bin
+        self._run_solver( strategy=Rand1Bin )
+
+#-------------------------------------------------------------------------
+
+    def test_NelderMeadSimplexSolver_CRT(self): # Default for this solver
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import CandidateRelativeTolerance as CRT
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = CRT()#tol)
+        self._run_solver()
+
+    def test_NelderMeadSimplexSolver_VTR(self): 
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = VTR()#tol)
+        self._run_solver()
+
+    def test_NelderMeadSimplexSolver_COG(self): 
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = COG()#tol)
+        self._run_solver()
+
+    def test_NelderMeadSimplexSolver_NCOG(self): 
+        from scipy_optimize import NelderMeadSimplexSolver
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.solver = NelderMeadSimplexSolver(self.ND)
+        self.term = NCOG()#tol)
+        self._run_solver()
+
+#--------------------------------------------------------------------------
+
+    def test_PowellDirectionalSolver_NCOG(self): # Default for this solver
+        from scipy_optimize import PowellDirectionalSolver
+        from mystic.termination import NormalizedChangeOverGeneration as NCOG
+        tol = 1e-7
+        self.solver = PowellDirectionalSolver(self.ND)
+        self.term = NCOG()#tol)
+        self._run_solver()
+
+    def test_PowellDirectionalSolver_COG(self): 
+        from scipy_optimize import PowellDirectionalSolver
+        from mystic.termination import ChangeOverGeneration as COG
+        tol = 1e-7
+        self.solver = PowellDirectionalSolver(self.ND)
+        self.term = COG()#tol)
+        self._run_solver()
+
+    def test_PowellDirectionalSolver_VTR(self): 
+        from scipy_optimize import PowellDirectionalSolver
+        from mystic.termination import VTR
+        tol = 1e-7
+        self.solver = PowellDirectionalSolver(self.ND)
+        self.term = VTR()#tol)
+        self._run_solver()
+
+    # Note: No CRT becaues that requires a solver that uses solver.population.
+
+
 #---------------------------------------------------------------------------------
 
@@ -1667 +2229 @@
     suite7 = unittest.TestLoader().loadTestsFromTestCase(TestGriewangk)
     suite8 = unittest.TestLoader().loadTestsFromTestCase(TestPeaks) 
-    suite9 = unittest.TestLoader().loadTestsFromTestCase(TestVenkataraman91)  
+    suite9 = unittest.TestLoader().loadTestsFromTestCase(TestVenkataraman91)
+    suite10 = unittest.TestLoader().loadTestsFromTestCase(TestSchwefel)  
+    suite11 = unittest.TestLoader().loadTestsFromTestCase(TestEasom)  
+    suite12 = unittest.TestLoader().loadTestsFromTestCase(TestRotatedEllipsoid) 
     # Comment out suites in the list below to test specific test cost functions only
     # (Testing all the problems will take some time)
     allsuites = unittest.TestSuite([suite1, suite2, suite3, suite4, suite5, \
-                                    suite6, suite7, suite8, suite9])
+                                    suite6, suite7, suite8, suite9, suite10, \
+                                    suite11, suite12])
     unittest.TextTestRunner(verbosity=2).run(allsuites)

branches/alta/mystic-0.2a1/test_constraints_cvxopt_qp.py

@@ -49 +49 @@
     print soln.xf
     Solution: {x1: array([ 0.2500267]), x2: array([ 0.7499733])}
+
+    Scipy.optimize.fmin_slsqp code and results:
+    -------------------------------------------
+    from scipy.optimize import fmin_slsqp
+    def func(x):
+        x1 = x[0]
+        x2 = x[1]
+        return 2.*x1**2 + x2**2 + x1*x2 + x1 + x2
+
+    def ineqcon1(x):
+        return x[0]
+
+    def ineqcon2(x):
+        return x[1]
+
+    def eqcon1(x):
+        return x[0] + x[1] - 1.0
+
+    x0 = [1., 1.]
+
+    print fmin_slsqp(func, x0, eqcons=[eqcon1], ieqcons=[ineqcon1, ineqcon2])
+    Solution: [ 0.25  0.75]
 """
 
@@ -75 +97 @@
 # Wrap the constraints to the cost function
 from constraint_tools import wrap_constraints_to_cost
-wrapped_costfunc = wrap_constraints_to_cost(constraints_string, ndim, costfunc)
+wrapped_costfunc = wrap_constraints_to_cost(constraints_string, ndim, costfunc,\
+                                            penalty=1e7)
 
 # Solve the constrained optimization problem with a one-line interface

branches/alta/mystic-0.2a1/test_problems_unconstrained.py

@@ -96 +96 @@
 inverted for minimization.' - http://www.geatbx.com/docu/fcnindex-01.html
 Global minimum f(x1, x2) = -1 at (x1, x2) = (pi, pi)
-xi in -100, 100. 2-dimensional."""
+xi in [-100, 100]. 2-dimensional."""
     x1 = x[0]
     x2 = x[1]
-    return -cos(x1)*cos(x2)*exp(-(x1-pi)**2 + (x2 - pi)**2)
+    return -cos(x1)*cos(x2)*exp(-(x1-pi)**2 - (x2 - pi)**2)
 
 #print "Easom:", easom([pi, pi])
 
+def goldstein_price(x):
+    """Goldstein-Price function. Global minimum f(x1, x2) = 3 at 
+(x1, x2) = (0, -1)
+x1, x2 in [-2., 2.]
+2-dimensional.  http://www.geatbx.com/docu/fcnindex-01.html"""
+    x1 = x[0]
+    x2 = x[1]
+    return (1.+(x1+x2+1.)**2*(19.-14.*x1+3.*x1**2-14.*x2+6.*x1*x2+3.*x2**2))*\
+           (30.+(2.*x1-3.*x2)**2*(18.-32.*x1+12.*x1**2+48.*x2-36.*x1*x2+\
+            27.*x2**2))
+
+#print "Goldstein-Price:", goldstein_price([0., -1.])
+
+def rotated_ellipsoid(x):
+    """'An extension of the axis parallel hyper-ellipsoid is Schwefel's 
+function1.2. With respect to the coordinate axes, this function produces 
+rotated hyper-ellipsoids. It is continuous, convex and unimodal.' 
+- http://www.geatbx.com/docu/fcnindex-01.html
+xi in [-65.536, 65.536]. n-dimensional.
+global minimum f(x)=0 at xi=0."""
+    result = 0.
+    for i in range(len(x)):
+        s = 0.
+        for j in range(i+1):
+            s += x[j]
+        result += s**2
+    return result
+
+#print "Rotated Ellipsoid:", rotated_ellipsoid([0., 0.])
+