scalePow evenly spaced ticks?

[vincerubinetti]

Looking at the code and experimenting, it seems like scalePow generates ticks in the same was as scaleLinear. I think it'd be cool if it could generate evenly (after the application of the power) spaced ticks similar to how scaleLog does.

I'm not exactly sure what this would look like at the moment, but I feel like it should be possible for scalePow if it's possible for scaleLog.

I could do something like this:

const min = 0;
const max = 100;
const power = 2;
const steps = 10;

const scale = d3.scalePow().domain([min, max]).range([min, max]).exponent(power);
const ticks = d3.range(scale.range()[0], scale.range()[1], steps).map((v) => scale.invert(v));
// or
const ticks = d3.ticks(scale.range()[0], scale.range()[1], steps).map((v) => scale.invert(v));

But I believe in the linear and log versions, there is more "magic" happening behind the scenes to make it look nice?

Actually it looks like d3-array has a ticks method that does some magic, but I'm still not sure integrating it into my example above is as good as linear/log's built-in ticking. Moreover, maybe this should be added regardless for convenience, so I don't have to do any of the work above.

[Fil]

Ticks are supposed to be "human readable", like 10, 20, 30, rather than arbitrary numbers such as 31.622776601683793, 44.721359549995796.

A common use case is, say powers of 2, where you want the ticks to be 1, 2, 4, 8, 16, 32, 64… and your method allows that. However it's not generic: if you add more ticks in-between you get multiples of sqrt(2), which are not "readable".

[vincerubinetti]

Sorry for making an issue and not a discussion, I thought I saw that discussions weren't enabled on the repo.

I think what I'm asking is if it should be made similar to how scaleLog works:

Like continuous.ticks, but customized for a log scale. If the base is an integer, the returned ticks are uniformly spaced within each integer power of base; otherwise, one tick per power of base is returned. The returned ticks are guaranteed to be within the extent of the domain. If the orders of magnitude in the domain is greater than count, then at most one tick per power is returned. Otherwise, the tick values are unfiltered, b

d3.scaleLog().base(2).domain([1, 256]).ticks(5);
d3.scaleLog().base(2).domain([1, 256]).ticks()
d3.scaleLog().base(2).domain([1, 256]).ticks(20)

[1, 4, 16, 64, 256]
[1, 2, 4, 8, 16, 32, 64, 128, 256]
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250]

d3.scalePow().exponent(2).domain([1, 256]).ticks(5);
d3.scalePow().exponent(2).domain([1, 256]).ticks();
d3.scalePow().exponent(2).domain([1, 256]).ticks(20);

[50, 100, 150, 200, 250]
[20, 40, 60, 80, 100, 120, 140, 160, 180, 200, 220, 240]
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 110, 120, 130, 140, 150, 160, 170, 180, 190, 200, 210, 220, 230, 240, 250]

It seems like if you increase ticks for scaleLog beyond a certain point, it just reverts to linear. I think scalePow could do the same thing, so if you add more ticks as you said, it just falls back to linear. And if less, it skips multiples of sqrt(2).

[vincerubinetti]

I guess I could use scaleLog for this behavior (though for my code I'd then need both scaleLog and scalePow), but I'd expect them to have similar behavior I guess.