fitscube 2.3.1__tar.gz → 2.3.2__tar.gz

{fitscube-2.3.1 → fitscube-2.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fitscube
-Version: 2.3.1
+Version: 2.3.2
 Summary: A package to produce produce FITS cubes.
 Project-URL: Homepage, https://github.com/AlecThomson/fitscube
 Project-URL: Bug Tracker, https://github.com/AlecThomson/fitscube/issues

{fitscube-2.3.1 → fitscube-2.3.2}/fitscube/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.3.1'
-__version_tuple__ = version_tuple = (2, 3, 1)
+__version__ = version = '2.3.2'
+__version_tuple__ = version_tuple = (2, 3, 2)
 
 __commit_id__ = commit_id = None

{fitscube-2.3.1 → fitscube-2.3.2}/fitscube/combine_fits.py

@@ -132,6 +132,41 @@ def isin_close(
     return np.isclose(element[:, None], test_element, atol, rtol).any(1)
 
 
+def grid_step(diffs: ArrayLike) -> float:
+    """Recover the fundamental channel step from the observed diffs.
+
+    On a regular grid with missing channels every diff is an integer multiple
+    of the channel width, so the gcd of the diffs recovers that width even when
+    no two surviving channels are adjacent -- the case where ``min(diffs)``
+    overestimates the step (e.g. present channels 0, 3, 5 give ``min == 2`` but
+    the true step is 1). Falls back to ``min(diffs)`` if the gcd is numerically
+    unstable or does not divide every diff, so the common case is unchanged (any
+    surviving adjacent pair makes the gcd equal the minimum diff exactly).
+
+    Args:
+        diffs (ArrayLike): Differences between consecutive spec values.
+
+    Returns:
+        float: Estimated regular grid step.
+    """
+    diffs = np.abs(np.asarray(diffs, dtype=np.longdouble))
+    min_diff = np.min(diffs)
+    tol = np.max(diffs) * 1e-6
+
+    g = diffs[0]
+    for d in diffs[1:]:
+        a, b = (g, d) if g >= d else (d, g)
+        # Tolerant Euclid: stop once the remainder is within the noise floor.
+        while b > tol:
+            a, b = b, a % b
+        g = a
+
+    divides_all = np.all(np.abs(np.round(diffs / g) - diffs / g) <= 1e-3)
+    if g <= tol or not divides_all:
+        return float(min_diff)
+    return float(g)
+
+
 def even_spacing(specs: u.Quantity, time_domain_mode: bool = False) -> SpequencyInfo:
     """Make the frequencies or times evenly spaced.
 
@@ -143,9 +178,9 @@ def even_spacing(specs: u.Quantity, time_domain_mode: bool = False) -> Spequency
     """
     specs_arr = specs.value.astype(np.longdouble)
     diffs = np.diff(specs_arr)
-    min_diff: float = np.min(diffs)
-    # Create a new array with the minimum difference
-    new_specs = np_arange_fix(specs_arr[0], specs_arr[-1], min_diff)
+    step = grid_step(diffs)
+    # Create a new array with the fundamental grid step
+    new_specs = np_arange_fix(specs_arr[0], specs_arr[-1], step)
     missing_chan_idx = np.logical_not(
         isin_close(new_specs, specs_arr, time_domain_mode)
     )

{fitscube-2.3.1 → fitscube-2.3.2}/pyproject.toml

@@ -83,6 +83,7 @@ addopts = ["-ra", "--showlocals", "--strict-markers", "--strict-config"]
 xfail_strict = true
 filterwarnings = [
   "error",
+  "ignore:The TestRunner",
 ]
 log_cli_level = "INFO"
 testpaths = [

{fitscube-2.3.1 → fitscube-2.3.2}/tests/test_frequencies.py

@@ -6,7 +6,7 @@ import astropy.units as u
 import numpy as np
 import pytest
 from astropy.io import fits
-from fitscube.combine_fits import combine_fits, parse_specs
+from fitscube.combine_fits import combine_fits, even_spacing, parse_specs
 
 
 @pytest.fixture
@@ -108,3 +108,16 @@ def test_uneven_combine(
             assert chan in (1, 2)
             continue
         assert np.allclose(plane, image)
+
+
+def test_even_spacing_non_adjacent_gaps():
+    # Present channels 0, 3, 5 GHz on a 1 GHz grid (1, 2, 4 missing). No two
+    # surviving channels are adjacent, so min(diffs) == 2 GHz would mis-grid the
+    # axis to [0, 2, 4] and drop the real channels. The gcd of the diffs
+    # [3, 2] GHz recovers the true 1 GHz step.
+    specs = np.array([0.0, 3.0, 5.0]) * u.GHz
+    new_specs, missing_chan_idx = even_spacing(specs)
+    assert len(new_specs) == 6, "should rebuild the full 0..5 GHz grid"
+    assert missing_chan_idx.sum() == 3
+    expected_missing = np.array([False, True, True, False, True, False])
+    assert np.array_equal(missing_chan_idx, expected_missing)