quantileIndex, medianIndex

[Fil]

closes #140

[Fil]

@EE2dev please test :-)

[EE2dev]

Here is a test observable:
https://observablehq.com/d/254038e0365760ad

It seems for an array with an 99 (odd number of elements) the value1 and index1 should be the same as value0 and index0 but it isnt. Or am I missing something?

[Fil]

Thanks so much for checking this! In the notebook's function I hadn't paid enough attention to the case where the quantile falls exactly on an index; I always returned [i,i+1] in that case. Note that this PR is about the second approach (which I called "ex post" in the notebook).

[mbostock]

It feels a little unusual to me that quantileIndex (and by extension medianIndex) returns a two-element array of indexes rather than a single index. I understand why that is, but I think another reasonable interpretation would be to return only the first index, and then quantileIndex would be consistent with the other index methods. And secondly, knowing both indexes isn’t enough to compute the value returned by median or quantile using the R-7 method since you’d still need to the fractional component (i - i0). So how would you feel about just returning the first index?

Something like:

function quantileIndex(values, p, valueof) {
  values = Float64Array.from(numbers(values, valueof));
  if (!(n = values.length)) return;
  if ((p = +p) <= 0 || n < 2) return minIndex(values);
  if (p >= 1) return maxIndex(values);
  var n,
      i = (n - 1) * p,
      i0 = Math.floor(i),
      order = (i, j) => ascending(values[i], values[j]);
  return max(quickselect(Uint32Array.from(values, (_, i) => i), i0, 0, n - 1, order).subarray(0, i0 + 1), order);
}

[EE2dev]

Thanks for the clarification. I agree about the downside/ overhead having two indices.. I am fine with your suggestion.

[Fil]

I pushed a new version that returns the left-side index

[mbostock]

In 11fa241, I made some changes:

• I changed the implementation of quantileIndex to match my previous suggestion, though I needed to use greatest instead of max. The previous approach was doing a linear scan after computing the quantile value, but we can compute the quantile index directly, so I think it’s preferable to do that. Performance-wise I expect them to be similar since both require making two copies of the input array.
• We need to apply numeric coercion even if valueof is undefined; the behavior of quantileIndex should match quantile. (And even so, we should test valueof for strictly undefined rather than falsey to match the behavior of default arguments in JavaScript.)
• Tests should use strict equality instead of loose equality wherever possible.

FWIW, here is another alternative implementation that I considered (closer to your proposal), but I prefer the one now in this PR.

function quantileIndex(values, p, valueof) {
  values = Float64Array.from(numbers(values, valueof));
  if (!(n = values.length)) return;
  if ((p = +p) <= 0 || n < 2) return minIndex(values);
  if (p >= 1) return maxIndex(values);
  var n,
      m = Math.floor((n - 1) * p),
      q = max(quickselect(values.slice(), m).subarray(0, m + 1)),
      i = -1;
  while (++i < n) {
    if (values[i] === q) {
      return i;
    }
  }
}