Quartic Operator (#75)

* remove helpers from tests/models/mono/__init__.py

* model tests with inheritance structure

* parametric model tests with inheritance

* bugfix: fit_regselect_continuous() now returns self

* restructure operator tests for nonparametric (parametric still needed)

* nonparametric quartic operator

* v0.5.12 and update changelog

* fix interpolation tests

* small printing fix to TimedBlock, bug note for continuous regselect

Author: shanemcq18

docs/source/opinf/changelog.md

@@ -5,10 +5,16 @@
 New versions may introduce substantial new features or API adjustments.
 :::
 
+## Version 0.5.12
+
+- New `operators.QuarticOperator`, plus unit tests.
+- Reorganized some unit tests for models and operators to have OOP structure.
+- Bugfix: `fit_regselect_continuous()` now returns `self`
+
 ## Version 0.5.11
 
-- New scaling option for ``pre.ShiftScaleTransformer`` so that training snapshots have at maximum norm 1. Contributed by [@nicolearetz](https://github.com/nicolearetz).
-- Small clarifications to ``pre.ShiftScaleTransformer`` and updates to the ``pre`` documentation.
+- New scaling option for `pre.ShiftScaleTransformer` so that training snapshots have at maximum norm 1. Contributed by [@nicolearetz](https://github.com/nicolearetz).
+- Small clarifications to `pre.ShiftScaleTransformer` and updates to the `pre` documentation.
 
 ## Version 0.5.10
 

src/opinf/__init__.py

@@ -7,7 +7,7 @@
     https://github.com/Willcox-Research-Group/rom-operator-inference-Python3
 """
 
-__version__ = "0.5.11"
+__version__ = "0.5.12"
 
 from . import (
     basis,

src/opinf/models/mono/_base.py

@@ -7,16 +7,8 @@
 import warnings
 import numpy as np
 
-from ... import errors, lstsq
-from ...operators import (
-    ConstantOperator,
-    LinearOperator,
-    QuadraticOperator,
-    CubicOperator,
-    InputOperator,
-    StateInputOperator,
-    _utils as oputils,
-)
+from ... import errors, lstsq, operators as _operators
+from ...operators import _utils as oputils
 
 
 class _Model(abc.ABC):
@@ -135,32 +127,32 @@ def __iter__(self):
     @property
     def c_(self):
         """:class:`opinf.operators.ConstantOperator` (or ``None``)."""
-        return self._get_operator_of_type(ConstantOperator)
+        return self._get_operator_of_type(_operators.ConstantOperator)
 
     @property
     def A_(self):
         """:class:`opinf.operators.LinearOperator` (or ``None``)."""
-        return self._get_operator_of_type(LinearOperator)
+        return self._get_operator_of_type(_operators.LinearOperator)
 
     @property
     def H_(self):
         """:class:`opinf.operators.QuadraticOperator` (or ``None``)."""
-        return self._get_operator_of_type(QuadraticOperator)
+        return self._get_operator_of_type(_operators.QuadraticOperator)
 
     @property
     def G_(self):
         """:class:`opinf.operators.CubicOperator` (or ``None``)."""
-        return self._get_operator_of_type(CubicOperator)
+        return self._get_operator_of_type(_operators.CubicOperator)
 
     @property
     def B_(self):
         """:class:`opinf.operators.InputOperator` (or ``None``)."""
-        return self._get_operator_of_type(InputOperator)
+        return self._get_operator_of_type(_operators.InputOperator)
 
     @property
     def N_(self):
         """:class:`opinf.operators.StateInputOperator` (or ``None``)."""
-        return self._get_operator_of_type(StateInputOperator)
+        return self._get_operator_of_type(_operators.StateInputOperator)
 
     # Properties: dimensions --------------------------------------------------
     @staticmethod
@@ -362,27 +354,33 @@ def _check_is_trained(self):
             raise AttributeError("no state_dimension (call fit())")
         if self._has_inputs and (self.input_dimension is None):
             raise AttributeError("no input_dimension (call fit())")
-
-        for op in self.operators:
-            if op.entries is None:
-                raise AttributeError("model not trained (call fit())")
+        if any(oputils.is_uncalibrated(op) for op in self.operators):
+            raise AttributeError("model not trained (call fit())")
 
     def __eq__(self, other):
         """Two models are equal if they have equivalent operators."""
         if not isinstance(other, self.__class__):
             return False
         if len(self.operators) != len(other.operators):
             return False
-        for selfop, otherop in zip(self.operators, other.operators):
-            if selfop != otherop:
-                return False
         if self.state_dimension != other.state_dimension:
             return False
         if self.input_dimension != other.input_dimension:
             return False
+        marked = set()
+        for selfop in self.operators:
+            found = False
+            for i, otherop in enumerate(other.operators):
+                if selfop == otherop and i not in marked:
+                    found = True
+                    marked.add(i)
+                    break
+            if not found:
+                return False
         return True
 
     # Model persistence -------------------------------------------------------
     def copy(self):
         """Make a copy of the model."""
-        return self.__class__([op.copy() for op in self.operators])
+        sol = self.solver.copy() if self.solver is not None else None
+        return self.__class__([op.copy() for op in self.operators], solver=sol)

src/opinf/models/mono/_nonparametric.py

@@ -14,29 +14,8 @@
 import scipy.interpolate as spinterpolate
 
 from ._base import _Model
-from ... import errors, utils
-from ...operators import (
-    ConstantOperator,
-    LinearOperator,
-    QuadraticOperator,
-    CubicOperator,
-    InputOperator,
-    StateInputOperator,
-    _utils as oputils,
-)
-
-
-_operator_name2class = {
-    OpClass.__name__: OpClass
-    for OpClass in (
-        ConstantOperator,
-        LinearOperator,
-        QuadraticOperator,
-        CubicOperator,
-        InputOperator,
-        StateInputOperator,
-    )
-}
+from ... import errors, utils, operators as _operators
+from ...operators import _utils as oputils
 
 
 # Base class ==================================================================
@@ -58,12 +37,12 @@ class _NonparametricModel(_Model):
 
     # Properties: operators ---------------------------------------------------
     _operator_abbreviations = {
-        "c": ConstantOperator,
-        "A": LinearOperator,
-        "H": QuadraticOperator,
-        "G": CubicOperator,
-        "B": InputOperator,
-        "N": StateInputOperator,
+        "c": _operators.ConstantOperator,
+        "A": _operators.LinearOperator,
+        "H": _operators.QuadraticOperator,
+        "G": _operators.CubicOperator,
+        "B": _operators.InputOperator,
+        "N": _operators.StateInputOperator,
     }
 
     @staticmethod
@@ -460,8 +439,8 @@ def load(cls, loadfile: str):
             ops = []
             for i in range(num_operators):
                 gp = hf[f"operator_{i}"]
-                OpClassName = gp["meta"].attrs["class"]
-                ops.append(_operator_name2class[OpClassName].load(gp))
+                OpClass = getattr(_operators, gp["meta"].attrs["class"])
+                ops.append(OpClass.load(gp))
 
             # Construct the model.
             model = cls(ops)
@@ -1105,20 +1084,20 @@ class _FrozenSteadyModel(_FrozenMixin, SteadyModel):
     a parametric model.
     """
 
-    pass  # pragma: no cover
+    pass
 
 
 class _FrozenDiscreteModel(_FrozenMixin, DiscreteModel):
     """Nonparametric discrete-time model that is the evaluation of
     a parametric model.
     """
 
-    pass  # pragma: no cover
+    pass
 
 
 class _FrozenContinuousModel(_FrozenMixin, ContinuousModel):
     """Nonparametric continuous-time model that is the evaluation of
     a parametric model.
     """
 
-    pass  # pragma: no cover
+    pass

src/opinf/models/mono/_parametric.py

@@ -20,31 +20,8 @@
     _FrozenDiscreteModel,
     _FrozenContinuousModel,
 )
-from ... import errors, utils
-from ...operators import (
-    OperatorTemplate,
-    ParametricOperatorTemplate,
-    InterpConstantOperator,
-    InterpLinearOperator,
-    InterpQuadraticOperator,
-    InterpCubicOperator,
-    InterpInputOperator,
-    InterpStateInputOperator,
-    _utils as oputils,
-)
-
-
-_operator_name2class = {
-    OpClass.__name__: OpClass
-    for OpClass in (
-        InterpConstantOperator,
-        InterpLinearOperator,
-        InterpQuadraticOperator,
-        InterpCubicOperator,
-        InterpInputOperator,
-        InterpStateInputOperator,
-    )
-}
+from ... import errors, utils, operators as _operators
+from ...operators import _utils as oputils
 
 
 # Base classes ================================================================
@@ -82,8 +59,8 @@ def _isvalidoperator(self, op):
         return isinstance(
             op,
             (
-                OperatorTemplate,
-                ParametricOperatorTemplate,
+                _operators.OperatorTemplate,
+                _operators.ParametricOperatorTemplate,
             ),
         )
 
@@ -1124,12 +1101,12 @@ def set_interpolator(self, InterpolatorClass):
 
     # Properties: operators ---------------------------------------------------
     _operator_abbreviations = {
-        "c": InterpConstantOperator,
-        "A": InterpLinearOperator,
-        "H": InterpQuadraticOperator,
-        "G": InterpCubicOperator,
-        "B": InterpInputOperator,
-        "N": InterpStateInputOperator,
+        "c": _operators.InterpConstantOperator,
+        "A": _operators.InterpLinearOperator,
+        "H": _operators.InterpQuadraticOperator,
+        "G": _operators.InterpCubicOperator,
+        "B": _operators.InterpInputOperator,
+        "N": _operators.InterpStateInputOperator,
     }
 
     def _isvalidoperator(self, op):
@@ -1317,11 +1294,8 @@ def load(cls, loadfile: str, InterpolatorClass: type = None):
             for i in range(num_operators):
                 gp = hf[f"operator_{i}"]
                 OpClassName = gp["meta"].attrs["class"]
-                ops.append(
-                    _operator_name2class[OpClassName].load(
-                        gp, InterpolatorClass
-                    )
-                )
+                OpClass = getattr(_operators, OpClassName)
+                ops.append(OpClass.load(gp, InterpolatorClass))
 
             # Construct the model.
             model = cls(ops)