visualdynamics 0.1.0a4__tar.gz → 0.1.0a5__tar.gz

{visualdynamics-0.1.0a4/src/visualdynamics.egg-info → visualdynamics-0.1.0a5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: visualdynamics
-Version: 0.1.0a4
+Version: 0.1.0a5
 Summary: Structural Dynamics Visualization: a units-aware structural dynamics analysis toolset
 Author-email: Brandon Zwink <bzwink@gmail.com>
 License-Expression: GPL-3.0-or-later
@@ -155,7 +155,7 @@ newer). To work on it, install from a clone:
 
 ```bash
 pip install -e .
-visualdynamics-gui                 # the desktop app
+visualdynamics                     # the desktop app
 ```
 
 ```python

{visualdynamics-0.1.0a4 → visualdynamics-0.1.0a5}/README.md

@@ -101,7 +101,7 @@ newer). To work on it, install from a clone:
 
 ```bash
 pip install -e .
-visualdynamics-gui                 # the desktop app
+visualdynamics                     # the desktop app
 ```
 
 ```python

{visualdynamics-0.1.0a4 → visualdynamics-0.1.0a5}/pyproject.toml

@@ -87,6 +87,10 @@ Source = "https://github.com/visualdynamics/visualdynamics"
 Issues = "https://github.com/visualdynamics/visualdynamics/issues"
 
 [project.scripts]
+# one window is the whole program, so the package's own name launches
+# it (Brandon, 2026-09-18); the longer spelling stays for anything
+# that learned it from the first alphas
+visualdynamics = "visualdynamics.gui:main"
 visualdynamics-gui = "visualdynamics.gui:main"
 
 [project.optional-dependencies]

{visualdynamics-0.1.0a4 → visualdynamics-0.1.0a5}/src/visualdynamics/__init__.py

