class_docstr: Windows generated 'dyadically'.
  
  These are successive windows of increasing fineness. The windows are as
  follows:
      Depth 1: The global window over the full data.
      Depth 2: The windows of the first and second halves of the dataset.
      Depth 3: The dataset is split into quarters, and we take the windows of
          each quarter.
      ...
      Depth n: For a dataset of length L, we generate windows
          [0:L/(2^n), L/(2^n):(2L)/(2^n), ..., (2^(n-1))L/2^n:L].
  Each depth also contains all previous depths.
  
  Note: Ensure the depth, n, is chosen such that L/(2^n) >= 1, else it will
      be too high for the dataset.
  
  Parameters
  ----------
  depth: int, The depth of the dyadic window, explained in the class
      description.
code: def call(self, length, _offset=0.0, _depth=0, _out=None):
      if _out is None:
          _out = [[] for _ in range(self.depth + 1)]
      _out[_depth].append(_Pair(int(_offset), int(_offset + length)))
  
      if _depth < self.depth:
          left = _Dyadic(self.depth)
          right = _Dyadic(self.depth)
          half_length = length / 2
          # The order of left then right is important, so that they add their
          # entries to _out in the correct order.
          left.call(half_length, _offset, _depth + 1, _out)
          right.call(
              half_length, _offset + half_length, _depth + 1, _out
          )
  
      return _out
  
imports: import collections
  import numpy
label_desc: Use image node_id 3 for calling the _Dyadic obj's underlying member method code with example usage: obj.call(length, _offset, _depth, _out) and returns: _out