Major update to nm_stats.py

Moved NumPy data array to nm_dimension class. Only one project now allowed. Major update to nm_stats.py using NumPy functions.

Author: jasonsethrothman

pyneuromatic/nm_channel.py

@@ -6,7 +6,7 @@
 """
 from pyneuromatic.nm_object import NMObject
 from pyneuromatic.nm_object_container import NMObjectContainer
-from pyneuromatic.nm_scale import NMScale, NMScaleX
+from pyneuromatic.nm_dimension import NMDimension, NMDimensionX
 import pyneuromatic.nm_utilities as nmu
 from typing import Dict, List, Union
 
@@ -45,8 +45,8 @@ def __init__(
         self,
         parent: Union[object, None] = None,
         name: str = "NMChannel",
-        xscale: Union[dict, nmu.NMScaleXType] = {},
-        yscale: Union[dict, nmu.NMScaleType] = {},
+        xscale: Union[dict, nmu.NMDimensionXType] = {},
+        yscale: Union[dict, nmu.NMDimensionType] = {},
         copy: Union[nmu.NMChannelType, None] = None,
     ) -> None:
         super().__init__(parent=parent, name=name, copy=copy)
@@ -63,7 +63,6 @@ def __init__(
         elif isinstance(copy, NMChannel):
             xscale = copy._NMChannel__x.scale
             yscale = copy._NMChannel__y.scale
-
             if self._folder is None:
                 # direct copy
                 self.__thedata = list(copy._NMChannel__thedata)
@@ -80,29 +79,29 @@ def __init__(
 
         if xscale is None:
             pass
-        elif isinstance(xscale, NMScaleX):
+        elif isinstance(xscale, NMDimensionX):
             self.__x = xscale
         elif isinstance(xscale, dict):
-            self.__x = NMScaleX(parent=self, name="xscale", scale=xscale)
+            self.__x = NMDimensionX(parent=self, name="xscale", scale=xscale)
         else:
-            e = nmu.typeerror(xscale, "xscale", "dictionary or NMScaleX")
+            e = nmu.typeerror(xscale, "xscale", "dictionary or NMDimensionX")
             raise TypeError(e)
 
         if yscale is None:
             pass
-        elif isinstance(yscale, NMScale):
+        elif isinstance(yscale, NMDimension):
             self.__y = yscale
         elif isinstance(yscale, dict):
-            self.__y = NMScale(parent=self, name="yscale", scale=yscale)
+            self.__y = NMDimension(parent=self, name="yscale", scale=yscale)
         else:
-            e = nmu.typeerror(yscale, "yscale", "dictionary or NMScale")
+            e = nmu.typeerror(yscale, "yscale", "dictionary or NMDimension")
             raise TypeError(e)
 
-        if not isinstance(self.__x, NMScaleX):
-            self.__x = NMScaleX(parent=self, name="xscale")
+        if not isinstance(self.__x, NMDimensionX):
+            self.__x = NMDimensionX(parent=self, name="xscale")
 
-        if not isinstance(self.__y, NMScale):
-            self.__y = NMScale(parent=self, name="yscale")
+        if not isinstance(self.__y, NMDimension):
+            self.__y = NMDimension(parent=self, name="yscale")
 
         return None
 
@@ -139,11 +138,11 @@ def data(self) -> List[nmu.NMDataType]:
         return self.__thedata
 
     @property
-    def x(self) -> nmu.NMScaleXType:
+    def x(self) -> nmu.NMDimensionXType:
         return self.__x
 
     @property
-    def y(self) -> nmu.NMScaleType:
+    def y(self) -> nmu.NMDimensionType:
         return self.__y
 
 
@@ -182,8 +181,8 @@ def content_type(self) -> str:
     def new(
         self,
         # name: str = 'A',  use name_next()
-        xscale: Union[dict, nmu.NMScaleXType] = {},
-        yscale: Union[dict, nmu.NMScaleType] = {},
+        xscale: Union[dict, nmu.NMDimensionXType] = {},
+        yscale: Union[dict, nmu.NMDimensionType] = {},
         select: bool = False,
         # quiet: bool = nmp.QUIET
     ) -> nmu.NMChannelType:

pyneuromatic/nm_data.py

@@ -3,19 +3,19 @@
 nmpy - NeuroMatic in Python
 Copyright 2019 Jason Rothman
 """
-# import math
+import math
 import numpy
 
 # import numpy.typing as npt # No module named 'numpy.typing
 from typing import Dict, Union
 
 from pyneuromatic.nm_channel import NMChannel
 from pyneuromatic.nm_dataseries import NMDataSeries, NMDataSeriesContainer
+from pyneuromatic.nm_dimension import NMDimension, NMDimensionX
 from pyneuromatic.nm_epoch import NMEpoch
 from pyneuromatic.nm_object import NMObject
 from pyneuromatic.nm_object_container import NMObjectContainer
 import pyneuromatic.nm_preferences as nmp
-from pyneuromatic.nm_scale import NMScale, NMScaleX
 import pyneuromatic.nm_utilities as nmu
 
 
