Abscissa WIP

Author: lucas-wilkins

sasdata/abscissa.py

@@ -4,6 +4,8 @@
 from numpy._typing import ArrayLike
 
 from quantities.quantity import Quantity
+from exceptions import InterpretationError
+from util import is_increasing
 
 
 class Abscissa(ABC):
@@ -45,31 +47,78 @@ def axes(self) -> list[Quantity]:
         return self._axes
 
     @staticmethod
-    def determine(axes_data: list[Quantity[ArrayLike]], ordinate_data: Quantity[ArrayLike]) -> "Abscissa":
+    def _determine_error_message(axis_arrays: list[np.ndarray], ordinate_shape: tuple):
+        """ Error message for the `.determine` function"""
+
+        shape_string = ", ".join([str(axis.shape) for axis in axis_arrays])
+
+        return f"Cannot interpret array shapes axis: [{shape_string}], ordinate: {ordinate_shape}"
+
+    @staticmethod
+    def determine(axis_data: list[Quantity[ArrayLike]], ordinate_data: Quantity[ArrayLike]) -> "Abscissa":
         """ Get an Abscissa object that fits the combination of axes and data"""
 
-        # Different possibilites:
+        # Different posibilites:
         #   1: axes_data[i].shape == axes_data[j].shape == ordinate_data.shape
         #    1a: axis_data[i] is 1D =>
-        #      1a-i:  len(axes_data) == 1 => Grid type (trivially)
-        #      1a-ii: len(axes_data) != 1 => Mesh type
-        #    1b: axis_data[i] dimensionality matches len(axis_data) => Grid type
+        #      1a-i:  len(axes_data) == 1 => Grid type or Scatter type depending on sortedness
+        #      1a-ii: len(axes_data) != 1 => Scatter type
+        #    1b: axis_data[i] dimensionality matches len(axis_data) => Meshgrid type
         #    1c: other => Error
         #   2: (len(axes_data[0]), len(axes_data[1])... ) == ordinate_data.shape => Grid type
         #   3: None of the above => Error
 
         ordinate_shape = np.array(ordinate_data.value).shape
+        axis_arrays = [np.array(axis.value) for axis in axis_data]
+
+        # 1:
+        if all([axis.shape == ordinate_shape for axis in axis_arrays]):
+            # 1a:
+            if all([len(axis.shape)== 1 for axis in axis_arrays]):
+                # 1a-i:
+                if len(axis_arrays) == 1:
+                    # Is it sorted
+                    if is_increasing(axis_arrays[0]):
+                        return GridAbscissa(axis_data)
+                    else:
+                        return ScatterAbscissa(axis_data)
+                # 1a-ii
+                else:
+                    return ScatterAbscissa(axis_data)
+            # 1b
+            elif [len(axis.shape) == len(axis_arrays) for axis in axis_arrays] :
+
+                return MeshgridAbscissa(axis_data)
+
+            else:
+                raise InterpretationError(Abscissa._determine_error_message(axis_arrays, ordinate_shape))
+
+        elif all([len(axis.shape)== 1 for axis in axis_arrays]) and \
+                tuple([axis.shape[0] for axis in axis_arrays]) == ordinate_shape:
 
-        if len(ordinate_shape) == 1 and all([np.array(axis.value).shape == ordinate_shape for axis in axes_data]):
-            return ScatterAbscissa(axes_data)
+            # Require that they are sorted
+            if all([is_increasing(axis) for axis in axis_arrays]):
+
+                return GridAbscissa(axis_data)
+
+            else:
+                raise InterpretationError("Grid axes are not sorted")
+
+        else:
+            raise InterpretationError(Abscissa._determine_error_message(axis_arrays, ordinate_shape))
 
-        elif
 class GridAbscissa(Abscissa):
 
     @property
     def is_grid(self):
         return True
 
+class MeshgridAbscissa(Abscissa):
+
+    @property
+    def is_grid(self):
+        return True
+
 class ScatterAbscissa(Abscissa):
 
     @property

sasdata/exceptions.py

@@ -0,0 +1,2 @@
+class InterpretationError(Exception):
+    """ Error interpreting data """

sasdata/util.py

@@ -1,6 +1,8 @@
 from collections.abc import Callable
 from typing import TypeVar
 
+import numpy as np
+
 T = TypeVar("T")
 
 def cache[T](fun: Callable[[], T]):
@@ -16,3 +18,15 @@ def wrapper() -> T:
         return cache_state[1]
 
     return wrapper
+
+def is_increasing(data: np.ndarray):
+    """ Check if a 1D array is sorted in strictly increasing order"""
+    return np.all(data[1:] > data[:-1])
+
+def is_decreasing(data: np.ndarray):
+    """ Check if a 1D array is sorted in strictly decreasing order"""
+    return np.all(data[1:] < data[:-1])
+
+def is_sorted(data: np.ndarray):
+    """ Check if a 1D array is strictly sorted """
+    return is_increasing(data) or is_decreasing(data)

test/utest_asbscissa.py

@@ -0,0 +1,80 @@
+import numpy as np
+import pytest
+
+from abscissa import Abscissa, GridAbscissa, MeshgridAbscissa, ScatterAbscissa
+from quantities.quantity import Quantity
+
+from quantities.units import none
+
+from exceptions import InterpretationError
+
+
+def test_deterimine_1d_grid():
+    """ Test that 1D ordered data is grid type"""
+    q = Quantity(np.arange(10), units=none)
+
+    determined = Abscissa.determine([q], q)
+
+    assert isinstance(determined, GridAbscissa)
+
+
+def test_deterimine_1d_scatter():
+    """ Test that 1D unordered data is scatter type """
+    a = Quantity(np.array([1, 2, 3, 4, 5, 0, 9, 8, 7, 6]), units=none)
+    d = Quantity(np.arange(10), units=none)
+
+
+    determined = Abscissa.determine([a], d)
+
+    assert isinstance(determined, ScatterAbscissa)
+
+def test_2D_scatter():
+    """ Test the nD scatter case with 2D data """
+    q = Quantity(np.arange(10), units=none)
+
+    determined = Abscissa.determine([q, q], q)
+
+    assert isinstance(determined, ScatterAbscissa)
+
+def test_2D_meshgrid():
+    """ Test the meshgrid case with 2x5"""
+    q = Quantity(np.arange(10).reshape(2, 5), units=none)
+
+    determined = Abscissa.determine([q, q], q)
+
+    assert isinstance(determined, MeshgridAbscissa)
+
+
+def test_2D_grid():
+    """ Test the nD grid case with 2x5 """
+    a1 = Quantity(np.arange(2), units=none)
+    a2 = Quantity(np.arange(5), units=none)
+
+    d = Quantity(np.arange(10).reshape(2, 5), units=none)
+
+    determined = Abscissa.determine([a1, a2], d)
+
+    assert isinstance(determined, GridAbscissa)
+
+def test_2D_grid_axis_error():
+    """ Test the nD grid case with bad axes """
+
+    a1 = Quantity(np.arange(2), units=none)
+    a2 = Quantity(np.arange(5), units=none)
+
+    d = Quantity(np.arange(10).reshape(5, 2, 1), units=none)
+
+    with pytest.raises(InterpretationError):
+
+        Abscissa.determine([a1, a2], d)
+
+
+def test_2D_meshgrid_error_mismatched_dimensionality():
+    """ Test the nD meshgrid case with bad axes """
+
+    q = Quantity(np.arange(10).reshape(5, 2), units=none)
+
+    with pytest.raises(InterpretationError):
+
+        deterimined = Abscissa.determine([q, q, q], q) # three axes, each 2D
+        print(type(deterimined))