@@ -76,7 +76,7 @@ from .units import (
 #: alpha, said in the version itself so the dialog, the About text, the
 #: installers and latest.json all say the same thing, and the first
 #: non-alpha release is offered as an upgrade (Brandon, 2026-09-11)
-__version__ = '0.1.0a4'
+__version__ = '0.1.0a5'
 
 
 def launch_gui(*paths: str, in_process: bool | None = None) -> Any:
@@ -103,7 +103,7 @@ def launch_gui(*paths: str, in_process: bool | None = None) -> Any:
     if in_process:
         from .gui import main
 
-        # `main` hands back Qt's exit status, which `visualdynamics-gui` wants as
+        # `main` hands back Qt's exit status, which the `visualdynamics` command wants as
         # its own and nothing else does — it is always 0, since nothing
         # here ever calls exit() with anything else. Swallowed, so
         # closing the window from a prompt does not answer with a bare

{visualdynamics-0.1.0a4 → visualdynamics-0.1.0a5}/src/visualdynamics/__main__.py

@@ -1,4 +1,4 @@
-"""`python -m visualdynamics` — the same entry point as the `visualdynamics-gui`
+"""`python -m visualdynamics` — the same entry point as the `visualdynamics`
 script, so the app starts without one being installed.
 """
 

{visualdynamics-0.1.0a4 → visualdynamics-0.1.0a5}/src/visualdynamics/core/author.py

@@ -67,6 +67,13 @@ STARTER_LEVEL = 1.0
 CONSTANT_TOLERANCE = 1e-6
 
 
+#: the grid a dragged or stepped limit lands on, in decibels. A
+#: whole decibel (Brandon, 2026-09-06: "never 1.5") was too coarse
+#: to place a limit where it was wanted (Brandon, 2026-09-18); the
+#: plot's handles snap to the same grid (`plot.bands.STEP`).
+LIMIT_STEP_DB = 0.25
+
+
 @dataclass
 class SpecificationDraft:
     """A specification being written, at any channels.
@@ -128,7 +135,15 @@ class SpecificationDraft:
     def __post_init__(self) -> None:
         from .validate import dofs as _dofs
 
-        self.channels = _dofs(list(self.channels), 'channel')
+        # what the object accepts, the sheet accepts: a virtual point's
+        # rows come in numbered '1', '2', '3' with no direction, since
+        # the controller's file names them nowhere, and the sheet
+        # refused to open on them (Brandon, 2026-09-18). Only an empty
+        # name is refused — a channel has to be called something
+        self.channels = _dofs(list(self.channels), 'channel',
+                              allow_unknown=True)
+        if any(not name for name in self.channels):
+            raise ValueError('every channel needs a name')
         self.dims = [str(d) for d in self.dims]
         self.frequencies = [float(f) for f in self.frequencies]
         self.levels = [[float(v) for v in row] for row in self.levels]
@@ -773,12 +788,13 @@ class SpecificationDraft:
 
     def shifted_band(self, kind: str, side: str, segments: Any,
                      decibels: float, channels: Any = None,
-                     step: float = 1.0) -> SpecificationDraft:
+                     step: float = LIMIT_STEP_DB) -> SpecificationDraft:
         """The same draft with one edge of a band moved — the drag on
         the plot, landed. A symmetric channel moves the other edge to
         match; a uniform channel moves every segment. The edge lands
-        on a multiple of `step` (Brandon, 2026-09-06: whole decibels,
-        never 1.5), and never nearer the target than one step.
+        on a multiple of `step` (`LIMIT_STEP_DB`: a quarter decibel,
+        Brandon 2026-09-18, from the whole decibel of 2026-09-06), and
+        never nearer the target than one step.
 
         Parameters
         ----------
@@ -793,7 +809,7 @@ class SpecificationDraft:
         channels : list of str, optional
             Which channels; all of them when omitted — the channels
             selected are the channels edited.
-        step : float, default 1.0
+        step : float, default LIMIT_STEP_DB
             The decibel grid the edge lands on.
 
         Returns
@@ -806,7 +822,7 @@ class SpecificationDraft:
 
     def with_band_edge(self, kind: str, side: str, segments: Any,
                        decibels: float, channels: Any = None,
-                       step: float = 1.0) -> SpecificationDraft:
+                       step: float = LIMIT_STEP_DB) -> SpecificationDraft:
         """The same draft with one edge of a band set to `decibels` on
         every channel — the drag on the plot, landed (Brandon,
         2026-09-06: a drag from 3 to 4 dB puts every selected channel
@@ -828,7 +844,7 @@ class SpecificationDraft:
             The edge's level, positive above the target.
         channels : list of str, optional
             Which channels; all of them when omitted.
-        step : float, default 1.0
+        step : float, default LIMIT_STEP_DB
             The decibel grid the edge lands on.
 
         Returns
@@ -1285,7 +1301,7 @@ class SpecificationDraft:
             return below if side == 'lower' else above
 
         def carried(values):
-            return _at_lines(old_f, values, lines)
+            return read_at_lines(old_f, values, lines)
 
         def autos_at(name, i):
             # the sheet inside its range, the specification's own
@@ -1493,7 +1509,7 @@ def uniform_spacing(frequencies: Any) -> float | None:
     return float(steps[0])
 
 
-def _at_lines(old_f: np.ndarray, values: np.ndarray,
+def read_at_lines(old_f: np.ndarray, values: np.ndarray,
               lines: np.ndarray) -> np.ndarray:
     """A specification's record read at new lines: its own value where
     a line is one of its own, and between them the power law a

{visualdynamics-0.1.0a4 → visualdynamics-0.1.0a5}/src/visualdynamics/core/averaging.py

@@ -80,7 +80,8 @@ def normalize_window(name: str | None) -> str:
 
 
 def from_span(averaging: Averaging, low: float, high: float,
-              sample_rate: float, samples: int) -> Averaging:
+              sample_rate: float, samples: int,
+              origin: float = 0.0) -> Averaging:
     """The averaging a dragged span means, in whole frames.
 
     The frame length and the window are the table's; a drag says only
@@ -91,8 +92,11 @@ def from_span(averaging: Averaging, low: float, high: float,
     """
     rate = sample_rate
     n = averaging.frame_length
+    # the drag is on the record's clock; the start counts from the
+    # record's beginning (`Averaging.stop` says why they differ)
+    low, high = float(low) - origin, float(high) - origin
     last_start = max(samples - n, 0) / rate
-    start = min(max(float(low), 0.0), last_start)
+    start = min(max(low, 0.0), last_start)
     moved = replace(averaging, start=start)
     width = round((float(high) - start) * rate)
     wanted = 1 if width < n else 1 + (width - n) // moved.hop
@@ -265,16 +269,28 @@ class Averaging:
     def start_sample(self, sample_rate: float) -> int:
         return round(self.start * sample_rate)
 
-    def stop(self, sample_rate: float) -> float:
-        """When the analysis ends, in seconds — derived, never stored."""
-        return (self.start_sample(sample_rate) + self.span) / sample_rate
+    def stop(self, sample_rate: float, origin: float = 0.0) -> float:
+        """When the analysis ends, in seconds — derived, never stored.
+
+        `origin` is the record's first instant. `start` counts from
+        the record's beginning, a sample count in disguise, and stays
+        so whatever the clock says; but a record whose clock does not
+        begin at zero — a truncation keeps its measured instants, an
+        import window reads the run's — is drawn and dragged on that
+        clock, and the frames of one that began at 1060 s were being
+        drawn at 0 s, off the plot (Brandon, 2026-09-18). Every
+        reading in seconds takes the origin here, once.
+        """
+        return origin + (self.start_sample(sample_rate) + self.span) / sample_rate
 
-    def frame_bounds(self, sample_rate: float) -> list[tuple[float, float]]:
-        """[(start, stop)] in seconds, one per frame, overlaps included —
-        what the time history plot shades."""
+    def frame_bounds(self, sample_rate: float,
+                     origin: float = 0.0) -> list[tuple[float, float]]:
+        """[(start, stop)] in seconds on the record's clock, one per
+        frame, overlaps included — what the time history plot shades.
+        `origin` as in `stop`."""
         first = self.start_sample(sample_rate)
-        return [((first + i * self.hop) / sample_rate,
-                 (first + i * self.hop + self.frame_length) / sample_rate)
+        return [(origin + (first + i * self.hop) / sample_rate,
+                 origin + (first + i * self.hop + self.frame_length) / sample_rate)
                 for i in range(self.frames)]
 
     def fits(self, samples: int, sample_rate: float) -> bool:

{visualdynamics-0.1.0a4 → visualdynamics-0.1.0a5}/src/visualdynamics/core/compliance.py

@@ -152,11 +152,26 @@ def written_band(frequencies: ArrayLike,
 
 def band_of(specification: Specification,
             record: int = 0) -> tuple[float, float] | None:
-    """(low, high) the specification actually says something over."""
-    return written_band(specification.abscissa, specification.ordinate[record])
+    """(low, high) the specification actually says something over.
+
+    A specification on bands says something over each band's whole
+    width, so its range is its outer bin edges — not its first and last
+    centers, which sit inside them and would shrink every comparison
+    against it by half a band at each end.
+    """
+    frequencies = np.asarray(specification.abscissa, dtype=float)
+    values = np.asarray(np.real(specification.ordinate[record]), dtype=float)
+    band = written_band(frequencies, values)
+    if band is None or getattr(specification, 'bandwidth', None) is None:
+        return band
+    left, right = specification.bin_bounds()
+    usable = (np.isfinite(frequencies) & (frequencies > 0.0)
+              & np.isfinite(values) & (values > 0.0))
+    return float(left[usable].min()), float(right[usable].max())
 
 
-def covered(lines: ArrayLike, low: float, high: float
+def covered(lines: ArrayLike, low: float, high: float,
+            widths: ArrayLike | None = None
             ) -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
     """Each measured bin cut to the part of it a band covers.
 
@@ -171,14 +186,15 @@ def covered(lines: ArrayLike, low: float, high: float
     if lines.size < 2:
         empty = np.zeros(lines.shape)
         return empty, empty, empty, np.zeros(lines.shape, dtype=bool)
-    widths = np.gradient(lines)
+    # a banded measurement's bins are its own, geometric ones
+    widths = np.gradient(lines) if widths is None else np.asarray(widths)
     start = np.maximum(lines - widths / 2.0, low)
     stop = np.minimum(lines + widths / 2.0, high)
     width = np.clip(stop - start, 0.0, None)
     return start, stop, width, (width > 0.0) & (width < widths * (1.0 - 1e-9))
 
 
-def _written_area(frequencies, values, low, high, reading):
+def _written_area(frequencies, values, low, high, reading, widths=None):
     """The area under a written curve, read the way its owner is.
 
     A limit belongs to a specification and is written the way the
@@ -192,7 +208,9 @@ def _written_area(frequencies, values, low, high, reading):
         return log_log_area(frequencies, values, low, high)
     from .octave import bin_bounds
 
-    left, right = bin_bounds(np.asarray(frequencies, dtype=float))
+    # a banded specification carries its own bins — geometric, from a
+    # standard — and the midpoints between its centers are not them
+    left, right = bin_bounds(np.asarray(frequencies, dtype=float), widths)
     if low is not None:
         left, right = np.maximum(left, low), np.maximum(right, low)
     if high is not None:
@@ -207,7 +225,9 @@ def _written_area(frequencies, values, low, high, reading):
 
 def outside(lines: ArrayLike, values: ArrayLike,
             spec_frequencies: ArrayLike, limit_values: ArrayLike,
-            over: bool = True, reading: str = 'log_log') -> np.ndarray:
+            over: bool = True, reading: str = 'log_log',
+            spec_widths: ArrayLike | None = None,
+            widths: ArrayLike | None = None) -> np.ndarray:
     """Which measured lines fell outside one written limit curve.
 
     In the middle of the band this is the plain comparison: the density
@@ -234,10 +254,10 @@ def outside(lines: ArrayLike, values: ArrayLike,
     band = written_band(spec_frequencies, limit_values)
     if band is None:
         return out
-    start, stop, width, cut = covered(lines, *band)
+    start, stop, width, cut = covered(lines, *band, widths)
     for i in np.flatnonzero(cut & real):
         asked = _written_area(spec_frequencies, limit_values,
-                              start[i], stop[i], reading)
+                              start[i], stop[i], reading, spec_widths)
         if not np.isfinite(asked):
             continue
         held = values[i] * width[i]
@@ -516,7 +536,9 @@ def exceedances(specification: Specification, measured: DataArray,
                      else outside(lines, got, specification.abscissa,
                                   written[spec_record], over,
                                   getattr(specification, 'interpolation',
-                                          'log_log')))
+                                          'log_log'),
+                                  getattr(specification, 'bandwidth', None),
+                                  getattr(measured, 'bandwidth', None)))
     return marks[0], marks[1]
 
 

{visualdynamics-0.1.0a4 → visualdynamics-0.1.0a5}/src/visualdynamics/core/data.py

@@ -58,6 +58,13 @@ from ..units import (
     si_factor,
     si_transform,
 )
+
+#: how much of an object's ordinate a display conversion holds at
+#: once, in bytes (`DataArray.display_blocks`): a quarter gigabyte is
+#: a few hundred records of a long run, and a block's transients —
+#: the gather, the scaling, the decimator's padding — are bounded by
+#: it whatever the object weighs
+DISPLAY_BLOCK_BYTES = 256 * 2 ** 20
 from .validate import DIRECTION_CODES
 from .validate import dofs as _dofs
 
@@ -853,17 +860,62 @@ class DataArray:
         rows = range(self.num_records) if records is None else list(records)
         out = np.empty((len(rows), self.ordinate.shape[1]),
                        dtype=self.ordinate.dtype)
-        by_dimension = {}
-        for position, record in enumerate(rows):
-            by_dimension.setdefault(self.ordinate_dim[record], []).append(
-                (position, record))
-        for dim, pairs in by_dimension.items():
-            positions = [position for position, _ in pairs]
-            source = self.ordinate[[record for _, record in pairs]]
-            out[positions] = (source if dim == UNKNOWN
-                              else unit_system.from_si(source, dim))
+        # converted a block of records at a time into slices of `out`:
+        # gathering every asked-for record and scaling the gather were
+        # two whole copies beside the answer, and on a 1.2 GB history
+        # the conversion alone peaked at three times its output
+        # (measured 2026-09-18, on the way to a 22 GB import that took
+        # the application down at 67 GB)
+        for start, stop, block in self.display_blocks(unit_system, rows):
+            out[start:stop] = block
         return out
 
+    def display_blocks(self, unit_system: UnitSystem,
+                       records: Iterable[int] | None = None,
+                       block_bytes: int | None = None):
+        """`display_ordinate` a block of records at a time.
+
+        Yields `(start, stop, values)`: positions within `records` and
+        the converted rows for them, each block at most `block_bytes`
+        (`DISPLAY_BLOCK_BYTES` by default) — so a reading that thins
+        every record before it draws it, the 3-D stage above all,
+        never holds a converted copy of the whole object. A record
+        larger than the block is still one block: a row is not split.
+
+        Parameters
+        ----------
+        unit_system : UnitSystem
+            The units to present the values in.
+        records : iterable of int, optional
+            Which records to convert. All of them when omitted.
+        block_bytes : int, optional
+            The most a block may hold, in bytes.
+
+        Yields
+        ------
+        tuple of (int, int, numpy.ndarray)
+            The block's positions among `records`, and its values in
+            display units.
+        """
+        rows = range(self.num_records) if records is None else list(records)
+        limit = DISPLAY_BLOCK_BYTES if block_bytes is None else int(block_bytes)
+        row_bytes = max(1, self.ordinate.shape[1] * self.ordinate.dtype.itemsize)
+        per_block = max(1, limit // row_bytes)
+        for start in range(0, len(rows), per_block):
+            chunk = rows[start:start + per_block]
+            block = np.empty((len(chunk), self.ordinate.shape[1]),
+                             dtype=self.ordinate.dtype)
+            by_dimension = {}
+            for position, record in enumerate(chunk):
+                by_dimension.setdefault(self.ordinate_dim[record], []).append(
+                    (position, record))
+            for dim, pairs in by_dimension.items():
+                positions = [position for position, _ in pairs]
+                source = self.ordinate[[record for _, record in pairs]]
+                block[positions] = (source if dim == UNKNOWN
+                                    else unit_system.from_si(source, dim))
+            yield start, start + len(chunk), block
+
     def __eq__(self, other: object) -> bool:
         if type(self) is not type(other):
             return NotImplemented
@@ -2535,26 +2587,11 @@ class Psd(DataArray):
         Psd
             The same power, arranged on proportional bands.
         """
-        from .octave import PER_OCTAVE, bands, resample
+        from .octave import resample
 
         frequencies = np.asarray(self.abscissa, dtype=float)
-        positive = frequencies[frequencies > 0.0]
-        if positive.size < 2:
-            raise ValueError(
-                'octave bands need a spectrum with frequency lines above '
-                'zero; this one has ' + str(positive.size))
-        # the range the bands have to span is the range the *bins*
-        # cover, not the range the centers do. A line at 0.5 Hz stands
-        # for a bin reaching down to 0.25, and a grid that started at
-        # the line would leave that half outside every band — which is
-        # a small loss of area and an unnecessary one.
-        reach, beyond = self.bin_bounds()
-        inside = reach[reach > 0.0]
-        low = (float(inside.min()) if inside.size else float(positive.min())) \
-            if low is None else float(low)
-        high = float(beyond.max()) if high is None else float(high)
-        per_octave = PER_OCTAVE if per_octave is None else int(per_octave)
-        centers, widths, bounds = bands(low, high, per_octave)
+        per_octave, centers, widths, bounds = self._octave_grid(
+            per_octave, low, high)
         banded = resample(frequencies, self.ordinate, bounds, widths,
                           source=self.bin_bounds())
         out = Psd(centers, banded,
@@ -2574,6 +2611,32 @@ class Psd(DataArray):
         out.scale_db = self.scale_db
         return out
 
+    def _octave_grid(self, per_octave, low, high):
+        """(per_octave, centers, widths, bounds): the bands this spectrum
+        bands onto — one grid, shared by the ordinate and, for a
+        specification, its limits."""
+        from .octave import PER_OCTAVE, bands
+
+        frequencies = np.asarray(self.abscissa, dtype=float)
+        positive = frequencies[frequencies > 0.0]
+        if positive.size < 2:
+            raise ValueError(
+                'octave bands need a spectrum with frequency lines above '
+                'zero; this one has ' + str(positive.size))
+        # the range the bands have to span is the range the *bins*
+        # cover, not the range the centers do. A line at 0.5 Hz stands
+        # for a bin reaching down to 0.25, and a grid that started at
+        # the line would leave that half outside every band — which is
+        # a small loss of area and an unnecessary one.
+        reach, beyond = self.bin_bounds()
+        inside = reach[reach > 0.0]
+        low = (float(inside.min()) if inside.size else float(positive.min())) \
+            if low is None else float(low)
+        high = float(beyond.max()) if high is None else float(high)
+        per_octave = PER_OCTAVE if per_octave is None else int(per_octave)
+        centers, widths, bounds = bands(low, high, per_octave)
+        return per_octave, centers, widths, bounds
+
     def bin_widths(self) -> np.ndarray:
         """The width of every line's own bin.
 
@@ -2792,6 +2855,146 @@ class Specification(Bounded, Psd):
     #: law. `compute_psds` says otherwise for one it computed.
     interpolation = 'log_log'
 
+    #: how finely a breakpoint curve's cross terms are read when a band
+    #: integrates them: points per band on a log grid
+    _CROSS_POINTS = 64
+
+    def to_octave(self, per_octave: int | None = None,
+                  low: float | None = None,
+                  high: float | None = None) -> Specification:
+        """This specification integrated onto proportional bands, its
+        warning and abort limits with it.
+
+        The same area rule as `Psd.to_octave`, read the way the object
+        is: a specification computed on lines is a density and each
+        line is a bin; one written at breakpoints is a power law
+        between them, and each band takes the exact area under that law
+        (`compliance.log_log_area`) over the part of the band the
+        specification covers, divided by the band's width. The limits
+        are curves written the same way and go through the same rule,
+        so a band's warning line stands in the same relation to its
+        target as the breakpoints did. Cross terms of a breakpoint
+        specification are not power laws (a phase is not), so they are
+        read onto a fine log grid the way the authoring sheet reads
+        them — magnitude log–log, phase straight — and integrated there.
+
+        The result is a density per band (`interpolation` 'bin', the
+        bands' widths carried), which is what a banded measurement is
+        compared against band for band. Brandon, 2026-09-18: the
+        specification and the measurement it judges should be
+        convertible alike, so a compliance can be read on bands at both
+        ends — reversing the earlier reasoning (PLAN.md, "Octave
+        bands") that a written curve needed no banding because the
+        comparison integrates it exactly; it does, and a banded
+        specification is still the object a person asks to see and
+        hand on.
+
+        Parameters
+        ----------
+        per_octave : int, optional
+            Bands per octave.
+        low, high : float, optional
+            The band to cover.
+
+        Returns
+        -------
+        Specification
+            The same power and the same limits, arranged on
+            proportional bands.
+        """
+        from .compliance import log_log_area, written_band
+        from .octave import resample
+
+        frequencies = np.asarray(self.abscissa, dtype=float)
+        rows = np.atleast_2d(self.ordinate)
+        if self.interpolation == 'log_log':
+            # the grid spans what the curve is written over — its first
+            # breakpoint to its last — not bins inferred between
+            # breakpoints, which put the first band at the midpoint of
+            # the first segment and lost everything below it
+            spans = [written_band(frequencies, np.abs(row)) for row in rows]
+            spans = [span for span in spans if span is not None]
+            if not spans:
+                raise ValueError('octave bands need a specification written '
+                                 'over a range of frequencies above zero')
+            from .octave import PER_OCTAVE, bands
+
+            per_octave = PER_OCTAVE if per_octave is None else int(per_octave)
+            low = min(span[0] for span in spans) if low is None else float(low)
+            high = (max(span[1] for span in spans) if high is None
+                    else float(high))
+            centers, widths, bounds = bands(low, high, per_octave)
+
+            def band_real(row):
+                out = np.full(len(centers), np.nan)
+                band = written_band(frequencies, row)
+                if band is None:
+                    return out
+                for k in range(len(centers)):
+                    lo = max(bounds[k], band[0])
+                    hi = min(bounds[k + 1], band[1])
+                    if hi > lo:
+                        out[k] = log_log_area(frequencies, row, lo, hi) \
+                            / widths[k]
+                return out
+
+            def band_complex(row):
+                from .author import read_at_lines
+
+                out = np.full(len(centers), np.nan, dtype=complex)
+                band = written_band(frequencies, np.abs(row))
+                if band is None:
+                    return out
+                for k in range(len(centers)):
+                    lo = max(bounds[k], band[0])
+                    hi = min(bounds[k + 1], band[1])
+                    if hi > lo:
+                        grid = np.geomspace(lo, hi, self._CROSS_POINTS)
+                        values = read_at_lines(frequencies, row, grid)
+                        out[k] = np.trapezoid(values, grid) / widths[k]
+                return out
+
+            banded = np.array([
+                band_complex(row) if np.iscomplexobj(row) and np.any(row.imag)
+                else band_real(np.real(row)) for row in rows])
+            limits = {name: np.array([band_real(row) for row in values])
+                      for name, values in self.limits.items()}
+        else:
+            per_octave, centers, widths, bounds = self._octave_grid(
+                per_octave, low, high)
+            source = self.bin_bounds()
+            banded = resample(frequencies, rows, bounds, widths, source=source)
+            limits = {}
+            for name, values in self.limits.items():
+                values = np.atleast_2d(values)
+                # a limit row that is all NaN is a cross term's, which
+                # has no limit of its own; the integration would read
+                # its NaN as nothing and hand back zeros
+                unwritten = ~np.isfinite(values).any(axis=1)
+                out = resample(frequencies, values, bounds, widths,
+                               source=source).astype(float)
+                out[unwritten] = np.nan
+                limits[name] = out
+        out = Specification(
+            centers, banded,
+            response_dof=list(self.response_dof),
+            reference_dof=(None if self.reference_dof is None
+                           else list(self.reference_dof)),
+            ordinate_dim=list(self.ordinate_dim),
+            ordinate_unit=list(self.ordinate_unit),
+            reference_unit=list(self.reference_unit),
+            dimension_hint=list(self.dimension_hint),
+            block=None if self.block is None else list(self.block),
+            bandwidth=widths,
+            comment=f'1/{per_octave} octave bands',
+            **limits)
+        out.interpolation = 'bin'
+        out.scale_db = self.scale_db
+        constraints = getattr(self, 'band_constraints', None)
+        if constraints:
+            out.band_constraints = dict(constraints)
+        return out
+
 
 class ShockSpecification(Bounded, Srs):
     """What a shock test was controlled to: an SRS, and its band.