auto yapf (to avoid future diffs)

Author: segasai

py/dynesty/bounding.py

@@ -69,8 +69,7 @@ def _slogdet_checked(matrix):
         raise ValueError(
             f"Invalid ellipsoid: covariance matrix has non-positive determinant "
             f"(sign={detsign}). This may indicate degenerate live points or "
-            f"numerical instability. Matrix shape: {matrix.shape}"
-        )
+            f"numerical instability. Matrix shape: {matrix.shape}")
     return detln
 
 

tests/test_dyn.py

@@ -37,6 +37,6 @@ def test_dyn():
                                            nlive=nlive,
                                            rstate=rstate)
     sampler.run_nested(dlogz_init=1, print_progress=printing)
-    assert (abs(LOGZ_TRUTH - sampler.results.logz[-1]) <
-            THRESHOLD * sampler.results.logzerr[-1])
+    assert (abs(LOGZ_TRUTH - sampler.results.logz[-1])
+            < THRESHOLD * sampler.results.logzerr[-1])
     print(sampler.citations)

tests/test_egg.py

@@ -42,8 +42,8 @@ def test_bounds(bound, sample):
                                     sample=sample,
                                     rstate=rstate)
     sampler.run_nested(dlogz=0.01, print_progress=printing)
-    assert (abs(LOGZ_TRUTH - sampler.results.logz[-1]) <
-            5. * sampler.results.logzerr[-1])
+    assert (abs(LOGZ_TRUTH - sampler.results.logz[-1])
+            < 5. * sampler.results.logzerr[-1])
 
 
 def test_ellipsoids_bootstrap():
@@ -59,5 +59,5 @@ def test_ellipsoids_bootstrap():
                                     bootstrap=5,
                                     rstate=rstate)
     sampler.run_nested(dlogz=0.01, print_progress=printing)
-    assert (abs(LOGZ_TRUTH - sampler.results.logz[-1]) <
-            5. * sampler.results.logzerr[-1])
+    assert (abs(LOGZ_TRUTH - sampler.results.logz[-1])
+            < 5. * sampler.results.logzerr[-1])

tests/test_highdim.py

