o Add support for Floting-Point Bands and

new tests for the same. Use np.linspace instead of np.arange for
 latitude bands as it prevents the accumulation of precision errors.

Author: rajeeja

test/grid/integrate/test_zonal.py

@@ -111,6 +111,63 @@ def test_conservative_zonal_mean_basic(self, gridpath, datasetpath):
         assert result.shape == (len(bands) - 1,)
         assert np.all(np.isfinite(result.values))
 
+    def test_conservative_float_step_size(self, gridpath, datasetpath):
+        """Test conservative zonal mean with float step sizes."""
+        grid_path = gridpath("ugrid", "outCSne30", "outCSne30.ug")
+        data_path = datasetpath("ugrid", "outCSne30", "outCSne30_vortex.nc")
+        uxds = ux.open_dataset(grid_path, data_path)
+
+        # Test with float step size (5.5 degrees)
+        result = uxds["psi"].zonal_mean(lat=(-90, 90, 0.05), conservative=True)
+
+        # Should get valid results
+        assert len(result) > 0
+        assert np.all(np.isfinite(result.values))
+
+        # Test with reasonable float step size (no warning)
+        result = uxds["psi"].zonal_mean(lat=(-90, 90, 5.5), conservative=True)
+        expected_n_bands = int(np.ceil(180 / 5.5))
+        assert result.shape[0] == expected_n_bands
+        assert np.all(np.isfinite(result.values))
+
+    def test_conservative_near_pole(self, gridpath, datasetpath):
+        """Test conservative zonal mean with bands near the poles."""
+        grid_path = gridpath("ugrid", "outCSne30", "outCSne30.ug")
+        data_path = datasetpath("ugrid", "outCSne30", "outCSne30_vortex.nc")
+        uxds = ux.open_dataset(grid_path, data_path)
+
+        # Test near north pole with float step
+        bands_north = np.array([85.0, 87.5, 90.0])
+        result_north = uxds["psi"].zonal_mean(lat=bands_north, conservative=True)
+        assert result_north.shape == (2,)
+        assert np.all(np.isfinite(result_north.values))
+
+        # Test near south pole with float step
+        bands_south = np.array([-90.0, -87.5, -85.0])
+        result_south = uxds["psi"].zonal_mean(lat=bands_south, conservative=True)
+        assert result_south.shape == (2,)
+        assert np.all(np.isfinite(result_south.values))
+
+        # Test spanning pole with non-integer step
+        bands_span = np.array([88.5, 89.25, 90.0])
+        result_span = uxds["psi"].zonal_mean(lat=bands_span, conservative=True)
+        assert result_span.shape == (2,)
+        assert np.all(np.isfinite(result_span.values))
+
+    def test_conservative_step_size_validation(self, gridpath, datasetpath):
+        """Test that step size validation works correctly."""
+        grid_path = gridpath("ugrid", "outCSne30", "outCSne30.ug")
+        data_path = datasetpath("ugrid", "outCSne30", "outCSne30_vortex.nc")
+        uxds = ux.open_dataset(grid_path, data_path)
+
+        # Test negative step size
+        with pytest.raises(ValueError, match="Step size must be positive"):
+            uxds["psi"].zonal_mean(lat=(-90, 90, -10), conservative=True)
+
+        # Test zero step size
+        with pytest.raises(ValueError, match="Step size must be positive"):
+            uxds["psi"].zonal_mean(lat=(-90, 90, 0), conservative=True)
+
     def test_conservative_full_sphere_conservation(self, gridpath, datasetpath):
         """Test that single band covering entire sphere conserves global mean."""
         grid_path = gridpath("ugrid", "outCSne30", "outCSne30.ug")

uxarray/core/dataarray.py

@@ -565,7 +565,11 @@ def zonal_mean(self, lat=(-90, 90, 10), conservative: bool = False, **kwargs):
         if not conservative:
             # Non-conservative (traditional) zonal averaging
             if isinstance(lat, tuple):
-                latitudes = np.arange(lat[0], lat[1] + lat[2], lat[2])
+                start, end, step = lat
+                if step <= 0:
+                    raise ValueError("Step size must be positive.")
+                num_points = int(round((end - start) / step)) + 1
+                latitudes = np.linspace(start, end, num_points)
                 latitudes = np.clip(latitudes, -90, 90)
             elif isinstance(lat, (float, int)):
                 latitudes = [lat]
@@ -601,7 +605,13 @@ def zonal_mean(self, lat=(-90, 90, 10), conservative: bool = False, **kwargs):
         else:
             # Conservative zonal averaging
             if isinstance(lat, tuple):
-                edges = np.arange(lat[0], lat[1] + lat[2], lat[2])
+                start, end, step = lat
+                if step <= 0:
+                    raise ValueError(
+                        "Step size must be positive for conservative averaging."
+                    )
+                num_points = int(round((end - start) / step)) + 1
+                edges = np.linspace(start, end, num_points)
                 edges = np.clip(edges, -90, 90)
             elif isinstance(lat, (list, np.ndarray)):
                 edges = np.asarray(lat, dtype=float)