def test_post_rescaling_with_logit_update_bounds(reparam): """Assert an error is raised if using logit and update bounds""" reparam._update_bounds = True rescaling = 'logit' with pytest.raises(RuntimeError) as excinfo: RescaleToBounds.configure_post_rescaling(reparam, rescaling) assert 'Cannot use logit with update bounds' in str(excinfo.value)
def test_update_prime_prior_bounds_integration(): """Assert the prime prior bounds are correctly computed""" rescaling = ( lambda x: (x / 2, np.zeros_like(x)), lambda x: (2 * x, np.zeros_like(x)), ) reparam = RescaleToBounds( parameters=['x'], prior_bounds=[1000, 1001], prior='uniform', pre_rescaling=rescaling, offset=True, ) np.testing.assert_equal(reparam.offsets['x'], 500.25) np.testing.assert_array_equal(reparam.prior_bounds['x'], [1000, 1001]) np.testing.assert_array_equal(reparam.pre_prior_bounds['x'], [500, 500.5]) np.testing.assert_array_equal(reparam.bounds['x'], [-0.25, 0.25]) np.testing.assert_array_equal(reparam.prime_prior_bounds['x_prime'], [-1, 1]) x_prime = numpy_array_to_live_points( np.array([[-2], [-1], [0.5], [1], [10]]), ['x_prime']) log_prior = reparam.x_prime_log_prior(x_prime) expected = np.array([-np.inf, 0, 0, 0, -np.inf]) np.testing.assert_equal(log_prior, expected)
def test_pre_rescaling_with_functions(reparam): """Assert that specifying functions works as intended""" rescaling = (np.exp, np.log) RescaleToBounds.configure_pre_rescaling(reparam, rescaling) assert reparam.has_pre_rescaling is True assert reparam.pre_rescaling is np.exp assert reparam.pre_rescaling_inv is np.log
def test_pre_rescaling_with_str(reparam): """Assert that specifying a str works as intended""" from nessai.utils.rescaling import rescaling_functions rescaling = 'logit' RescaleToBounds.configure_pre_rescaling(reparam, rescaling) assert reparam.has_pre_rescaling is True assert reparam.pre_rescaling is rescaling_functions['logit'][0] assert reparam.pre_rescaling_inv is rescaling_functions['logit'][1]
def test_set_bounds(reparam): """Test the set bounds method.""" reparam.parameters = ['x'] reparam.rescale_bounds = {'x': np.array([-1, 1])} reparam.pre_rescaling = lambda x: (x / 2, np.zeros_like(x)) reparam.offsets = {'x': 1} RescaleToBounds.set_bounds(reparam, {'x': np.array([-10, 10])}) np.testing.assert_array_equal(reparam.pre_prior_bounds['x'], [-5, 5]) np.testing.assert_array_equal(reparam.bounds['x'], [-6, 4])
def test_default_post_rescaling(reparam): """Assert the default post-rescaling is the identity""" x = np.array([1, 2, 3]) expected_log_j = np.zeros(3) x_out, log_j = RescaleToBounds.post_rescaling(reparam, x) x_out_inv, log_j_inv = RescaleToBounds.post_rescaling_inv(reparam, x) np.testing.assert_array_equal(x_out, x) np.testing.assert_array_equal(x_out_inv, x) np.testing.assert_array_equal(log_j, expected_log_j) np.testing.assert_array_equal(log_j_inv, expected_log_j)
def test_boundary_inversion_invalid_type(reparam): """Assert an error is raised in the type is invalid""" with pytest.raises(TypeError) as excinfo: RescaleToBounds.__init__( reparam, parameters='x', prior_bounds=[0, 1], boundary_inversion='Yes', ) assert 'boundary_inversion must be a list, dict or bool' \ in str(excinfo.value)
def test_rescale_bounds_config(reparam, input, expected_value): """Assert the rescale bounds are set correctly.""" RescaleToBounds.__init__( reparam, parameters=['x', 'y'], prior_bounds={ 'x': [-1, 1], 'y': [0, 1] }, rescale_bounds=input, ) assert reparam.rescale_bounds == expected_value
def test_boundary_inversion_config(reparam, input, expected_value): """Assert the boundary inversion dict is set correctly""" RescaleToBounds.__init__( reparam, parameters=['x', 'y'], prior_bounds={ 'x': [0, 1], 'y': [0, 1] }, boundary_inversion=input, ) assert reparam.boundary_inversion == expected_value
def test_update_bounds(reparam): """Assert the correct values are returned""" reparam.offsets = {'x': 0.0, 'y': 1.0} reparam.pre_rescaling = MagicMock( side_effect=lambda x: (x, np.zeros_like(x))) reparam.parameters = ['x', 'y'] x = {'x': [-1, 0, 1], 'y': [-2, 0, 2]} RescaleToBounds.update_bounds(reparam, x) reparam.update_prime_prior_bounds.assert_called_once() reparam.pre_rescaling.assert_has_calls( [call(-1), call(1), call(-2), call(2)]) assert reparam.bounds == {'x': [-1, 1], 'y': [-3, 1]}
def test_rescale_bounds_incorrect_type(reparam): """Assert an error is raised if the rescale_bounds is an invalid type.""" with pytest.raises(TypeError) as excinfo: RescaleToBounds.__init__( reparam, parameters=['x', 'y'], prior_bounds={ 'x': [-1, 1], 'y': [0, 1] }, rescale_bounds=1, ) assert 'must be an instance of list or dict' in str(excinfo.value)
def test_rescale_bounds_dict_missing_params(reparam): """Assert an error is raised if the rescale_bounds dict is missing a parameter. """ with pytest.raises(RuntimeError) as excinfo: RescaleToBounds.__init__(reparam, parameters=['x', 'y'], prior_bounds={ 'x': [-1, 1], 'y': [0, 1] }, rescale_bounds={'x': [0, 1]}) assert 'Missing rescale bounds for parameters' in str(excinfo.value)
def test_detect_edges_without_inversion(reparam): """Assert detect edges cannot be used with boundary inversion""" with pytest.raises(RuntimeError) as excinfo: RescaleToBounds.__init__( reparam, parameters=['x', 'y'], prior_bounds={ 'x': [-1, 1], 'y': [0, 1] }, detect_edges=True, ) assert 'Must enable boundary inversion to use detect edges' \ in str(excinfo.value)
def test_post_rescaling_with_str(reparam): """Assert that specifying a str works as intended. Also test the config for the logit """ reparam._update_bounds = False reparam.parameters = ['x'] from nessai.utils.rescaling import rescaling_functions rescaling = 'logit' RescaleToBounds.configure_post_rescaling(reparam, rescaling) assert reparam.has_post_rescaling is True assert reparam.has_prime_prior is False assert reparam.post_rescaling is rescaling_functions['logit'][0] assert reparam.post_rescaling_inv is rescaling_functions['logit'][1] assert reparam.rescale_bounds == {'x': [0, 1]}
def test_set_offets(reparam): """Assert the offset are set correctly""" reparam.pre_rescaling = lambda x: (x / 2, 0.0) RescaleToBounds.__init__( reparam, parameters=['x', 'y'], prior_bounds={ 'x': [8, 32], 'y': [2, 4] }, offset=True, ) assert reparam.offsets == {'x': 10.0, 'y': 1.5}
def test_reparameterise(reparam): """Test the reparameterise function""" reparam.has_pre_rescaling = False reparam.has_post_rescaling = False reparam.parameters = ['x'] reparam.prime_parameters = ['x_prime'] reparam.offsets = {'x': 1.0} reparam.boundary_inversion = {} x = numpy_array_to_live_points(np.array([(1.0, ), (2.0, )]), reparam.parameters) x_prime_in = np.zeros([ 2, ], dtype=get_dtype(reparam.prime_parameters)) x_prime_val = np.array([0.0, 0.5]) log_j = np.zeros(x.size) reparam._rescale_to_bounds = MagicMock(return_value=(x_prime_val, np.array([0, 0.5]))) x_out, x_prime_out, log_j_out = \ RescaleToBounds.reparameterise(reparam, x, x_prime_in, log_j) np.testing.assert_array_equal( np.array([0.0, 1.0]), reparam._rescale_to_bounds.call_args_list[0][0][0]) assert reparam._rescale_to_bounds.call_args_list[0][0][1] == 'x' np.testing.assert_array_equal(x, x_out) np.testing.assert_array_equal(x_prime_out['x_prime'], x_prime_val) np.testing.assert_array_equal(log_j_out, np.array([0.0, 0.5]))
def test_inverse_reparameterise(reparam): """Test the inverse_reparameterise function""" reparam.has_pre_rescaling = False reparam.has_post_rescaling = False reparam.parameters = ['x'] reparam.prime_parameters = ['x_prime'] reparam.offsets = {'x': 1.0} reparam.boundary_inversion = {} x_prime = numpy_array_to_live_points(np.array([(1.0, ), (2.0, )]), reparam.prime_parameters) x_in = np.zeros([ 2, ], dtype=get_dtype(reparam.parameters)) x_val = np.array([0.0, 0.5]) log_j = np.zeros(x_prime.size) reparam._inverse_rescale_to_bounds = MagicMock( return_value=(x_val, np.array([0, 0.5]))) x_out, x_prime_out, log_j_out = \ RescaleToBounds.inverse_reparameterise(reparam, x_in, x_prime, log_j) # x[p] is updated in place, can't test inputs reparam._inverse_rescale_to_bounds.assert_called_once() assert \ reparam._inverse_rescale_to_bounds.call_args_list[0][0][1] == 'x' np.testing.assert_array_equal(x_prime_out, x_prime) np.testing.assert_array_equal(x_out['x'], x_val + 1.0) np.testing.assert_array_equal(log_j_out, np.array([0.0, 0.5]))
def test_add_single_reparameterisations(): """Test the core functionality of adding reparameterisations""" r = RescaleToBounds(parameters='x', prior_bounds=[0, 1]) c = CombinedReparameterisation() c.add_reparameterisations(r) assert c.parameters == ['x'] assert c.has_prime_prior is False
def test_reverse_inversion_not_applied(reparam): """Assert the reverse inversion works correctly""" reparam.parameters = ['x'] reparam.prime_parameters = ['x_prime'] reparam.offsets = {'x': 1.0} reparam._edges = {'x': False} reparam.bounds = {'x': [0, 5]} x_val = np.array([[1], [2]]) x = numpy_array_to_live_points(x_val, ['x']) x_prime = numpy_array_to_live_points(np.array([3, 4]), ['x_prime']) log_j = np.zeros(2) with patch('nessai.reparameterisations.inverse_rescale_minus_one_to_one', side_effect=lambda x, *args, **kwargs: (x, np.array([5, 6]))) as f: x_out, x_prime_out, log_j_out = RescaleToBounds._reverse_inversion( reparam, x, x_prime, log_j, 'x', 'x_prime', ) assert f.call_args_list[0][1] == {'xmin': 0, 'xmax': 5} # Should be output of rescaling minus offset np.testing.assert_array_equal(x_out['x'], np.array([2, 3])) # x_prime should be the same assert x_prime_out is x_prime # Jacobian should just include jacobian from rescaling np.testing.assert_array_equal(log_j_out, np.array([5, 6]))
def test_apply_inversion_detect_edge(reparam): """Assert detect edge is called with the correct arguments""" reparam.parameters = ['x'] reparam.prime_parameters = ['x_prime'] reparam.offsets = {'x': 1.0} reparam._edges = {'x': None} reparam.detect_edges_kwargs = {'allowed_bounds': ['lower']} reparam.bounds = {'x': [0, 5]} reparam.rescale_bounds = {'x': [0, 1]} x = numpy_array_to_live_points(np.array([1, 2]), ['x']) x_prime = numpy_array_to_live_points(np.array([3, 4]), ['x_prime']) log_j = np.zeros(2) with patch('nessai.reparameterisations.detect_edge', return_value=False) as mock_fn: _ = RescaleToBounds._apply_inversion(reparam, x, x_prime, log_j, 'x', 'x_prime', False, test=True) reparam.update_prime_prior_bounds.assert_called_once() mock_fn.assert_called_once_with( x_prime['x_prime'], test=True, allowed_bounds=['lower'], ) assert reparam._edges == {'x': False}
def test_reverse_inversion(reparam): """Assert the reverse inversion works correctly""" reparam.parameters = ['x'] reparam.prime_parameters = ['x_prime'] reparam.offsets = {'x': 1.0} reparam._edges = {'x': 'upper'} reparam.bounds = {'x': [0, 5]} x_val = np.array([[-0.7], [0.4]]) x = numpy_array_to_live_points(x_val, ['x']) x_prime = numpy_array_to_live_points(np.array([3, 4]), ['x_prime']) log_j = np.zeros(2) # Return the same value to check that the negative values are handled # correctly with patch('nessai.reparameterisations.inverse_rescale_zero_to_one', side_effect=lambda x, *args: (x, np.array([5, 6]))) as f: x_out, x_prime_out, log_j_out = RescaleToBounds._reverse_inversion( reparam, x, x_prime, log_j, 'x', 'x_prime', ) assert f.call_args_list[0][0][1] == 0.0 assert f.call_args_list[0][0][2] == 5.0 # Should be output of rescaling minus offset np.testing.assert_array_equal(x_out['x'], np.array([1.3, 1.6])) # x_prime should be the same assert x_prime_out is x_prime # Jacobian should just include jacobian from rescaling np.testing.assert_array_equal(log_j_out, np.array([5, 6]))
def test_pre_rescaling_integration(is_invertible, model): """Test the pre-scaling feature""" def forward(x): return np.log(x), -np.log(x) def inv(x): return np.exp(x), x.copy() reparam = RescaleToBounds( parameters='x', prior_bounds={'x': [1.0, np.e]}, pre_rescaling=(forward, inv), rescale_bounds=[-1.0, 1.0], ) x = numpy_array_to_live_points( np.array([[1.0], [np.e**0.5], [2.0], [np.e]]), ['x']) x_prime = numpy_array_to_live_points(np.empty([x.size, 1]), ['x_prime']) log_j = np.zeros(x.size) x_out, x_prime_out, log_j_out = reparam.reparameterise(x, x_prime, log_j) np.testing.assert_array_equal(x_out, x) np.testing.assert_array_equal(x_prime_out['x_prime'], np.array([-1, 0.0, 2 * np.log(2) - 1, 1])) np.testing.assert_array_equal(log_j_out, -np.log(x['x']) + np.log(2)) x_in = numpy_array_to_live_points(np.empty([x_prime_out.size, 1]), ['x']) log_j = np.zeros(x.size) x_out, x_prime_final, log_j_final = \ reparam.inverse_reparameterise(x_in, x_prime_out, log_j) np.testing.assert_array_equal(log_j_final, np.log(x_out['x']) - np.log(2)) np.testing.assert_array_equal(x_out['x'], x['x']) np.testing.assert_array_equal(x_prime_final, x_prime_out) np.testing.assert_array_equal(log_j_final, -log_j_out) # Trick to get a 1d model to test only x model._names.remove('y') model._bounds = {'x': [1.0, np.e]} assert is_invertible(reparam, model=model, decimal=12)
def test_apply_inversion_duplicate(reparam, inv_type, compute_radius): """Assert apply inversion with duplicate works as intended. This test also covers compute_radius=True """ reparam.parameters = ['x', 'y'] reparam.prime_parameters = ['x_prime', 'y'] reparam.offsets = {'x': 1.0} reparam._edges = {'x': 'lower'} reparam.bounds = {'x': [0, 5]} reparam.rescale_bounds = {'x': [0, 1]} reparam.boundary_inversion = {'x': inv_type} x_val = np.array([[1.2, 1.0], [1.7, 2.0]]) x_prime = numpy_array_to_live_points(x_val, ['x_prime', 'y']) x = numpy_array_to_live_points(np.array([[1, 2], [3, 4]]), ['x', 'y']) log_j = np.zeros(2) with patch('numpy.random.choice') as rnd, \ patch('nessai.reparameterisations.rescale_zero_to_one', side_effect=lambda x, *args: (x, np.array([5, 6]))) as f: x_out, x_prime_out, log_j_out = RescaleToBounds._apply_inversion( reparam, x, x_prime, log_j, 'x', 'x_prime', compute_radius, ) rnd.assert_not_called() assert f.call_args_list[0][0][1] == 0.0 assert f.call_args_list[0][0][2] == 5.0 # Output should be x_val minus offset # Then duplicated np.testing.assert_array_almost_equal( x_prime_out['x_prime'], np.array([0.2, 0.7, -0.2, -0.7]), decimal=10, ) np.testing.assert_array_almost_equal( x_prime_out['y'], np.array([1.0, 2.0, 1.0, 2.0]), decimal=10, ) # x should be the same but duplicated np.testing.assert_array_equal(x_out, np.concatenate([x, x])) # Jacobian should just include jacobian from rescaling but duplicated np.testing.assert_array_equal(log_j_out, np.array([5, 6, 5, 6]))
def test_reparameterise_boundary_inversion(reparam): """Test the reparameterise function with boundary inversion""" reparam.has_pre_rescaling = False reparam.has_post_rescaling = False reparam.parameters = ['x'] reparam.prime_parameters = ['x_prime'] reparam.offsets = {'x': 1.0} reparam.boundary_inversion = {'x': 'split'} x = numpy_array_to_live_points(np.array([(1.0, ), (2.0, )]), reparam.parameters) inversion_out = numpy_array_to_live_points( np.array([(-1.0, ), (-2.0, ), (1.0, ), (2.0, )]), reparam.prime_parameters) x_prime_in = np.zeros([ 2, ], dtype=get_dtype(reparam.prime_parameters)) log_j = np.zeros(x.size) x_ex = np.concatenate([x, x]) x_prime_ex = inversion_out log_j_ex = np.array([0, 0.5, 0, 0.5]) reparam._apply_inversion = MagicMock(return_value=(x_ex, x_prime_ex, log_j_ex)) x_out, x_prime_out, log_j_out = RescaleToBounds.reparameterise( reparam, x, x_prime_in, log_j, compute_radius=True, test='test', ) np.testing.assert_array_equal( reparam._apply_inversion.call_args_list[0][0][0], x) np.testing.assert_array_equal( reparam._apply_inversion.call_args_list[0][0][1], x_prime_in, ) np.testing.assert_array_equal( reparam._apply_inversion.call_args_list[0][0][2], log_j) assert reparam._apply_inversion.call_args_list[0][0][3] == 'x' assert reparam._apply_inversion.call_args_list[0][0][4] == 'x_prime' assert reparam._apply_inversion.call_args_list[0][0][5] is True assert reparam._apply_inversion.call_args_list[0][1] == {'test': 'test'} np.testing.assert_array_equal(x_out, x_ex) np.testing.assert_array_equal(x_prime_out, x_prime_ex) np.testing.assert_array_equal(log_j_out, log_j_ex)
def test_add_multiple_reparameterisations(model): """ Test adding multiple reparameterisations and using the reparameterisation. """ r = [ RescaleToBounds(parameters='x', prior_bounds=model.bounds['x'], prior='uniform'), RescaleToBounds(parameters='y', prior_bounds=model.bounds['y'], prior='uniform') ] reparam = CombinedReparameterisation() reparam.add_reparameterisations(r) assert reparam.parameters == ['x', 'y'] assert reparam.has_prime_prior is True n = 100 x = model.new_point(N=n) x_prime = np.zeros([n], dtype=get_dtype(reparam.prime_parameters)) log_j = 0 x_re, x_prime_re, log_j_re = reparam.reparameterise(x, x_prime, log_j) assert reparam.x_prime_log_prior(x_prime_re) is not None np.testing.assert_array_equal(x, x_re) x_in = np.zeros([n], dtype=get_dtype(reparam.parameters)) x_inv, x_prime_inv, log_j_inv = \ reparam.inverse_reparameterise(x_in, x_prime_re, log_j) np.testing.assert_array_equal(x, x_inv) np.testing.assert_array_equal(x_prime_re, x_prime_inv) np.testing.assert_array_equal(log_j_re, -log_j_inv)
def test_is_invertible_general_config(is_invertible, model, kwargs, decimal): """Test the invertibility of the reparameterisation General tests that don't check specific attributes but can check combinations. """ if decimal is None: decimal = 16 default_kwargs = dict( parameters=model.names, prior_bounds=model.bounds, ) default_kwargs.update(kwargs) reparam = RescaleToBounds(**default_kwargs) assert is_invertible(reparam, decimal=decimal)
def test_apply_inversion_split(reparam): """Assert apply inversion with split works as intended. Also tests "upper" setting. """ reparam.parameters = ['x'] reparam.prime_parameters = ['x_prime'] reparam.offsets = {'x': 1.0} reparam._edges = {'x': 'upper'} reparam.bounds = {'x': [0, 5]} reparam.rescale_bounds = {'x': [0, 1]} reparam.boundary_inversion = {'x': 'split'} x_val = np.array([[1.2], [1.7]]) x_prime = numpy_array_to_live_points(x_val, ['x_prime']) x = numpy_array_to_live_points(np.array([3, 4]), ['x']) log_j = np.zeros(2) with patch('numpy.random.choice', return_value=np.array([1])) as rnd, \ patch('nessai.reparameterisations.rescale_zero_to_one', side_effect=lambda x, *args: (x, np.array([5, 6]))) as f: x_out, x_prime_out, log_j_out = RescaleToBounds._apply_inversion( reparam, x, x_prime, log_j, 'x', 'x_prime', False, ) rnd.assert_called_once_with(2, 1, replace=False) assert f.call_args_list[0][0][1] == 0.0 assert f.call_args_list[0][0][2] == 5.0 # Output should be x_val minus offset # Then 1 - that for 'upper' # Then *= -1 with the output of rnd np.testing.assert_array_almost_equal( x_prime_out['x_prime'], np.array([0.8, -0.3]), decimal=10, ) # x should be the same assert x_out is x # Jacobian should just include jacobian from rescaling np.testing.assert_array_equal(log_j_out, np.array([5, 6]))
def test_inverse_reparameterise_pre_post_rescaling(reparam): """Test the inverse_reparameterise function with pre and post rescaling""" reparam.has_pre_rescaling = True reparam.has_post_rescaling = True reparam.parameters = ['x'] reparam.prime_parameters = ['x_prime'] reparam.offsets = {'x': 0.0} reparam.boundary_inversion = {} x_prime = numpy_array_to_live_points(np.array([(1.0, ), (2.0, )]), reparam.prime_parameters) x_in = np.zeros([ 2, ], dtype=get_dtype(reparam.parameters)) x_val = np.array([4.0, 8.0]) log_j = np.zeros(x_prime.size) reparam._inverse_rescale_to_bounds = MagicMock( return_value=(x_val, np.array([0, 0.5]))) reparam.pre_rescaling_inv = MagicMock(return_value=(np.array([0.5, 1.0]), np.array([0.5, 0.5]))) reparam.post_rescaling_inv = MagicMock(return_value=(np.array([1.0, 1.5]), np.array([2.0, 3.0]))) x_out, x_prime_out, log_j_out = \ RescaleToBounds.inverse_reparameterise(reparam, x_in, x_prime, log_j) np.testing.assert_array_equal( np.array([0.5, 1.0]), reparam._inverse_rescale_to_bounds.call_args_list[0][0][0]) assert reparam._inverse_rescale_to_bounds.call_args_list[0][0][1] == 'x' np.testing.assert_array_equal( reparam.post_rescaling_inv.call_args_list[0][0][0], x_prime['x_prime'], ) reparam.pre_rescaling_inv.assert_called_once() # x_prime gets replaces so change check inputs to the function reparam.post_rescaling_inv.assert_called_once() np.testing.assert_array_equal(x_prime, x_prime_out) np.testing.assert_array_equal(x_out['x'], np.array([0.5, 1.0])) np.testing.assert_array_equal(log_j_out, np.array([2.5, 4.0]))
def test_inverse_reparameterise_boundary_inversion(reparam): """Test the inverse_reparameterise function with boundary inversion""" reparam.has_pre_rescaling = False reparam.has_post_rescaling = False reparam.parameters = ['x'] reparam.prime_parameters = ['x'] reparam.offsets = {'x': 1.0} reparam.boundary_inversion = {'x': 'split'} x_prime = numpy_array_to_live_points(np.array([(-1.0, ), (2.0, )]), reparam.prime_parameters) inversion_out = numpy_array_to_live_points(np.array([(1.0, ), (2.0, )]), reparam.parameters) x_in = np.zeros([ 2, ], dtype=get_dtype(reparam.parameters)) log_j = np.zeros(x_prime.size) x_ex = inversion_out x_prime_ex = x_prime log_j_ex = np.array([0, 0.5]) reparam._reverse_inversion = MagicMock(return_value=(x_ex, x_prime_ex, log_j_ex)) x_out, x_prime_out, log_j_out = RescaleToBounds.inverse_reparameterise( reparam, x_in, x_prime, log_j, ) np.testing.assert_array_equal( reparam._reverse_inversion.call_args_list[0][0][0], x_in) np.testing.assert_array_equal( reparam._reverse_inversion.call_args_list[0][0][1], x_prime) np.testing.assert_array_equal( reparam._reverse_inversion.call_args_list[0][0][2], log_j) np.testing.assert_array_equal(x_out, x_ex) np.testing.assert_array_equal(x_prime_out, x_prime_ex) np.testing.assert_array_equal(log_j_out, log_j_ex)
def test_update_bounds_disabled(reparam, caplog): """Assert nothing happens in _update_bounds is False""" caplog.set_level('DEBUG') reparam._update_bounds = False RescaleToBounds.update_bounds(reparam, [0, 1]) assert 'Update bounds not enabled' in str(caplog.text)