ddt __str__()

Author: shanemcq18

docs/source/api/ddt.ipynb

@@ -191,7 +191,14 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Partial Estimation"
+    "## Finite Difference Estimators"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Partial Estimation"
    ]
   },
   {
@@ -248,7 +255,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Complete Estimation"
+    "### Complete Estimation"
    ]
   },
   {
@@ -294,7 +301,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Convenience Classes"
+    "### Convenience Classes"
    ]
   },
   {
@@ -312,6 +319,15 @@
    "outputs": [],
    "source": [
     "differ = opinf.ddt.UniformFiniteDifferencer(t, scheme=\"fwd1\")\n",
+    "print(differ)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "differ.verify(plot=True)"
    ]
   },
@@ -329,8 +345,46 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Custom Estimators\n",
-    "\n",
+    "## Interpolatory Estimators"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The {class}`InterpolationDerivativeEstimator` interpolates the state data using classes from {mod}`scipy.interpolate` and evaluates the derivative of the interpolant."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "estimator = opinf.ddt.InterpolationDerivativeEstimator(t, \"cubic\")\n",
+    "print(estimator)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "estimator.verify(plot=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Custom Estimators"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
     "New time derivative estimators can be defined by inheriting from {class}`DerivativeEstimatorTemplate`.\n",
     "Once implemented, the [`verify()`](opinf.ddt.DerivativeEstimatorTemplate.verify) method may be used to compare the results of [`estimate()`](opinf.ddt.DerivativeEstimatorTemplate.estimate) with true derivatives for a limited number of test cases."
    ]
@@ -387,7 +441,8 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The following class wraps {class}`scipy.interpolate.CubicSpline` and uses its `derivative()` method to compute the derivative."
+    "The following class wraps {class}`scipy.interpolate.CubicSpline` and uses its `derivative()` method to compute the derivative.\n",
+    "This is a simplified version of {class}`DerivativeEstimatorTemplate`."
    ]
   },
   {
@@ -407,7 +462,7 @@
     "\n",
     "    # Required methods --------------------------------------------------------\n",
     "    def estimate(self, states, inputs=None):\n",
-    "        \"\"\"Estimate the first time derivatives o’f the states.\"\"\"\n",
+    "        \"\"\"Estimate the first time derivatives of the states.\"\"\"\n",
     "        spline = spinterpolate.CubicSpline(\n",
     "            x=self.time_domain,\n",
     "            y=states,\n",
@@ -425,9 +480,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "t = np.linspace(0, 1, 200)\n",
     "spline_estimator = CubicSplineEstimator(t)\n",
-    "\n",
     "print(spline_estimator)"
    ]
   },

src/opinf/ddt/_base.py

@@ -12,7 +12,7 @@
 import scipy.linalg as la
 import matplotlib.pyplot as plt
 
-from .. import errors
+from .. import errors, utils
 
 
 class DerivativeEstimatorTemplate(abc.ABC):
@@ -86,6 +86,17 @@ def time_domain(self):
         """Time domain of the snapshot data, a (k,) ndarray."""
         return self.__t
 
+    def __str__(self):
+        """String representation: class name, time domain."""
+        out = [self.__class__.__name__]
+        t = self.time_domain
+        out.append(f"time_domain: {t.size} entries in [{t.min()}, {t.max()}]")
+        return "\n  ".join(out)
+
+    def __repr__(self):
+        """Unique ID + string representation."""
+        return utils.str2repr(self)
+
     # Main routine ------------------------------------------------------------
     def _check_dimensions(self, states, inputs, check_against_time=True):
         """Check dimensions and alignment of the state and inputs."""

src/opinf/ddt/_finite_difference.py

@@ -862,6 +862,13 @@ def scheme(self):
         """Finite difference engine."""
         return self.__scheme
 
+    def __str__(self):
+        """String representation: class name, time domain."""
+        head = DerivativeEstimatorTemplate.__str__(self)
+        tail = [f"time step: {self.dt:.2e}"]
+        tail.append(f"finite difference scheme: {self.scheme.__name__}()")
+        return f"{head}\n  " + "\n  ".join(tail)
+
     # Main routine ------------------------------------------------------------
     def estimate(self, states, inputs=None):
         r"""Estimate the first time derivatives of the states using
@@ -918,6 +925,12 @@ def __init__(self, time_domain):
                 errors.OpInfWarning,
             )
 
+    def __str__(self):
+        """String representation: class name, time domain."""
+        head = DerivativeEstimatorTemplate.__str__(self)
+        tail = "finite difference engine: np.gradient(edge_order=2)"
+        return f"{head}\n  {tail}"
+
     # Main routine ------------------------------------------------------------
     def estimate(self, states, inputs=None):
         r"""Estimate the first time derivatives of the states using

src/opinf/ddt/_interpolation.py

@@ -100,6 +100,26 @@ def __init__(
         self.__options = types.MappingProxyType(options)
 
     # Properties --------------------------------------------------------------
+    def __str__(self):
+        """String representation: class name, time domain."""
+        head = DerivativeEstimatorTemplate.__str__(self)
+        options = ", ".join(
+            [
+                f"{key}={repr(value)}"
+                for key, value in self.options.items()
+                if key != "axis"
+            ]
+        )
+        tail = [
+            f"InterpolatorClass: {self.InterpolatorClass.__name__}({options})"
+        ]
+        if (t2 := self.new_time_domain) is not None:
+            tail.append(
+                f"new_time_domain: {t2.size} entries "
+                f"in [{t2.min()}, {t2.max()}]"
+            )
+        return f"{head}\n  " + "\n  ".join(tail)
+
     @property
     def InterpolatorClass(self):
         """One-dimensional differentiable interpolator class."""

tests/ddt/test_finite_difference.py

@@ -79,6 +79,8 @@ def myscheme():
             differ = self.Diff(t, scheme=name)
             assert differ.scheme is func
 
+        repr(differ)
+
     def test_estimate(self, r=3, k=100, m=2):
         """Use verify() to validate estimate()
         for all registered difference schemes.
@@ -131,6 +133,7 @@ def test_init(self, k=100):
         t = t**2
         differ = self.Diff(t)
         assert differ.time_domain is t
+        repr(differ)
 
         # Too many dimensions.
         t3 = np.sort(np.random.random((3, 3, 3)))

tests/ddt/test_interpolation.py

@@ -41,6 +41,7 @@ def test_init(self, k=100):
         assert "axis" in est.options
         assert est.options["axis"] == 1
         assert est.new_time_domain.shape == t.shape
+        repr(est)
 
     def test_estimate(self, r=5, m=3, k=20):
         """Use verify() to test estimate()."""