Changeset 735


Ignore:
Timestamp:
07/29/14 08:33:29 (22 months ago)
Author:
mmckerns
Message:

fix: numpy imports for models defined inside solver_test_suite; use trap_stdout

Location:
mystic/tests
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • mystic/tests/solver_test_suite.py

    r713 r735  
    1313# should report clock-time, # of iterations, and # of function evaluations 
    1414 
     15import sys 
     16from StringIO import StringIO 
    1517import unittest 
    1618from math import * 
    1719from mystic.math import almostEqual 
    1820 
    19 disp = True # Flag for whether to display number of iterations and  
    20             # function evaluations 
     21disp = False  # Flag for whether to display number of iterations  
     22              #  and function evaluations. 
     23verbosity = 2 # Verbosity setting for unittests (default is 1). 
     24 
     25def trap_stdout(): #XXX: better with contextmanager? 
     26    "temporarily trap stdout; return original sys.stdout" 
     27    orig, sys.stdout = sys.stdout, StringIO() 
     28    return orig 
     29 
     30def release_stdout(orig): 
     31    "release stdout; return any trapped output as a string" 
     32    out = sys.stdout.getvalue() 
     33    sys.stdout.close() 
     34    sys.stdout = orig 
     35    return out 
     36 
    2137 
    2238class TestZimmermann(unittest.TestCase): 
    … …  
    3652    def _run_solver(self, iter_limit=False, local=False, **kwds): 
    3753        from mystic.monitors import Monitor 
    38         import numpy 
    3954        from mystic.tools import random_seed 
    4055        random_seed(321) # Number of failures is quite dependent on random seed! 
    4156        esow = Monitor() 
    4257        ssow = Monitor()  
    43  
    44         if iter_limit: # CRT with solvers that don't use population. 
    45             print '\nA warning should print:' 
    4658 
    4759        solver = self.solver 
    … …  
    5062        solver.SetEvaluationMonitor(esow) 
    5163        solver.SetGenerationMonitor(ssow) 
     64        _stdout = trap_stdout() 
    5265        solver.Solve(self.costfunction, self.term, **kwds) 
     66        out = release_stdout(_stdout) 
    5367        sol = solver.Solution() 
    5468        #print '\nsol:', sol 
    … …  
    6478        if iter_limit: 
    6579            self.assertTrue(solver.generations < 2) 
     80            warn = "Warning: Invalid termination condition (nPop < 2)" 
     81            self.assertTrue(warn in out) 
    6682            return 
    6783 
    … …  
    247263    def _run_solver(self, iter_limit=False, **kwds): 
    248264        from mystic.monitors import Monitor 
    249         import numpy 
    250265        from mystic.tools import random_seed 
    251266        #random_seed(123) 
    … …  
    260275        solver.SetEvaluationMonitor(esow) 
    261276        solver.SetGenerationMonitor(ssow) 
     277        _stdout = trap_stdout() 
    262278        solver.Solve(self.costfunction, self.term, **kwds) 
     279        out = release_stdout(_stdout) 
    263280        sol = solver.Solution() 
    264281 
    … …  
    273290        if iter_limit: 
    274291            self.assertTrue(solver.generations < 2) 
     292            warn = "Warning: Invalid termination condition (nPop < 2)" 
     293            self.assertTrue(warn in out) 
    275294            return 
    276295 
    … …  
    448467    def _run_solver(self, iter_limit=False, **kwds): 
    449468        from mystic.monitors import Monitor 
    450         import numpy 
    451469        from mystic.tools import random_seed 
    452470        random_seed(123) 
    … …  
    460478        solver.SetEvaluationMonitor(esow) 
    461479        solver.SetGenerationMonitor(ssow) 
     480        _stdout = trap_stdout() 
    462481        solver.Solve(self.costfunction, self.term, **kwds) 
     482        out = release_stdout(_stdout) 
    463483        sol = solver.Solution() 
    464484 
    … …  
    473493        if iter_limit: 
    474494            self.assertTrue(solver.generations < 2) 
     495            warn = "Warning: Invalid termination condition (nPop < 2)" 
     496            self.assertTrue(warn in out) 
    475497            return 
    476498 
    … …  
    649671    def _run_solver(self, iter_limit=False, **kwds): 
    650672        from mystic.monitors import Monitor 
    651         import numpy 
    652673        from mystic.tools import random_seed 
    653674        #random_seed(123) 
    … …  
    661682        solver.SetEvaluationMonitor(esow) 
    662683        solver.SetGenerationMonitor(ssow) 
     684        _stdout = trap_stdout() 
    663685        solver.Solve(self.costfunction, self.term, **kwds) 
     686        out = release_stdout(_stdout) 
    664687        sol = solver.Solution() 
    665688 
    … …  
    674697        if iter_limit: 
    675698            self.assertTrue(solver.generations < 2) 
     699            warn = "Warning: Invalid termination condition (nPop < 2)" 
     700            self.assertTrue(warn in out) 
    676701            return 
    677702 
    … …  
    848873    def _run_solver(self, iter_limit=False, **kwds): 
    849874        from mystic.monitors import Monitor 
    850         import numpy 
    851875        from mystic.tools import random_seed 
    852876        random_seed(123) 
    … …  
    860884        solver.SetEvaluationMonitor(esow) 
    861885        solver.SetGenerationMonitor(ssow) 
     886        _stdout = trap_stdout() 
    862887        solver.Solve(self.costfunction, self.term, **kwds) 
     888        out = release_stdout(_stdout) 
    863889        sol = solver.Solution() 
    864890 
    … …  
    873899        if iter_limit: 
    874900            self.assertTrue(solver.generations < 2) 
     901            warn = "Warning: Invalid termination condition (nPop < 2)" 
     902            self.assertTrue(warn in out) 
    875903            return 
    876904 
    … …  
    10481076    def _run_solver(self, iter_limit = False, **kwds): 
    10491077        from mystic.monitors import Monitor 
    1050         import numpy 
    10511078        from mystic.tools import random_seed 
    10521079       #random_seed(123) 
    … …  
    10601087        solver.SetEvaluationMonitor(esow) 
    10611088        solver.SetGenerationMonitor(ssow) 
     1089        _stdout = trap_stdout() 
    10621090        solver.Solve(self.costfunction, self.term, **kwds) 
     1091        out = release_stdout(_stdout) 
    10631092        sol = solver.Solution() 
    10641093 
    … …  
    10731102        if iter_limit: 
    10741103            self.assertTrue(solver.generations < 2) 
     1104            warn = "Warning: Invalid termination condition (nPop < 2)" 
     1105            self.assertTrue(warn in out) 
    10751106            return 
    10761107 
    … …  
    12491280    def _run_solver(self, iter_limit=False, **kwds): 
    12501281        from mystic.monitors import Monitor 
    1251         import numpy 
    12521282        from mystic.tools import random_seed 
    12531283        #random_seed(123) 
    … …  
    12611291        solver.SetEvaluationMonitor(esow) 
    12621292        solver.SetGenerationMonitor(ssow) 
     1293        _stdout = trap_stdout() 
    12631294        solver.Solve(self.costfunction, self.term, **kwds) 
     1295        out = release_stdout(_stdout) 
    12641296        sol = solver.Solution() 
    12651297 
    … …  
    12741306        if iter_limit: 
    12751307            self.assertTrue(solver.generations < 2) 
     1308            warn = "Warning: Invalid termination condition (nPop < 2)" 
     1309            self.assertTrue(warn in out) 
    12761310            return 
    12771311 
    … …  
    14621496    def _run_solver(self, iter_limit=False, **kwds): 
    14631497        from mystic.monitors import Monitor 
    1464         import numpy 
    14651498        from mystic.tools import random_seed 
    14661499        #random_seed(123) 
    … …  
    14741507        solver.SetEvaluationMonitor(esow) 
    14751508        solver.SetGenerationMonitor(ssow) 
     1509        _stdout = trap_stdout() 
    14761510        solver.Solve(self.costfunction, self.term, **kwds) 
     1511        out = release_stdout(_stdout) 
    14771512        sol = solver.Solution() 
    14781513 
    … …  
    14871522        if iter_limit: 
    14881523            self.assertTrue(solver.generations < 2) 
     1524            warn = "Warning: Invalid termination condition (nPop < 2)" 
     1525            self.assertTrue(warn in out) 
    14891526            return 
    14901527 
    … …  
    16741711    def _run_solver(self, iter_limit=False, **kwds): 
    16751712        from mystic.monitors import Monitor 
    1676         import numpy 
    16771713        from mystic.tools import random_seed 
    16781714        #random_seed(123) 
    … …  
    16861722        solver.SetEvaluationMonitor(esow) 
    16871723        solver.SetGenerationMonitor(ssow) 
     1724        _stdout = trap_stdout() 
    16881725        solver.Solve(self.costfunction, self.term, **kwds) 
     1726        out = release_stdout(_stdout) 
    16891727        sol = solver.Solution() 
    16901728 
    … …  
    17031741        if iter_limit: 
    17041742            self.assertTrue(solver.generations < 2) 
     1743            warn = "Warning: Invalid termination condition (nPop < 2)" 
     1744            self.assertTrue(warn in out) 
    17051745            return 
    17061746 
    … …  
    18621902 
    18631903    def setUp(self): 
     1904        import numpy 
    18641905        def schwefel(x): 
    18651906            """'Schwefel's function [Sch81] is deceptive in that the global minimum is  
    … …  
    18831924    def _run_solver(self, iter_limit=False, **kwds): 
    18841925        from mystic.monitors import Monitor 
    1885         import numpy 
    18861926        from mystic.tools import random_seed 
    18871927        random_seed(123) 
    … …  
    18951935        solver.SetEvaluationMonitor(esow) 
    18961936        solver.SetGenerationMonitor(ssow) 
     1937        _stdout = trap_stdout() 
    18971938        solver.Solve(self.costfunction, self.term, **kwds) 
     1939        out = release_stdout(_stdout) 
    18981940        sol = solver.Solution() 
    18991941 
    … …  
    19081950        if iter_limit: 
    19091951            self.assertTrue(solver.generations < 2) 
     1952            warn = "Warning: Invalid termination condition (nPop < 2)" 
     1953            self.assertTrue(warn in out) 
    19101954            return 
    19111955 
    … …  
    20902134    def _run_solver(self, iter_limit=False, **kwds): 
    20912135        from mystic.monitors import Monitor 
    2092         import numpy 
    20932136        from mystic.tools import random_seed 
    20942137        random_seed(123) 
    … …  
    21022145        solver.SetEvaluationMonitor(esow) 
    21032146        solver.SetGenerationMonitor(ssow) 
     2147        _stdout = trap_stdout() 
    21042148        solver.Solve(self.costfunction, self.term, **kwds) 
     2149        out = release_stdout(_stdout) 
    21052150        sol = solver.Solution() 
    21062151 
    … …  
    21152160        if iter_limit: 
    21162161            self.assertTrue(solver.generations < 2) 
     2162            warn = "Warning: Invalid termination condition (nPop < 2)" 
     2163            self.assertTrue(warn in out) 
    21172164            return 
    21182165 
    … …  
    23022349    def _run_solver(self, iter_limit=False, **kwds): 
    23032350        from mystic.monitors import Monitor 
    2304         import numpy 
    23052351        from mystic.tools import random_seed 
    23062352        random_seed(123) 
    … …  
    23142360        solver.SetEvaluationMonitor(esow) 
    23152361        solver.SetGenerationMonitor(ssow) 
     2362        _stdout = trap_stdout() 
    23162363        solver.Solve(self.costfunction, self.term, **kwds) 
     2364        out = release_stdout(_stdout) 
    23172365        sol = solver.Solution() 
    23182366 
    … …  
    23272375        if iter_limit: 
    23282376            self.assertTrue(solver.generations < 2) 
     2377            warn = "Warning: Invalid termination condition (nPop < 2)" 
     2378            self.assertTrue(warn in out) 
    23292379            return 
    23302380 
    … …  
    24902540 
    24912541    def setUp(self): 
     2542        import numpy 
    24922543        def ackley(x): 
    24932544            """Ackley's Path function. 
    … …  
    25092560    def _run_solver(self, iter_limit=False, **kwds): 
    25102561        from mystic.monitors import Monitor 
    2511         import numpy 
    25122562        from mystic.tools import random_seed 
    25132563        random_seed(123) 
    … …  
    25212571        solver.SetEvaluationMonitor(esow) 
    25222572        solver.SetGenerationMonitor(ssow) 
     2573        _stdout = trap_stdout() 
    25232574        solver.Solve(self.costfunction, self.term, **kwds) 
     2575        out = release_stdout(_stdout) 
    25242576        sol = solver.Solution() 
    25252577 
    … …  
    25342586        if iter_limit: 
    25352587            self.assertTrue(solver.generations < 2) 
     2588            warn = "Warning: Invalid termination condition (nPop < 2)" 
     2589            self.assertTrue(warn in out) 
    25362590            return 
    25372591 
    … …  
    26982752 
    26992753    def setUp(self): 
     2754        import numpy 
    27002755        def rastrigin(x): 
    27012756            """Rastrigin's function. Global minimum at xi=0, f(x)=0. Contains 
    … …  
    27152770    def _run_solver(self, iter_limit=False, **kwds): 
    27162771        from mystic.monitors import Monitor 
    2717         import numpy 
    27182772        from mystic.tools import random_seed 
    27192773        random_seed(123) 
    … …  
    27272781        solver.SetEvaluationMonitor(esow) 
    27282782        solver.SetGenerationMonitor(ssow) 
     2783        _stdout = trap_stdout() 
    27292784        solver.Solve(self.costfunction, self.term, **kwds) 
     2785        out = release_stdout(_stdout) 
    27302786        sol = solver.Solution() 
    27312787 
    … …  
    27402796        if iter_limit: 
    27412797            self.assertTrue(solver.generations < 2) 
     2798            warn = "Warning: Invalid termination condition (nPop < 2)" 
     2799            self.assertTrue(warn in out) 
    27422800            return 
    27432801 
    … …  
    29222980    def _run_solver(self, iter_limit=False, **kwds): 
    29232981        from mystic.monitors import Monitor 
    2924         import numpy 
    29252982        from mystic.tools import random_seed 
    29262983        random_seed(123) 
    … …  
    29342991        solver.SetEvaluationMonitor(esow) 
    29352992        solver.SetGenerationMonitor(ssow) 
     2993        _stdout = trap_stdout() 
    29362994        solver.Solve(self.costfunction, self.term, **kwds) 
     2995        out = release_stdout(_stdout) 
    29372996        sol = solver.Solution() 
    29382997 
    … …  
    29473006        if iter_limit: 
    29483007            self.assertTrue(solver.generations < 2) 
     3008            warn = "Warning: Invalid termination condition (nPop < 2)" 
     3009            self.assertTrue(warn in out) 
    29493010            return 
    29503011 
    … …  
    31333194    def _run_solver(self, iter_limit=False, **kwds): 
    31343195        from mystic.monitors import Monitor 
    3135         import numpy 
    31363196        from mystic.tools import random_seed 
    31373197        random_seed(123) 
    … …  
    31453205        solver.SetEvaluationMonitor(esow) 
    31463206        solver.SetGenerationMonitor(ssow) 
     3207        _stdout = trap_stdout() 
    31473208        solver.Solve(self.costfunction, self.term, **kwds) 
     3209        out = release_stdout(_stdout) 
    31483210        sol = solver.Solution() 
    31493211        #print '\n', sol 
    … …  
    31593221        if iter_limit: 
    31603222            self.assertTrue(solver.generations < 2) 
     3223            warn = "Warning: Invalid termination condition (nPop < 2)" 
     3224            self.assertTrue(warn in out) 
    31613225            return 
    31623226 
    … …  
    33483412    def _run_solver(self, iter_limit=False, **kwds): 
    33493413        from mystic.monitors import Monitor 
    3350         import numpy 
    33513414        from mystic.tools import random_seed 
    33523415        random_seed(123) 
    … …  
    33603423        solver.SetEvaluationMonitor(esow) 
    33613424        solver.SetGenerationMonitor(ssow) 
     3425        _stdout = trap_stdout() 
    33623426        solver.Solve(self.costfunction, self.term, **kwds) 
     3427        out = release_stdout(_stdout) 
    33633428        sol = solver.Solution() 
    33643429        #print '\n', sol 
    … …  
    33743439        if iter_limit: 
    33753440            self.assertTrue(solver.generations < 2) 
     3441            warn = "Warning: Invalid termination condition (nPop < 2)" 
     3442            self.assertTrue(warn in out) 
    33763443            return 
    33773444 
    … …  
    35543621    # Comment out suites in the list below to test specific test cost functions only 
    35553622    # (Testing all the problems will take some time) 
    3556     #allsuites = unittest.TestSuite([suite1, suite2, suite3, suite4, suite5, \ 
    3557     #                                suite6, suite7, suite8, suite9, suite10, \ 
    3558     #                                suite11, suite12, suite13, suite14,\ 
    3559     #                                suite15, suite16, suite17]) 
    3560     allsuites = unittest.TestSuite([suite1]) 
    3561     unittest.TextTestRunner(verbosity=2).run(allsuites) 
     3623    allsuites = unittest.TestSuite([suite1,   # Zimmermann 
     3624#                                   suite2,   # Rosenbrock 
     3625#                                   suite3,   # Corana 
     3626#                                   suite4,   # Quartic 
     3627#                                   suite5,   # Shekel 
     3628 #                                  suite6,   # Step 
     3629 #                                  suite7,   # Griewangk 
     3630#                                   suite8,   # Peaks 
     3631#                                   suite9,   # Venkataraman91 
     3632#                                   suite10,  # Schwefel 
     3633#                                   suite11,  # Easom 
     3634                                    suite12,  # RotatedEllipsoid 
     3635#                                   suite13,  # Ackley 
     3636#                                   suite14,  # Rastrigin 
     3637#                                   suite15,  # GoldsteinPrice 
     3638#                                   suite16,  # MathematicaDoc 
     3639 #                                  suite17,  # Paviani 
     3640                                    ]) 
     3641    unittest.TextTestRunner(verbosity=verbosity).run(allsuites) 
     3642 
     3643# EOF 

  • mystic/tests/test_solver_sanity.py

    r734 r735  
    1414from math import * 
    1515from mystic.math import almostEqual 
     16 
     17verbosity = 1 # Verbosity setting for unittests (default is 1). 
    1618 
    1719def trap_stdout(): #XXX: better with contextmanager? 
    … …  
    254256    suite1 = unittest.TestLoader().loadTestsFromTestCase(TestRosenbrock) 
    255257    allsuites = unittest.TestSuite([suite1]) 
    256 #   runner = unittest.TextTestRunner(verbosity=2) 
    257     runner = unittest.TextTestRunner() 
     258    runner = unittest.TextTestRunner(verbosity=verbosity) 
    258259 
    259260    my_maxiter = 0 
Note: See TracChangeset for help on using the changeset viewer.