@@ -127,10 +127,9 @@ def do_gaussians(sample='rslice',
 
 
 @pytest.mark.slow
-@pytest.mark.parametrize("ndim,sample",
-                         list(
-                             itertools.product([10, 30],
-                                               ['rslice', 'rwalk', 'unif'])))
+@pytest.mark.parametrize(
+    "ndim,sample",
+    list(itertools.product([10, 30], ['rslice', 'rwalk', 'unif'])))
 def test_run(ndim, sample):
     """
     Run the Gaussian likelihood test

tests/test_pathology.py

@@ -26,9 +26,9 @@ def prior_transform(x):
     return x * 2 - 1
 
 
-@pytest.mark.parametrize("dynamic,bound,sample",
-                         itertools.product([False, True], ['multi'],
-                                           ['unif', 'rslice', 'rwalk']))
+@pytest.mark.parametrize(
+    "dynamic,bound,sample",
+    itertools.product([False, True], ['multi'], ['unif', 'rslice', 'rwalk']))
 def test_pathology(dynamic, bound, sample):
     ndim = 2
     rstate = get_rstate()

tests/test_periodic.py

@@ -48,8 +48,8 @@ def test_periodic(sampler, dynamic):
                                     rstate=rstate,
                                     sample=sampler)
         dns.run_nested(dlogz=1, print_progress=printing)
-    assert (np.abs(dns.results['logz'][-1] - logz_true) <
-            thresh * dns.results['logzerr'][-1])
+    assert (np.abs(dns.results['logz'][-1] - logz_true)
+            < thresh * dns.results['logzerr'][-1])
 
 
 def test_error():

tests/test_proposal_stats.py

@@ -17,8 +17,7 @@ def __init__(self, corr=.95, prior_win=10):
         self.ndim = 3
         self.mean = np.linspace(-1, 1, self.ndim)
         self.cov = np.identity(self.ndim)
-        self.cov[self.cov ==
-                 0] = corr
+        self.cov[self.cov == 0] = corr
         self.cov_inv = linalg.inv(self.cov)
         self.lnorm = -0.5 * (np.log(2 * np.pi) * self.ndim +
                              np.log(linalg.det(self.cov)))
@@ -39,13 +38,14 @@ def prior_transform(self, u):
 def test_static_proposal_stats():
     rstate = get_rstate()
     g = Gaussian()
-    sampler = dynesty.NestedSampler(g.loglikelihood,
-                                    g.prior_transform,
-                                    g.ndim,
-                                    nlive=nlive,
-                                    rstate=rstate,
-                                    sample='rwalk',
-                                    blob=False) # blob=False to isolate proposal_stats
+    sampler = dynesty.NestedSampler(
+        g.loglikelihood,
+        g.prior_transform,
+        g.ndim,
+        nlive=nlive,
+        rstate=rstate,
+        sample='rwalk',
+        blob=False)  # blob=False to isolate proposal_stats
     sampler.run_nested(print_progress=printing, maxiter=100)
     res = sampler.results
     assert 'proposal_stats' in res
@@ -61,13 +61,14 @@ def test_static_proposal_stats():
 def test_dynamic_proposal_stats():
     rstate = get_rstate()
     g = Gaussian()
-    sampler = dynesty.DynamicNestedSampler(g.loglikelihood,
-                                           g.prior_transform,
-                                           g.ndim,
-                                           nlive=nlive,
-                                           rstate=rstate,
-                                           sample='unif',
-                                           blob=False) # blob=False to isolate proposal_stats
+    sampler = dynesty.DynamicNestedSampler(
+        g.loglikelihood,
+        g.prior_transform,
+        g.ndim,
+        nlive=nlive,
+        rstate=rstate,
+        sample='unif',
+        blob=False)  # blob=False to isolate proposal_stats
     sampler.run_nested(print_progress=printing, dlogz_init=1, maxiter_init=100)
     res = sampler.results
     assert 'proposal_stats' in res
@@ -84,16 +85,17 @@ def test_proposal_stats_length_consistency():
     """Test that proposal_stats array has same length as samples array"""
     rstate = get_rstate()
     g = Gaussian()
-    sampler = dynesty.NestedSampler(g.loglikelihood,
-                                    g.prior_transform,
-                                    g.ndim,
-                                    nlive=nlive//10,  # smaller for faster test
-                                    rstate=rstate,
-                                    sample='rwalk',
-                                    blob=False)
+    sampler = dynesty.NestedSampler(
+        g.loglikelihood,
+        g.prior_transform,
+        g.ndim,
+        nlive=nlive // 10,  # smaller for faster test
+        rstate=rstate,
+        sample='rwalk',
+        blob=False)
     sampler.run_nested(print_progress=printing, maxiter=50)
     res = sampler.results
-    
+
     # Check length consistency
     assert len(res['proposal_stats']) == len(res.samples)
 
@@ -102,30 +104,32 @@ def test_proposal_stats_different_samplers():
     """Test proposal_stats with different sampling methods"""
     rstate = get_rstate()
     g = Gaussian()
-    
+
     # Test different sampling methods
     sampling_methods = ['unif', 'rwalk', 'slice', 'rslice']
-    
+
     for sample_method in sampling_methods:
-        sampler = dynesty.NestedSampler(g.loglikelihood,
-                                        g.prior_transform,
-                                        g.ndim,
-                                        nlive=nlive//10,  # smaller for faster test
-                                        rstate=rstate,
-                                        sample=sample_method,
-                                        blob=False)
+        sampler = dynesty.NestedSampler(
+            g.loglikelihood,
+            g.prior_transform,
+            g.ndim,
+            nlive=nlive // 10,  # smaller for faster test
+            rstate=rstate,
+            sample=sample_method,
+            blob=False)
         sampler.run_nested(print_progress=printing, maxiter=30)
         res = sampler.results
-        
+
         # Basic checks
         assert 'proposal_stats' in res
         assert res['proposal_stats'] is not None
         assert len(res['proposal_stats']) == len(res['logl'])
-        
+
         # Check that we have some non-None proposal_stats
-        non_none_count = sum(1 for ps in res['proposal_stats'] if ps is not None)
+        non_none_count = sum(1 for ps in res['proposal_stats']
+                             if ps is not None)
         assert non_none_count > 0, f"No proposal_stats found for {sample_method}"
-        
+
         # Check structure of non-None entries
         for ps in res['proposal_stats']:
             if ps is not None:
@@ -139,42 +143,42 @@ def test_proposal_stats_nested_vs_dynamic():
     """Test proposal_stats consistency between nested and dynamic nested samplers"""
     rstate = get_rstate()
     g = Gaussian()
-    
+
     # Test with nested sampler
     sampler_nested = dynesty.NestedSampler(g.loglikelihood,
-                                          g.prior_transform,
-                                          g.ndim,
-                                          nlive=nlive//10,
-                                          rstate=rstate,
-                                          sample='rwalk',
-                                          blob=False)
+                                           g.prior_transform,
+                                           g.ndim,
+                                           nlive=nlive // 10,
+                                           rstate=rstate,
+                                           sample='rwalk',
+                                           blob=False)
     sampler_nested.run_nested(print_progress=printing, maxiter=30)
     res_nested = sampler_nested.results
-    
+
     # Test with dynamic nested sampler
     rstate = get_rstate()  # Reset to same state
     sampler_dynamic = dynesty.DynamicNestedSampler(g.loglikelihood,
-                                                  g.prior_transform,
-                                                  g.ndim,
-                                                  nlive=nlive//10,
-                                                  rstate=rstate,
-                                                  sample='rwalk',
-                                                  blob=False)
-    sampler_dynamic.run_nested(print_progress=printing, 
-                              dlogz_init=1, 
-                              maxiter_init=30)
+                                                   g.prior_transform,
+                                                   g.ndim,
+                                                   nlive=nlive // 10,
+                                                   rstate=rstate,
+                                                   sample='rwalk',
+                                                   blob=False)
+    sampler_dynamic.run_nested(print_progress=printing,
+                               dlogz_init=1,
+                               maxiter_init=30)
     res_dynamic = sampler_dynamic.results
-    
+
     # Both should have proposal_stats
     assert 'proposal_stats' in res_nested
     assert 'proposal_stats' in res_dynamic
     assert res_nested['proposal_stats'] is not None
     assert res_dynamic['proposal_stats'] is not None
-    
+
     # Both should have consistent lengths
     assert len(res_nested['proposal_stats']) == len(res_nested['logl'])
     assert len(res_dynamic['proposal_stats']) == len(res_dynamic['logl'])
-    
+
     # Both should have some non-None proposal_stats
     assert any(ps is not None for ps in res_nested['proposal_stats'])
     assert any(ps is not None for ps in res_dynamic['proposal_stats'])
@@ -187,67 +191,74 @@ def test_proposal_stats_content_validity():
     sampler = dynesty.NestedSampler(g.loglikelihood,
                                     g.prior_transform,
                                     g.ndim,
-                                    nlive=nlive//10,
+                                    nlive=nlive // 10,
                                     rstate=rstate,
                                     sample='rwalk',
                                     blob=False)
     sampler.run_nested(print_progress=printing, maxiter=30)
     res = sampler.results
-    
+
     # Check content of proposal_stats
     for i, ps in enumerate(res['proposal_stats']):
         if ps is not None:
             # Should be a dictionary
             assert isinstance(ps, dict), f"proposal_stats[{i}] is not a dict"
-            
+
             # Should contain n_proposals
             assert 'n_proposals' in ps, f"proposal_stats[{i}] missing 'n_proposals'"
-            
+
             # n_proposals should be a positive integer
             n_prop = ps['n_proposals']
-            assert isinstance(n_prop, (int, np.integer)), f"n_proposals is not an integer at index {i}"
+            assert isinstance(
+                n_prop,
+                (int,
+                 np.integer)), f"n_proposals is not an integer at index {i}"
             assert n_prop > 0, f"n_proposals should be positive at index {i}, got {n_prop}"
-            
+
             # If there are other keys, they should have reasonable values
             for key, value in ps.items():
                 if key != 'n_proposals':
                     # Any additional stats should be numeric and finite
                     if isinstance(value, (int, float, np.number)):
-                        assert np.isfinite(value), f"Non-finite value in proposal_stats[{i}]['{key}']"
+                        assert np.isfinite(
+                            value
+                        ), f"Non-finite value in proposal_stats[{i}]['{key}']"
 
 
 def test_proposal_stats_with_blob():
     """Test that proposal_stats work correctly when blob is also enabled"""
+
     def loglikelihood_with_blob(x):
         logl = -0.5 * np.sum(x**2)
         blob = {'param_sum': np.sum(x), 'param_max': np.max(x)}
         return logl, blob
-    
+
     def prior_transform(u):
         return 4 * (u - 0.5)  # uniform from -2 to 2
-    
+
     rstate = get_rstate()
-    sampler = dynesty.NestedSampler(loglikelihood_with_blob,
-                                    prior_transform,
-                                    3,  # ndim
-                                    nlive=nlive//10,
-                                    rstate=rstate,
-                                    sample='rwalk',
-                                    blob=True)
+    sampler = dynesty.NestedSampler(
+        loglikelihood_with_blob,
+        prior_transform,
+        3,  # ndim
+        nlive=nlive // 10,
+        rstate=rstate,
+        sample='rwalk',
+        blob=True)
     sampler.run_nested(print_progress=printing, maxiter=30)
     res = sampler.results
-    
+
     # Should have both blob and proposal_stats
     assert 'blob' in res
     assert 'proposal_stats' in res
     assert res['blob'] is not None
     assert res['proposal_stats'] is not None
-    
+
     # Both arrays should have same length as samples
     assert len(res['blob']) == len(res.samples)
     assert len(res['proposal_stats']) == len(res.samples)
     assert len(res['proposal_stats']) == len(res['logl'])
-    
+
     # Check that both contain valid data
     assert any(b is not None for b in res['blob'])
     assert any(ps is not None for ps in res['proposal_stats'])

tests/test_reflect.py

@@ -43,8 +43,8 @@ def test_periodic(sampler, dynamic):
                                     reflective=[0],
                                     rstate=rstate)
     dns.run_nested(print_progress=printing)
-    assert (np.abs(dns.results['logz'][-1] - logz_true) <
-            thresh * dns.results['logzerr'][-1])
+    assert (np.abs(dns.results['logz'][-1] - logz_true)
+            < thresh * dns.results['logzerr'][-1])
 
 
 def test_error():

tests/test_rosenbrock.py

@@ -79,7 +79,8 @@ def domany(sample='rslice', nlive=500, niter=100, nthreads=1):
     start = True
     rstate = get_rstate()
     seed = rstate.integers(int(1e9))
-    with (mp.get_context('spawn').Pool(nthreads) if nthreads > 1 else NullContextManager()) as pool:
+    with (mp.get_context('spawn').Pool(nthreads)
+          if nthreads > 1 else NullContextManager()) as pool:
         Cs = []
         for i in range(niter):
             if nthreads > 1:

tests/test_saver.py

@@ -34,7 +34,8 @@ def test_saving(dopool, maxiter):
     rstate = get_rstate()
     kw = {}
 
-    with (NullContextManager() if not dopool else mp.get_context('spawn').Pool(2)) as pool:
+    with (NullContextManager()
+          if not dopool else mp.get_context('spawn').Pool(2)) as pool:
         if dopool:
             pool = pool
             kw['pool'] = pool