Ejemplo n.º 1
0
 def setUp(self):
     self.model = ABCModel()
     self.param_names = ['a', 'b', 'c']
     self.default_bounds = {'a': (0, 1), 'b': (0, 1), 'c': (0, 1)}
     self.dtype = np.dtype([('a', np.float64), ('b', np.float64),
                            ('c', np.float64)])
     unittest.TestCase.setUp(self)
Ejemplo n.º 2
0
class TestBaseModelFunctions(unittest.TestCase):
    """Test all functions implemented in the BaseModel.
    
    These will not be tested for all models, but one as an example for one of 
    the models.
    """
    
    def setUp(self):
        self.model = ABCModel()
        self.param_names = ['a', 'b', 'c']
        self.default_bounds =  {'a': (0, 1),
                                'b': (0, 1),
                                'c': (0, 1)}
        self.dtype = np.dtype([('a', np.float64),
                               ('b', np.float64),
                               ('c', np.float64)])
        unittest.TestCase.setUp(self)
        
    def test_get_parameter_names(self):
        self.assertEqual(self.model.get_parameter_names(), self.param_names)
        
    def test_get_params(self):
        params = self.model.get_params()
        for param in self.param_names:
            msg = "Failed, because '{}' not in '{}'".format(param, params.keys)
            self.assertIn(param, params, msg)
            
    def test_get_default_bounds(self):
        bounds = self.model.get_default_bounds()
        self.assertDictEqual(bounds, self.default_bounds)
        
    def test_get_dtype(self):
        self.assertEqual(self.dtype, self.model.get_dtype())
        
    def test_random_params_in_default_bounds(self):
        params = self.model.get_random_params()
        bnds = self.default_bounds
        
        for p in self.param_names:
            msg = ["Failed for param: '{}', which has a ".format(p),
                   "a value of {}, but lower bounds ".format(params[p][0]),
                   "is {} and upper bound {}.".format(bnds[p][0], bnds[p][1])]
            self.assertTrue(bnds[p][0] <= params[p][0] <= bnds[p][1], 
                            "".join(msg))
    
    def test_get_multiple_random_param_sets(self):
        num = 24
        params = self.model.get_random_params(num=num)
        self.assertEqual(num, params.size)
              
    def test_set_params(self):
        rand_params = self.model.get_random_params()
        # convert rand_params array to dict:
        params = {}
        for p in self.param_names:
            params[p] = rand_params[p][0]
        self.model.set_params(params)
        self.assertDictEqual(params, self.model.get_params()) 
Ejemplo n.º 3
0
class TestABCModel(unittest.TestCase):
    """Test ABC-Model specific functions."""
    def setUp(self):
        self.model = ABCModel()
        unittest.TestCase.setUp(self)

    def test_model_subclass_of_basemodel(self):
        self.assertTrue(issubclass(self.model.__class__, BaseModel))

    def test_simulate_zero_rain(self):
        qsim = self.model.simulate(np.zeros(100))
        self.assertEqual(np.sum(qsim), 0)

    def test_simulate_negative_rain(self):
        with self.assertRaises(ValueError) as context:
            self.model.simulate([-1, 1, 1])
        expr = ("In the precipitation array are negative values."
                in str(context.exception))
        self.assertTrue(expr)
Ejemplo n.º 4
0
 def setUp(self):
     self.model = ABCModel()
     unittest.TestCase.setUp(self)
Ejemplo n.º 5
0
 def setUp(self):
     self.model = ABCModel()
     self.rain = np.random.random(100)
     unittest.TestCase.setUp(self)