MAINT: Review changes

Author: Carwyn Pelley

stratify/__init__.py

@@ -5,8 +5,7 @@
                        EXTRAPOLATE_NAN, EXTRAPOLATE_NEAREST,
                        EXTRAPOLATE_LINEAR, PyFuncExtrapolator,
                        PyFuncInterpolator)
-from ._bounded_vinterp import (interpolate as  # noqa: F401
-    interpolate_conservative)
+from ._bounded_vinterp import interpolate_conservative  # noqa: F401
 
 
 __version__ = '0.1a3.dev0'

stratify/_bounded_vinterp.py

@@ -5,9 +5,9 @@
 from ._conservative import conservative_interpolation
 
 
-def interpolate(z_target, z_src, fz_src, axis=-1):
+def interpolate_conservative(z_target, z_src, fz_src, axis=-1):
     """
-    Interface for optimised 1d interpolation across multiple dimensions.
+    1d conservative interpolation across multiple dimensions.
 
     This function provides the ability to perform 1d interpolation on datasets
     with more than one dimension. For instance, this function can be used to
@@ -117,7 +117,7 @@ def interpolate(z_target, z_src, fz_src, axis=-1):
                                              z_src_reshaped.shape[-1]])
     shape = int(np.product(z_target_reshaped.shape[1:-1]))
     z_target_reshaped = z_target_reshaped.reshape(
-            [z_target_reshaped.shape[0], shape, z_target_reshaped.shape[-1]])
+        [z_target_reshaped.shape[0], shape, z_target_reshaped.shape[-1]])
 
     result = conservative_interpolation(
         z_src_reshaped, z_target_reshaped, fz_src_reshaped)

stratify/_conservative.pyx

@@ -13,8 +13,8 @@ cdef calculate_weights(np.ndarray[np.float64_t, ndim=2] src_point,
     #    weight = overlap / delta
     cdef Py_ssize_t src_ind, tgt_ind
     cdef np.float64_t delta, weight
-    cdef np.ndarray[np.float64_t, ndim = 2] weights
-    cdef np.ndarray[np.float64_t, ndim = 1] src_cell, tgt_cell
+    cdef np.ndarray[np.float64_t, ndim=2] weights
+    cdef np.ndarray[np.float64_t, ndim=1] src_cell, tgt_cell
 
     weights = np.zeros([src_point.shape[0], tgt_point.shape[0]],
                        dtype=np.float64)
@@ -32,8 +32,8 @@ cdef apply_weights(np.ndarray[np.float64_t, ndim=3] src_point,
                    np.ndarray[np.float64_t, ndim=3] tgt_point,
                    np.ndarray[np.float64_t, ndim=3] src_data):
     cdef Py_ssize_t ind
-    cdef np.ndarray[np.float64_t, ndim = 3] results
-    cdef np.ndarray[np.float64_t, ndim = 2] weights
+    cdef np.ndarray[np.float64_t, ndim=3] results
+    cdef np.ndarray[np.float64_t, ndim=2] weights
     results = np.zeros(
         [src_data.shape[0], tgt_point.shape[0], src_data.shape[2]],
         dtype='float64')

stratify/tests/test_bounded_vinterp.py

@@ -27,15 +27,17 @@ def gen_bounds(self, start, stop, step):
 
     def test_target_half_resolution(self):
         target_bounds = self.gen_bounds(0, 7, 2)
-        res = bounded_vinterp.interpolate(target_bounds, self.bounds,
-                                          self.data, axis=1)
+        res = bounded_vinterp.interpolate_conservative(target_bounds,
+                                                       self.bounds, self.data,
+                                                       axis=1)
         target_data = np.ones((4, 3))*2
         assert_array_equal(res, target_data)
 
     def test_target_double_resolution(self):
         target_bounds = self.gen_bounds(0, 6.5, 0.5)
-        res = bounded_vinterp.interpolate(target_bounds, self.bounds,
-                                          self.data, axis=1)
+        res = bounded_vinterp.interpolate_conservative(target_bounds,
+                                                       self.bounds, self.data,
+                                                       axis=1)
         target_data = np.ones((4, 12))*.5
         assert_array_equal(res, target_data)
 
@@ -45,8 +47,9 @@ def test_no_broadcasting(self):
         # [1, axis_interpolation, 1].
         data = self.data[0]
         target_bounds = self.gen_bounds(0, 7, 2)
-        res = bounded_vinterp.interpolate(target_bounds, self.bounds, data,
-                                          axis=0)
+        res = bounded_vinterp.interpolate_conservative(target_bounds,
+                                                       self.bounds, data,
+                                                       axis=0)
         target_data = np.ones((3))*2
         assert_array_equal(res, target_data)
 
@@ -55,8 +58,9 @@ def test_target_extends_above_source(self):
         # |-|-|-|-|-|-|-|-| - Target
         source_bounds = self.gen_bounds(0, 7, 1)
         target_bounds = self.gen_bounds(0, 8, 1)
-        res = bounded_vinterp.interpolate(target_bounds, source_bounds,
-                                          self.data, axis=1)
+        res = bounded_vinterp.interpolate_conservative(target_bounds,
+                                                       source_bounds,
+                                                       self.data, axis=1)
         target_data = np.ones((4, 7))
         target_data[:, -1] = 0
         assert_array_equal(res, target_data)
@@ -66,8 +70,9 @@ def test_target_extends_below_source(self):
         # |-|-|-|-|-|-|-|-|   - Target
         source_bounds = self.gen_bounds(0, 7, 1)
         target_bounds = self.gen_bounds(-1, 7, 1)
-        res = bounded_vinterp.interpolate(target_bounds, source_bounds,
-                                          self.data, axis=1)
+        res = bounded_vinterp.interpolate_conservative(target_bounds,
+                                                       source_bounds,
+                                                       self.data, axis=1)
         target_data = np.ones((4, 7))
         target_data[:, 0] = 0
         assert_array_equal(res, target_data)
@@ -90,8 +95,9 @@ def gen_bounds(self, start, stop, step):
 
     def test_target_half_resolution(self):
         target_bounds = self.gen_bounds(0, 7, 2)
-        res = bounded_vinterp.interpolate(target_bounds, self.bounds,
-                                          self.data, axis=1)
+        res = bounded_vinterp.interpolate_conservative(target_bounds,
+                                                       self.bounds, self.data,
+                                                       axis=1)
 
         target_data = np.ones((2, 3, 4, 3))*2
         assert_array_equal(res, target_data)
@@ -103,14 +109,16 @@ def test_target_half_resolution_alt_axis(self):
         target_bounds = self.gen_bounds(0, 7, 2)
         target_bounds = target_bounds.transpose((1, 0, 2, 3))
 
-        res = bounded_vinterp.interpolate(target_bounds, bounds, data, axis=2)
+        res = bounded_vinterp.interpolate_conservative(target_bounds, bounds,
+                                                       data, axis=2)
         target_data = np.ones((2, 4, 3, 3))*2
         assert_array_equal(res, target_data)
 
     def test_target_double_resolution(self):
         target_bounds = self.gen_bounds(0, 6.5, 0.5)
-        res = bounded_vinterp.interpolate(target_bounds, self.bounds,
-                                          self.data, axis=1)
+        res = bounded_vinterp.interpolate_conservative(target_bounds,
+                                                       self.bounds,
+                                                       self.data, axis=1)
         target_data = np.ones((2, 12, 4, 3))*.5
         assert_array_equal(res, target_data)
 
@@ -123,7 +131,8 @@ def test_mismatch_source_target_level_dimensionality(self):
 
         msg = 'Expecting source and target levels dimensionality'
         with self.assertRaisesRegexp(ValueError, msg):
-            bounded_vinterp.interpolate(target_bounds, source_bounds, data)
+            bounded_vinterp.interpolate_conservative(target_bounds,
+                                                     source_bounds, data)
 
     def test_mismatch_source_target_level_shape(self):
         # The source and target levels should have identical shape, other than
@@ -134,8 +143,9 @@ def test_mismatch_source_target_level_shape(self):
 
         msg = 'Expecting the shape of the source and target levels'
         with self.assertRaisesRegexp(ValueError, msg):
-            bounded_vinterp.interpolate(target_bounds, source_bounds, data,
-                                        axis=0)
+            bounded_vinterp.interpolate_conservative(target_bounds,
+                                                     source_bounds, data,
+                                                     axis=0)
 
     def test_mismatch_between_source_levels_source_data(self):
         # The source levels should reflect the shape of the data.
@@ -145,8 +155,9 @@ def test_mismatch_between_source_levels_source_data(self):
 
         msg = 'The provided data is not of compatible shape'
         with self.assertRaisesRegexp(ValueError, msg):
-            bounded_vinterp.interpolate(target_bounds, source_bounds, data,
-                                        axis=0)
+            bounded_vinterp.interpolate_conservative(target_bounds,
+                                                     source_bounds, data,
+                                                     axis=0)
 
     def test_unexpected_bounds_shape(self):
         # Expecting bounds of size 2 (that is the upper and lower).
@@ -157,8 +168,9 @@ def test_unexpected_bounds_shape(self):
 
         msg = 'Unexpected source and target bounds shape. shape\[-1\] != 2'
         with self.assertRaisesRegexp(ValueError, msg):
-            bounded_vinterp.interpolate(target_bounds, source_bounds, data,
-                                        axis=0)
+            bounded_vinterp.interpolate_conservative(target_bounds,
+                                                     source_bounds, data,
+                                                     axis=0)
 
     def test_not_conservative(self):
         # Where the target does not cover the full extent of the source.
@@ -175,8 +187,9 @@ def gen_bounds(start, stop, step):
 
         msg = 'Weights calculation yields a less than conservative result.'
         with self.assertRaisesRegexp(ValueError, msg):
-            bounded_vinterp.interpolate(target_bounds, source_bounds, data,
-                                        axis=1)
+            bounded_vinterp.interpolate_conservative(target_bounds,
+                                                     source_bounds, data,
+                                                     axis=1)
 
 
 if __name__ == '__main__':