Ticks of niced linear scales do not always cover the domain

[Dominik Moritz]

> d3
  .scaleLinear()
  .domain([70, 210])
  .nice(2)
  .ticks(2)
[0,200]

https://github.com/d3/d3-scale#continuous_nice says that "An optional tick count argument allows greater control over the step size used to extend the bounds, guaranteeing that the returned ticks will exactly cover the domain." This is not true here and the scale domain ([0, 300]) is not covered by the ticks [0,200].

This issue looks similar to #9

[Mike Bostock]

So, the correct answer here is a domain of [0, 500] and ticks [0, 500]?

I’m not really sure how to implement the documented guarantee, but I’m open to suggestions.

[Dominik Moritz]

I think I would want a domain of [0,400] and ticks [0,200,400], which is what I am getting when I use a domain of [60, 210] (just a slightly different start).

d3
  .scaleLinear()
  .domain([60, 210])
  .nice(2)
  .ticks(2)

[Mike Bostock]

Ah, yes, that’s slightly better. And indeed that’s what you get if you nice twice:

> d3
  .scaleLinear()
  .domain([70, 210])
  .nice(2)
  .nice(2)
  .ticks(2)
[0, 200, 400]

[Dominik Moritz]

By the way, if we run the iteration in nice three times, we get the "right" answer. I didn't quite get what you meant by an iterative solution in #9 (comment).

Maybe we need to run the iteration to a fixpoint?

[Mike Bostock]

I was just going to make the same suggestion.

[Dominik Moritz]

I could take a stab at it but I'm not exactly sure what the fixpoint would be for. Do you have cycles to implement a fix?

I did write some test code already.

tape("linear.ticks(X) spans linear.nice().domain()", function(test) {
  function check(domain, count) {
    var s = scale.scaleLinear().domain(domain).nice(count);
    var ticks = s.ticks(count);
    test.deepEqual([ticks[0], ticks[ticks.length - 1]], s.domain());
  }
  
  check([1, 9], 2);
  check([1, 9], 3);
  check([1, 9], 4);

  check([8, 9], 2);
  check([8, 9], 3);
  check([8, 9], 4);

  check([1, 21], 2);
  check([2, 21], 2);
  check([3, 21], 2);
  check([4, 21], 2);
  check([5, 21], 2);
  check([6, 21], 2);
  check([7, 21], 2);
  check([8, 21], 2);
  check([9, 21], 2);
  check([10, 21], 2);

  test.end();
})

[Dominik Moritz]

The tick calculation feels somewhat similar to @jheer's binning code in https://github.com/vega/vega/blob/master/packages/vega-statistics/src/bin.js.

[Mike Bostock]

I think this will do it:

function nice(start, stop, count) {
  let prestep;
  while (true) {
    const step = tickIncrement(start, stop, count);
    if (step === prestep) {
      return step;
    } else if (step > 0) {
      start = Math.floor(start / step) * step;
      stop = Math.ceil(stop / step) * step;
    } else if (step < 0) {
      start = Math.ceil(start * step) / step;
      stop = Math.floor(stop * step) / step;
    } else {
      return NaN;
    }
    prestep = step;
  }
}

https://observablehq.com/d/7acf042a83b43c16

[Dominik Moritz]

I see. So you are running the fixpoint calculation until the step size has settled. Sounds good to me.