docs: public double nextDoubleValue() {
      if (hasNextValue(true)) {
        final double y0 = ((timestamps[pos] & FLAG_FLOAT) == FLAG_FLOAT
                           ? Double.longBitsToDouble(values[pos])
                           : values[pos]);
        if (current == pos) {
          //LOG.debug("Exact match, no lerp needed");
          return y0;
        }
        if (rate) {
          // No LERP for the rate. Just uses the rate of any previous timestamp.
          // If x0 is smaller than the current time stamp 'x', we just use
          // y0 as a current rate of the 'pos' span. If x0 is bigger than the
          // current timestamp 'x', we don't go back further and just use y0
          // instead. It happens only at the beginning of iteration.
          // TODO: Use the next rate the time range of which includes the current
          // timestamp 'x'.
          return y0;
        }
        final long x = timestamps[current] & TIME_MASK;
        final long x0 = timestamps[pos] & TIME_MASK;
        if (x == x0) {
          //LOG.debug("No lerp needed x == x0 (" + x + " == "+x0+") => " + y0);
          return y0;
        }
        final int next = pos + iterators.length;
        final double y1 = ((timestamps[next] & FLAG_FLOAT) == FLAG_FLOAT
                           ? Double.longBitsToDouble(values[next])
                           : values[next]);
        final long x1 = timestamps[next] & TIME_MASK;
        if (x == x1) {
          //LOG.debug("No lerp needed x == x1 (" + x + " == "+x1+") => " + y1);
          return y1;
        }
        if ((x1 & Const.MILLISECOND_MASK) != 0) {
          throw new AssertionError("x1=" + x1 + " in " + this);
        }
        final double r;
        switch (method) {
        case LERP:
          r = y0 + (x - x0) * (y1 - y0) / (x1 - x0);
          //LOG.debug("Lerping to time " + x + ": " + y0 + " @ " + x0
          //          + " -> " + y1 + " @ " + x1 + " => " + r);
          break;
        case ZIM:
          r = 0;
          break;
        case MAX:
          r = Double.MAX_VALUE;
          break;
        case MIN:
          r = Double.MIN_VALUE;
          break;
        case PREV:
          r = y0;
          break;
        default:
          throw new IllegalDataException("Invalid interploation somehow??");
      }
        return r;
      }
      throw new NoSuchElementException("no more doubles in " + this);
    }