@@ -45,38 +45,30 @@
 class NMData(NMObject):
     """
     NM Data class
-
-    np_array: NumPy N-dimensional array (ndarray)
     """
 
     def __init__(
         self,
         parent: object = None,
         name: str = "NMData",
-        np_array=None,  # TODO: typing
-        xscale: Union[dict, nmu.NMScaleXType] = {},
-        yscale: Union[dict, nmu.NMScaleType] = {},
-        # pass dictionary for independent scale
-        # pass reference to NMscale (master)
+        xdim: Union[nmu.NMDimensionXType, None] = None,
+        ydim: Union[nmu.NMDimensionType, None] = None,
         # dataseries: Union[nmu.NMDataSeriesType, None] = None,
         dataseries_channel: Union[nmu.NMChannelType, None] = None,
         dataseries_epoch: Union[nmu.NMEpochType, None] = None,
-        copy: nmu.NMDataType = None,  # see copy()
+        copy: nmu.NMDataType = None  # see copy()
     ) -> None:
         super().__init__(parent=parent, name=name, copy=copy)  # NMObject
 
-        self.__np_array = None
         # self.__dataseries = None
         self.__dataseries_channel = None
         self.__dataseries_epoch = None
 
         if copy is None:
             pass
         elif isinstance(copy, NMData):
-            if isinstance(copy.np_array, numpy.ndarray):
-                np_array = copy.np_array.copy()
-            xscale = copy._NMData__x.scale
-            yscale = copy._NMData__y.scale
+            xdim = copy.x.copy()
+            ydim = copy.y.copy()
             # TODO
             # dataseries = copy._NMData__dataseries
             # dataseries_channel = copy._NMData__dataseries_channel
@@ -85,33 +77,25 @@ def __init__(
             e = nmu.typeerror(copy, "copy", "NMData")
             raise TypeError(e)
 
-        if np_array is None:
-            pass
-        elif isinstance(np_array, numpy.ndarray):
-            self.__np_array = np_array
+        if xdim is None:
+            self.__x = NMDimensionX(self, "xscale")
+            self.__x.start = 0
+            self.__x.delta = 1
+        elif isinstance(xdim, NMDimensionX):
+            self.__x = xdim
         else:
-            e = nmu.typeerror(np_array, "np_array", "NumPy.ndarray")
+            e = nmu.typeerror(xdim, "xdim", "NMDimensionX")
             raise TypeError(e)
 
-        if isinstance(xscale, NMScaleX):
-            self.__x = xscale
-        elif xscale is None:
-            self.__x = NMScaleX(self, "xscale")
-        elif isinstance(xscale, dict):
-            self.__x = NMScaleX(self, "xscale", scale=xscale)
+        if ydim is None:
+            self.__y = NMDimension(self, "yscale")
+        elif isinstance(ydim, NMDimension):
+            self.__y = ydim
         else:
-            e = nmu.typeerror(xscale, "xscale", "dictionary or NMScaleX")
+            e = nmu.typeerror(ydim, "ydim", "NMDimension")
             raise TypeError(e)
 
-        if isinstance(yscale, NMScale):
-            self.__y = yscale
-        elif yscale is None:
-            self.__y = NMScale(self, "yscale")
-        elif isinstance(yscale, dict):
-            self.__y = NMScale(self, "yscale", scale=yscale)
-        else:
-            e = nmu.typeerror(yscale, "yscale", "dictionary or NMScale")
-            raise TypeError(e)
+        self.__x.ypair = self.__y.nparray
 
         self._dataseries_set(dataseries_channel, dataseries_epoch)
 
@@ -131,38 +115,10 @@ def __eq__(
         if not super().__eq__(other):
             return False
 
-        if self.x != other.x:
-            return False
-        if self.y != other.y:
+        if self.__x != other.x:
             return False
-        # print(isinstance(self.__np_array, numpy.ndarray))
-        if isinstance(self.__np_array, numpy.ndarray):
-            if isinstance(other.__np_array, numpy.ndarray):
-                if self.__np_array.dtype != other.np_array.dtype:
-                    return False
-                if self.__np_array.shape != other.np_array.shape:
-                    return False
-                if self.__np_array.nbytes != other.np_array.nbytes:
-                    return False
-                if not numpy.array_equal(self.__np_array, other.np_array):
-                    # array_equal returns false if both arrays filled with NANs
-                    if nmp.NAN_EQ_NAN:
-                        # compare array elements within a tolerance
-                        if not numpy.allclose(
-                            self.__np_array,
-                            other.np_array,
-                            rtol=0,
-                            atol=0,
-                            equal_nan=True,
-                        ):
-                            return False
-                    else:
-                        return False
-            else:
-                return False
-        elif isinstance(other.__np_array, numpy.ndarray):
+        if self.__y != other.y:
             return False
-
         if self._dataseries_channel != other._dataseries_channel:
             return False
         if self._dataseries_epoch != other._dataseries_epoch:
@@ -174,12 +130,8 @@ def __eq__(
     @property
     def parameters(self) -> Dict[str, object]:
         k = super().parameters
-        k.update({"xscale": self.x.scale})
-        k.update({"yscale": self.y.scale})
-        if isinstance(self.__np_array, numpy.ndarray):
-            k.update({"np_array": self.__np_array.dtype})
-        else:
-            k.update({"np_array": None})
+        k.update({"x": self.x.parameters})
+        k.update({"y": self.y.parameters})
         ds = self._dataseries
         if isinstance(ds, NMDataSeries):
             k.update({"dataseries": ds.name})
@@ -196,102 +148,19 @@ def parameters(self) -> Dict[str, object]:
         return k
 
     @property
-    def x(self) -> nmu.NMScaleXType:
+    def x(self) -> nmu.NMDimensionXType:
         if isinstance(self.__dataseries_channel, NMChannel):
-            if isinstance(self.__dataseries_channel.x, NMScaleX):
+            if isinstance(self.__dataseries_channel.x, NMDimensionX):
                 return self.__dataseries_channel.x
         return self.__x
 
     @property
-    def y(self) -> nmu.NMScaleType:
+    def y(self) -> nmu.NMDimensionType:
         if isinstance(self.__dataseries_channel, NMChannel):
-            if isinstance(self.__dataseries_channel.y, NMScale):
+            if isinstance(self.__dataseries_channel.y, NMDimension):
                 return self.__dataseries_channel.y
         return self.__y
 
-    @property
-    def np_array(self):
-        return self.__np_array
-
-    @np_array.setter
-    def np_array(self, np_array) -> None:
-        return self._np_array_set(np_array)
-
-    def _np_array_set(
-        self,
-        np_array,
-        # quiet=nmp.QUIET
-    ) -> None:
-        if np_array is None:
-            pass  # ok
-        elif not isinstance(np_array, numpy.ndarray):
-            e = nmu.typeerror(np_array, "np_array", "NumPy.ndarray")
-            raise TypeError(e)
-        if self.__np_array is None:
-            old = None
-        else:
-            old = self.__np_array.__array_interface__["data"][0]
-        self.__np_array = np_array
-        self.modified()
-        if self.__np_array is None:
-            new = None
-        else:
-            new = self.__np_array.__array_interface__["data"][0]
-        h = nmu.history_change("np_array reference", old, new)
-        # self.__notes_container.new(h)
-        # self._history(h, quiet=quiet)
-        return None
-
-    def np_array_make(
-        self,
-        shape,
-        fill_value=NP_FILL_VALUE,
-        dtype=NP_DTYPE,
-        order=NP_ORDER,
-        # quiet=nmp.QUIET
-    ):
-        # wrapper for NumPy.full
-        self.__np_array = numpy.full(shape, fill_value, dtype=dtype, order=order)
-        self.modified()
-        if not isinstance(self.__np_array, numpy.ndarray):
-            raise RuntimeError("failed to create numpy array")
-        n = (
-            "created numpy array (numpy.full): shape="
-            + str(shape)
-            + ", fill_value="
-            + str(fill_value)
-            + ", dtype="
-            + str(dtype)
-        )
-        # self.__notes_container.new(n)
-        # self._history(n, quiet=quiet)
-        return True
-
-    def np_array_make_random_normal(
-        self,
-        shape,
-        mean=0,
-        stdv=1,
-        # quiet=nmp.QUIET
-    ):
-        # wrapper for NumPy.random.normal
-        # dtype = float64
-        self.__np_array = numpy.random.normal(mean, stdv, shape)
-        self.modified()
-        if not isinstance(self.__np_array, numpy.ndarray):
-            raise RuntimeError("failed to create numpy array")
-        n = (
-            "created data array (numpy.random.normal): shape="
-            + str(shape)
-            + ", mean="
-            + str(mean)
-            + ", stdv="
-            + str(stdv)
-        )
-        # self.__notes_container.new(n)
-        # self._history(n, quiet=quiet)
-        return True
-
     @property
     def _dataseries(self) -> Union[nmu.NMDataSeriesType, None]:
         if not isinstance(self.__dataseries_channel, NMChannel):
@@ -370,20 +239,17 @@ def content_type(self) -> str:
     def new(
         self,
         name: str = "default",
-        np_array=None,  # TODO: typing
-        xscale: Union[dict, nmu.NMScaleXType] = {},
-        # TODO: can also be NMData?
-        yscale: Union[dict, nmu.NMScaleType] = {},
+        xdim: Union[nmu.NMDimensionXType, None] = None,
+        ydim: Union[nmu.NMDimensionType, None] = None,
         select: bool = False,
         # quiet: bool = nmp.QUIET
     ) -> nmu.NMDataType:
         name = self._newkey(name)
         d = NMData(
             parent=self._parent,
             name=name,
-            np_array=np_array,
-            xscale=xscale,
-            yscale=yscale,
+            xdim=xdim,
+            ydim=ydim
         )
         super().new(d, select=select)
         return d