You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
902 lines
24 KiB
902 lines
24 KiB
1 year ago
|
// https://d3js.org/d3-scale/ v2.1.2 Copyright 2018 Mike Bostock
|
||
|
|
(function (global, factory) {
|
||
|
|
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-collection'), require('d3-array'), require('d3-interpolate'), require('d3-format'), require('d3-time'), require('d3-time-format')) :
|
||
|
|
typeof define === 'function' && define.amd ? define(['exports', 'd3-collection', 'd3-array', 'd3-interpolate', 'd3-format', 'd3-time', 'd3-time-format'], factory) :
|
||
|
|
(factory((global.d3 = global.d3 || {}),global.d3,global.d3,global.d3,global.d3,global.d3,global.d3));
|
||
|
|
}(this, (function (exports,d3Collection,d3Array,d3Interpolate,d3Format,d3Time,d3TimeFormat) { 'use strict';
|
||
|
|
|
||
|
|
var array = Array.prototype;
|
||
|
|
|
||
|
|
var map = array.map;
|
||
|
|
var slice = array.slice;
|
||
|
|
|
||
|
|
var implicit = {name: "implicit"};
|
||
|
|
|
||
|
|
function ordinal(range) {
|
||
|
|
var index = d3Collection.map(),
|
||
|
|
domain = [],
|
||
|
|
unknown = implicit;
|
||
|
|
|
||
|
|
range = range == null ? [] : slice.call(range);
|
||
|
|
|
||
|
|
function scale(d) {
|
||
|
|
var key = d + "", i = index.get(key);
|
||
|
|
if (!i) {
|
||
|
|
if (unknown !== implicit) return unknown;
|
||
|
|
index.set(key, i = domain.push(d));
|
||
|
|
}
|
||
|
|
return range[(i - 1) % range.length];
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
if (!arguments.length) return domain.slice();
|
||
|
|
domain = [], index = d3Collection.map();
|
||
|
|
var i = -1, n = _.length, d, key;
|
||
|
|
while (++i < n) if (!index.has(key = (d = _[i]) + "")) index.set(key, domain.push(d));
|
||
|
|
return scale;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.range = function(_) {
|
||
|
|
return arguments.length ? (range = slice.call(_), scale) : range.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.unknown = function(_) {
|
||
|
|
return arguments.length ? (unknown = _, scale) : unknown;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return ordinal()
|
||
|
|
.domain(domain)
|
||
|
|
.range(range)
|
||
|
|
.unknown(unknown);
|
||
|
|
};
|
||
|
|
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
function band() {
|
||
|
|
var scale = ordinal().unknown(undefined),
|
||
|
|
domain = scale.domain,
|
||
|
|
ordinalRange = scale.range,
|
||
|
|
range = [0, 1],
|
||
|
|
step,
|
||
|
|
bandwidth,
|
||
|
|
round = false,
|
||
|
|
paddingInner = 0,
|
||
|
|
paddingOuter = 0,
|
||
|
|
align = 0.5;
|
||
|
|
|
||
|
|
delete scale.unknown;
|
||
|
|
|
||
|
|
function rescale() {
|
||
|
|
var n = domain().length,
|
||
|
|
reverse = range[1] < range[0],
|
||
|
|
start = range[reverse - 0],
|
||
|
|
stop = range[1 - reverse];
|
||
|
|
step = (stop - start) / Math.max(1, n - paddingInner + paddingOuter * 2);
|
||
|
|
if (round) step = Math.floor(step);
|
||
|
|
start += (stop - start - step * (n - paddingInner)) * align;
|
||
|
|
bandwidth = step * (1 - paddingInner);
|
||
|
|
if (round) start = Math.round(start), bandwidth = Math.round(bandwidth);
|
||
|
|
var values = d3Array.range(n).map(function(i) { return start + step * i; });
|
||
|
|
return ordinalRange(reverse ? values.reverse() : values);
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
return arguments.length ? (domain(_), rescale()) : domain();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.range = function(_) {
|
||
|
|
return arguments.length ? (range = [+_[0], +_[1]], rescale()) : range.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.rangeRound = function(_) {
|
||
|
|
return range = [+_[0], +_[1]], round = true, rescale();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.bandwidth = function() {
|
||
|
|
return bandwidth;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.step = function() {
|
||
|
|
return step;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.round = function(_) {
|
||
|
|
return arguments.length ? (round = !!_, rescale()) : round;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.padding = function(_) {
|
||
|
|
return arguments.length ? (paddingInner = paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.paddingInner = function(_) {
|
||
|
|
return arguments.length ? (paddingInner = Math.max(0, Math.min(1, _)), rescale()) : paddingInner;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.paddingOuter = function(_) {
|
||
|
|
return arguments.length ? (paddingOuter = Math.max(0, Math.min(1, _)), rescale()) : paddingOuter;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.align = function(_) {
|
||
|
|
return arguments.length ? (align = Math.max(0, Math.min(1, _)), rescale()) : align;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return band()
|
||
|
|
.domain(domain())
|
||
|
|
.range(range)
|
||
|
|
.round(round)
|
||
|
|
.paddingInner(paddingInner)
|
||
|
|
.paddingOuter(paddingOuter)
|
||
|
|
.align(align);
|
||
|
|
};
|
||
|
|
|
||
|
|
return rescale();
|
||
|
|
}
|
||
|
|
|
||
|
|
function pointish(scale) {
|
||
|
|
var copy = scale.copy;
|
||
|
|
|
||
|
|
scale.padding = scale.paddingOuter;
|
||
|
|
delete scale.paddingInner;
|
||
|
|
delete scale.paddingOuter;
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return pointish(copy());
|
||
|
|
};
|
||
|
|
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
function point() {
|
||
|
|
return pointish(band().paddingInner(1));
|
||
|
|
}
|
||
|
|
|
||
|
|
function constant(x) {
|
||
|
|
return function() {
|
||
|
|
return x;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function number(x) {
|
||
|
|
return +x;
|
||
|
|
}
|
||
|
|
|
||
|
|
var unit = [0, 1];
|
||
|
|
|
||
|
|
function deinterpolateLinear(a, b) {
|
||
|
|
return (b -= (a = +a))
|
||
|
|
? function(x) { return (x - a) / b; }
|
||
|
|
: constant(b);
|
||
|
|
}
|
||
|
|
|
||
|
|
function deinterpolateClamp(deinterpolate) {
|
||
|
|
return function(a, b) {
|
||
|
|
var d = deinterpolate(a = +a, b = +b);
|
||
|
|
return function(x) { return x <= a ? 0 : x >= b ? 1 : d(x); };
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function reinterpolateClamp(reinterpolate) {
|
||
|
|
return function(a, b) {
|
||
|
|
var r = reinterpolate(a = +a, b = +b);
|
||
|
|
return function(t) { return t <= 0 ? a : t >= 1 ? b : r(t); };
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function bimap(domain, range, deinterpolate, reinterpolate) {
|
||
|
|
var d0 = domain[0], d1 = domain[1], r0 = range[0], r1 = range[1];
|
||
|
|
if (d1 < d0) d0 = deinterpolate(d1, d0), r0 = reinterpolate(r1, r0);
|
||
|
|
else d0 = deinterpolate(d0, d1), r0 = reinterpolate(r0, r1);
|
||
|
|
return function(x) { return r0(d0(x)); };
|
||
|
|
}
|
||
|
|
|
||
|
|
function polymap(domain, range, deinterpolate, reinterpolate) {
|
||
|
|
var j = Math.min(domain.length, range.length) - 1,
|
||
|
|
d = new Array(j),
|
||
|
|
r = new Array(j),
|
||
|
|
i = -1;
|
||
|
|
|
||
|
|
// Reverse descending domains.
|
||
|
|
if (domain[j] < domain[0]) {
|
||
|
|
domain = domain.slice().reverse();
|
||
|
|
range = range.slice().reverse();
|
||
|
|
}
|
||
|
|
|
||
|
|
while (++i < j) {
|
||
|
|
d[i] = deinterpolate(domain[i], domain[i + 1]);
|
||
|
|
r[i] = reinterpolate(range[i], range[i + 1]);
|
||
|
|
}
|
||
|
|
|
||
|
|
return function(x) {
|
||
|
|
var i = d3Array.bisect(domain, x, 1, j) - 1;
|
||
|
|
return r[i](d[i](x));
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function copy(source, target) {
|
||
|
|
return target
|
||
|
|
.domain(source.domain())
|
||
|
|
.range(source.range())
|
||
|
|
.interpolate(source.interpolate())
|
||
|
|
.clamp(source.clamp());
|
||
|
|
}
|
||
|
|
|
||
|
|
// deinterpolate(a, b)(x) takes a domain value x in [a,b] and returns the corresponding parameter t in [0,1].
|
||
|
|
// reinterpolate(a, b)(t) takes a parameter t in [0,1] and returns the corresponding domain value x in [a,b].
|
||
|
|
function continuous(deinterpolate, reinterpolate) {
|
||
|
|
var domain = unit,
|
||
|
|
range = unit,
|
||
|
|
interpolate = d3Interpolate.interpolate,
|
||
|
|
clamp = false,
|
||
|
|
piecewise,
|
||
|
|
output,
|
||
|
|
input;
|
||
|
|
|
||
|
|
function rescale() {
|
||
|
|
piecewise = Math.min(domain.length, range.length) > 2 ? polymap : bimap;
|
||
|
|
output = input = null;
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
function scale(x) {
|
||
|
|
return (output || (output = piecewise(domain, range, clamp ? deinterpolateClamp(deinterpolate) : deinterpolate, interpolate)))(+x);
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.invert = function(y) {
|
||
|
|
return (input || (input = piecewise(range, domain, deinterpolateLinear, clamp ? reinterpolateClamp(reinterpolate) : reinterpolate)))(+y);
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
return arguments.length ? (domain = map.call(_, number), rescale()) : domain.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.range = function(_) {
|
||
|
|
return arguments.length ? (range = slice.call(_), rescale()) : range.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.rangeRound = function(_) {
|
||
|
|
return range = slice.call(_), interpolate = d3Interpolate.interpolateRound, rescale();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.clamp = function(_) {
|
||
|
|
return arguments.length ? (clamp = !!_, rescale()) : clamp;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.interpolate = function(_) {
|
||
|
|
return arguments.length ? (interpolate = _, rescale()) : interpolate;
|
||
|
|
};
|
||
|
|
|
||
|
|
return rescale();
|
||
|
|
}
|
||
|
|
|
||
|
|
function tickFormat(domain, count, specifier) {
|
||
|
|
var start = domain[0],
|
||
|
|
stop = domain[domain.length - 1],
|
||
|
|
step = d3Array.tickStep(start, stop, count == null ? 10 : count),
|
||
|
|
precision;
|
||
|
|
specifier = d3Format.formatSpecifier(specifier == null ? ",f" : specifier);
|
||
|
|
switch (specifier.type) {
|
||
|
|
case "s": {
|
||
|
|
var value = Math.max(Math.abs(start), Math.abs(stop));
|
||
|
|
if (specifier.precision == null && !isNaN(precision = d3Format.precisionPrefix(step, value))) specifier.precision = precision;
|
||
|
|
return d3Format.formatPrefix(specifier, value);
|
||
|
|
}
|
||
|
|
case "":
|
||
|
|
case "e":
|
||
|
|
case "g":
|
||
|
|
case "p":
|
||
|
|
case "r": {
|
||
|
|
if (specifier.precision == null && !isNaN(precision = d3Format.precisionRound(step, Math.max(Math.abs(start), Math.abs(stop))))) specifier.precision = precision - (specifier.type === "e");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
case "f":
|
||
|
|
case "%": {
|
||
|
|
if (specifier.precision == null && !isNaN(precision = d3Format.precisionFixed(step))) specifier.precision = precision - (specifier.type === "%") * 2;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return d3Format.format(specifier);
|
||
|
|
}
|
||
|
|
|
||
|
|
function linearish(scale) {
|
||
|
|
var domain = scale.domain;
|
||
|
|
|
||
|
|
scale.ticks = function(count) {
|
||
|
|
var d = domain();
|
||
|
|
return d3Array.ticks(d[0], d[d.length - 1], count == null ? 10 : count);
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.tickFormat = function(count, specifier) {
|
||
|
|
return tickFormat(domain(), count, specifier);
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.nice = function(count) {
|
||
|
|
if (count == null) count = 10;
|
||
|
|
|
||
|
|
var d = domain(),
|
||
|
|
i0 = 0,
|
||
|
|
i1 = d.length - 1,
|
||
|
|
start = d[i0],
|
||
|
|
stop = d[i1],
|
||
|
|
step;
|
||
|
|
|
||
|
|
if (stop < start) {
|
||
|
|
step = start, start = stop, stop = step;
|
||
|
|
step = i0, i0 = i1, i1 = step;
|
||
|
|
}
|
||
|
|
|
||
|
|
step = d3Array.tickIncrement(start, stop, count);
|
||
|
|
|
||
|
|
if (step > 0) {
|
||
|
|
start = Math.floor(start / step) * step;
|
||
|
|
stop = Math.ceil(stop / step) * step;
|
||
|
|
step = d3Array.tickIncrement(start, stop, count);
|
||
|
|
} else if (step < 0) {
|
||
|
|
start = Math.ceil(start * step) / step;
|
||
|
|
stop = Math.floor(stop * step) / step;
|
||
|
|
step = d3Array.tickIncrement(start, stop, count);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (step > 0) {
|
||
|
|
d[i0] = Math.floor(start / step) * step;
|
||
|
|
d[i1] = Math.ceil(stop / step) * step;
|
||
|
|
domain(d);
|
||
|
|
} else if (step < 0) {
|
||
|
|
d[i0] = Math.ceil(start * step) / step;
|
||
|
|
d[i1] = Math.floor(stop * step) / step;
|
||
|
|
domain(d);
|
||
|
|
}
|
||
|
|
|
||
|
|
return scale;
|
||
|
|
};
|
||
|
|
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
function linear() {
|
||
|
|
var scale = continuous(deinterpolateLinear, d3Interpolate.interpolateNumber);
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return copy(scale, linear());
|
||
|
|
};
|
||
|
|
|
||
|
|
return linearish(scale);
|
||
|
|
}
|
||
|
|
|
||
|
|
function identity() {
|
||
|
|
var domain = [0, 1];
|
||
|
|
|
||
|
|
function scale(x) {
|
||
|
|
return +x;
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.invert = scale;
|
||
|
|
|
||
|
|
scale.domain = scale.range = function(_) {
|
||
|
|
return arguments.length ? (domain = map.call(_, number), scale) : domain.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return identity().domain(domain);
|
||
|
|
};
|
||
|
|
|
||
|
|
return linearish(scale);
|
||
|
|
}
|
||
|
|
|
||
|
|
function nice(domain, interval) {
|
||
|
|
domain = domain.slice();
|
||
|
|
|
||
|
|
var i0 = 0,
|
||
|
|
i1 = domain.length - 1,
|
||
|
|
x0 = domain[i0],
|
||
|
|
x1 = domain[i1],
|
||
|
|
t;
|
||
|
|
|
||
|
|
if (x1 < x0) {
|
||
|
|
t = i0, i0 = i1, i1 = t;
|
||
|
|
t = x0, x0 = x1, x1 = t;
|
||
|
|
}
|
||
|
|
|
||
|
|
domain[i0] = interval.floor(x0);
|
||
|
|
domain[i1] = interval.ceil(x1);
|
||
|
|
return domain;
|
||
|
|
}
|
||
|
|
|
||
|
|
function deinterpolate(a, b) {
|
||
|
|
return (b = Math.log(b / a))
|
||
|
|
? function(x) { return Math.log(x / a) / b; }
|
||
|
|
: constant(b);
|
||
|
|
}
|
||
|
|
|
||
|
|
function reinterpolate(a, b) {
|
||
|
|
return a < 0
|
||
|
|
? function(t) { return -Math.pow(-b, t) * Math.pow(-a, 1 - t); }
|
||
|
|
: function(t) { return Math.pow(b, t) * Math.pow(a, 1 - t); };
|
||
|
|
}
|
||
|
|
|
||
|
|
function pow10(x) {
|
||
|
|
return isFinite(x) ? +("1e" + x) : x < 0 ? 0 : x;
|
||
|
|
}
|
||
|
|
|
||
|
|
function powp(base) {
|
||
|
|
return base === 10 ? pow10
|
||
|
|
: base === Math.E ? Math.exp
|
||
|
|
: function(x) { return Math.pow(base, x); };
|
||
|
|
}
|
||
|
|
|
||
|
|
function logp(base) {
|
||
|
|
return base === Math.E ? Math.log
|
||
|
|
: base === 10 && Math.log10
|
||
|
|
|| base === 2 && Math.log2
|
||
|
|
|| (base = Math.log(base), function(x) { return Math.log(x) / base; });
|
||
|
|
}
|
||
|
|
|
||
|
|
function reflect(f) {
|
||
|
|
return function(x) {
|
||
|
|
return -f(-x);
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
function log() {
|
||
|
|
var scale = continuous(deinterpolate, reinterpolate).domain([1, 10]),
|
||
|
|
domain = scale.domain,
|
||
|
|
base = 10,
|
||
|
|
logs = logp(10),
|
||
|
|
pows = powp(10);
|
||
|
|
|
||
|
|
function rescale() {
|
||
|
|
logs = logp(base), pows = powp(base);
|
||
|
|
if (domain()[0] < 0) logs = reflect(logs), pows = reflect(pows);
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.base = function(_) {
|
||
|
|
return arguments.length ? (base = +_, rescale()) : base;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
return arguments.length ? (domain(_), rescale()) : domain();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.ticks = function(count) {
|
||
|
|
var d = domain(),
|
||
|
|
u = d[0],
|
||
|
|
v = d[d.length - 1],
|
||
|
|
r;
|
||
|
|
|
||
|
|
if (r = v < u) i = u, u = v, v = i;
|
||
|
|
|
||
|
|
var i = logs(u),
|
||
|
|
j = logs(v),
|
||
|
|
p,
|
||
|
|
k,
|
||
|
|
t,
|
||
|
|
n = count == null ? 10 : +count,
|
||
|
|
z = [];
|
||
|
|
|
||
|
|
if (!(base % 1) && j - i < n) {
|
||
|
|
i = Math.round(i) - 1, j = Math.round(j) + 1;
|
||
|
|
if (u > 0) for (; i < j; ++i) {
|
||
|
|
for (k = 1, p = pows(i); k < base; ++k) {
|
||
|
|
t = p * k;
|
||
|
|
if (t < u) continue;
|
||
|
|
if (t > v) break;
|
||
|
|
z.push(t);
|
||
|
|
}
|
||
|
|
} else for (; i < j; ++i) {
|
||
|
|
for (k = base - 1, p = pows(i); k >= 1; --k) {
|
||
|
|
t = p * k;
|
||
|
|
if (t < u) continue;
|
||
|
|
if (t > v) break;
|
||
|
|
z.push(t);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
z = d3Array.ticks(i, j, Math.min(j - i, n)).map(pows);
|
||
|
|
}
|
||
|
|
|
||
|
|
return r ? z.reverse() : z;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.tickFormat = function(count, specifier) {
|
||
|
|
if (specifier == null) specifier = base === 10 ? ".0e" : ",";
|
||
|
|
if (typeof specifier !== "function") specifier = d3Format.format(specifier);
|
||
|
|
if (count === Infinity) return specifier;
|
||
|
|
if (count == null) count = 10;
|
||
|
|
var k = Math.max(1, base * count / scale.ticks().length); // TODO fast estimate?
|
||
|
|
return function(d) {
|
||
|
|
var i = d / pows(Math.round(logs(d)));
|
||
|
|
if (i * base < base - 0.5) i *= base;
|
||
|
|
return i <= k ? specifier(d) : "";
|
||
|
|
};
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.nice = function() {
|
||
|
|
return domain(nice(domain(), {
|
||
|
|
floor: function(x) { return pows(Math.floor(logs(x))); },
|
||
|
|
ceil: function(x) { return pows(Math.ceil(logs(x))); }
|
||
|
|
}));
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return copy(scale, log().base(base));
|
||
|
|
};
|
||
|
|
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
function raise(x, exponent) {
|
||
|
|
return x < 0 ? -Math.pow(-x, exponent) : Math.pow(x, exponent);
|
||
|
|
}
|
||
|
|
|
||
|
|
function pow() {
|
||
|
|
var exponent = 1,
|
||
|
|
scale = continuous(deinterpolate, reinterpolate),
|
||
|
|
domain = scale.domain;
|
||
|
|
|
||
|
|
function deinterpolate(a, b) {
|
||
|
|
return (b = raise(b, exponent) - (a = raise(a, exponent)))
|
||
|
|
? function(x) { return (raise(x, exponent) - a) / b; }
|
||
|
|
: constant(b);
|
||
|
|
}
|
||
|
|
|
||
|
|
function reinterpolate(a, b) {
|
||
|
|
b = raise(b, exponent) - (a = raise(a, exponent));
|
||
|
|
return function(t) { return raise(a + b * t, 1 / exponent); };
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.exponent = function(_) {
|
||
|
|
return arguments.length ? (exponent = +_, domain(domain())) : exponent;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return copy(scale, pow().exponent(exponent));
|
||
|
|
};
|
||
|
|
|
||
|
|
return linearish(scale);
|
||
|
|
}
|
||
|
|
|
||
|
|
function sqrt() {
|
||
|
|
return pow().exponent(0.5);
|
||
|
|
}
|
||
|
|
|
||
|
|
function quantile() {
|
||
|
|
var domain = [],
|
||
|
|
range = [],
|
||
|
|
thresholds = [];
|
||
|
|
|
||
|
|
function rescale() {
|
||
|
|
var i = 0, n = Math.max(1, range.length);
|
||
|
|
thresholds = new Array(n - 1);
|
||
|
|
while (++i < n) thresholds[i - 1] = d3Array.quantile(domain, i / n);
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
function scale(x) {
|
||
|
|
if (!isNaN(x = +x)) return range[d3Array.bisect(thresholds, x)];
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.invertExtent = function(y) {
|
||
|
|
var i = range.indexOf(y);
|
||
|
|
return i < 0 ? [NaN, NaN] : [
|
||
|
|
i > 0 ? thresholds[i - 1] : domain[0],
|
||
|
|
i < thresholds.length ? thresholds[i] : domain[domain.length - 1]
|
||
|
|
];
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
if (!arguments.length) return domain.slice();
|
||
|
|
domain = [];
|
||
|
|
for (var i = 0, n = _.length, d; i < n; ++i) if (d = _[i], d != null && !isNaN(d = +d)) domain.push(d);
|
||
|
|
domain.sort(d3Array.ascending);
|
||
|
|
return rescale();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.range = function(_) {
|
||
|
|
return arguments.length ? (range = slice.call(_), rescale()) : range.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.quantiles = function() {
|
||
|
|
return thresholds.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return quantile()
|
||
|
|
.domain(domain)
|
||
|
|
.range(range);
|
||
|
|
};
|
||
|
|
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
function quantize() {
|
||
|
|
var x0 = 0,
|
||
|
|
x1 = 1,
|
||
|
|
n = 1,
|
||
|
|
domain = [0.5],
|
||
|
|
range = [0, 1];
|
||
|
|
|
||
|
|
function scale(x) {
|
||
|
|
if (x <= x) return range[d3Array.bisect(domain, x, 0, n)];
|
||
|
|
}
|
||
|
|
|
||
|
|
function rescale() {
|
||
|
|
var i = -1;
|
||
|
|
domain = new Array(n);
|
||
|
|
while (++i < n) domain[i] = ((i + 1) * x1 - (i - n) * x0) / (n + 1);
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
return arguments.length ? (x0 = +_[0], x1 = +_[1], rescale()) : [x0, x1];
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.range = function(_) {
|
||
|
|
return arguments.length ? (n = (range = slice.call(_)).length - 1, rescale()) : range.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.invertExtent = function(y) {
|
||
|
|
var i = range.indexOf(y);
|
||
|
|
return i < 0 ? [NaN, NaN]
|
||
|
|
: i < 1 ? [x0, domain[0]]
|
||
|
|
: i >= n ? [domain[n - 1], x1]
|
||
|
|
: [domain[i - 1], domain[i]];
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return quantize()
|
||
|
|
.domain([x0, x1])
|
||
|
|
.range(range);
|
||
|
|
};
|
||
|
|
|
||
|
|
return linearish(scale);
|
||
|
|
}
|
||
|
|
|
||
|
|
function threshold() {
|
||
|
|
var domain = [0.5],
|
||
|
|
range = [0, 1],
|
||
|
|
n = 1;
|
||
|
|
|
||
|
|
function scale(x) {
|
||
|
|
if (x <= x) return range[d3Array.bisect(domain, x, 0, n)];
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
return arguments.length ? (domain = slice.call(_), n = Math.min(domain.length, range.length - 1), scale) : domain.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.range = function(_) {
|
||
|
|
return arguments.length ? (range = slice.call(_), n = Math.min(domain.length, range.length - 1), scale) : range.slice();
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.invertExtent = function(y) {
|
||
|
|
var i = range.indexOf(y);
|
||
|
|
return [domain[i - 1], domain[i]];
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return threshold()
|
||
|
|
.domain(domain)
|
||
|
|
.range(range);
|
||
|
|
};
|
||
|
|
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
var durationSecond = 1000,
|
||
|
|
durationMinute = durationSecond * 60,
|
||
|
|
durationHour = durationMinute * 60,
|
||
|
|
durationDay = durationHour * 24,
|
||
|
|
durationWeek = durationDay * 7,
|
||
|
|
durationMonth = durationDay * 30,
|
||
|
|
durationYear = durationDay * 365;
|
||
|
|
|
||
|
|
function date(t) {
|
||
|
|
return new Date(t);
|
||
|
|
}
|
||
|
|
|
||
|
|
function number$1(t) {
|
||
|
|
return t instanceof Date ? +t : +new Date(+t);
|
||
|
|
}
|
||
|
|
|
||
|
|
function calendar(year, month, week, day, hour, minute, second, millisecond, format) {
|
||
|
|
var scale = continuous(deinterpolateLinear, d3Interpolate.interpolateNumber),
|
||
|
|
invert = scale.invert,
|
||
|
|
domain = scale.domain;
|
||
|
|
|
||
|
|
var formatMillisecond = format(".%L"),
|
||
|
|
formatSecond = format(":%S"),
|
||
|
|
formatMinute = format("%I:%M"),
|
||
|
|
formatHour = format("%I %p"),
|
||
|
|
formatDay = format("%a %d"),
|
||
|
|
formatWeek = format("%b %d"),
|
||
|
|
formatMonth = format("%B"),
|
||
|
|
formatYear = format("%Y");
|
||
|
|
|
||
|
|
var tickIntervals = [
|
||
|
|
[second, 1, durationSecond],
|
||
|
|
[second, 5, 5 * durationSecond],
|
||
|
|
[second, 15, 15 * durationSecond],
|
||
|
|
[second, 30, 30 * durationSecond],
|
||
|
|
[minute, 1, durationMinute],
|
||
|
|
[minute, 5, 5 * durationMinute],
|
||
|
|
[minute, 15, 15 * durationMinute],
|
||
|
|
[minute, 30, 30 * durationMinute],
|
||
|
|
[ hour, 1, durationHour ],
|
||
|
|
[ hour, 3, 3 * durationHour ],
|
||
|
|
[ hour, 6, 6 * durationHour ],
|
||
|
|
[ hour, 12, 12 * durationHour ],
|
||
|
|
[ day, 1, durationDay ],
|
||
|
|
[ day, 2, 2 * durationDay ],
|
||
|
|
[ week, 1, durationWeek ],
|
||
|
|
[ month, 1, durationMonth ],
|
||
|
|
[ month, 3, 3 * durationMonth ],
|
||
|
|
[ year, 1, durationYear ]
|
||
|
|
];
|
||
|
|
|
||
|
|
function tickFormat(date) {
|
||
|
|
return (second(date) < date ? formatMillisecond
|
||
|
|
: minute(date) < date ? formatSecond
|
||
|
|
: hour(date) < date ? formatMinute
|
||
|
|
: day(date) < date ? formatHour
|
||
|
|
: month(date) < date ? (week(date) < date ? formatDay : formatWeek)
|
||
|
|
: year(date) < date ? formatMonth
|
||
|
|
: formatYear)(date);
|
||
|
|
}
|
||
|
|
|
||
|
|
function tickInterval(interval, start, stop, step) {
|
||
|
|
if (interval == null) interval = 10;
|
||
|
|
|
||
|
|
// If a desired tick count is specified, pick a reasonable tick interval
|
||
|
|
// based on the extent of the domain and a rough estimate of tick size.
|
||
|
|
// Otherwise, assume interval is already a time interval and use it.
|
||
|
|
if (typeof interval === "number") {
|
||
|
|
var target = Math.abs(stop - start) / interval,
|
||
|
|
i = d3Array.bisector(function(i) { return i[2]; }).right(tickIntervals, target);
|
||
|
|
if (i === tickIntervals.length) {
|
||
|
|
step = d3Array.tickStep(start / durationYear, stop / durationYear, interval);
|
||
|
|
interval = year;
|
||
|
|
} else if (i) {
|
||
|
|
i = tickIntervals[target / tickIntervals[i - 1][2] < tickIntervals[i][2] / target ? i - 1 : i];
|
||
|
|
step = i[1];
|
||
|
|
interval = i[0];
|
||
|
|
} else {
|
||
|
|
step = Math.max(d3Array.tickStep(start, stop, interval), 1);
|
||
|
|
interval = millisecond;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
return step == null ? interval : interval.every(step);
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.invert = function(y) {
|
||
|
|
return new Date(invert(y));
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
return arguments.length ? domain(map.call(_, number$1)) : domain().map(date);
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.ticks = function(interval, step) {
|
||
|
|
var d = domain(),
|
||
|
|
t0 = d[0],
|
||
|
|
t1 = d[d.length - 1],
|
||
|
|
r = t1 < t0,
|
||
|
|
t;
|
||
|
|
if (r) t = t0, t0 = t1, t1 = t;
|
||
|
|
t = tickInterval(interval, t0, t1, step);
|
||
|
|
t = t ? t.range(t0, t1 + 1) : []; // inclusive stop
|
||
|
|
return r ? t.reverse() : t;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.tickFormat = function(count, specifier) {
|
||
|
|
return specifier == null ? tickFormat : format(specifier);
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.nice = function(interval, step) {
|
||
|
|
var d = domain();
|
||
|
|
return (interval = tickInterval(interval, d[0], d[d.length - 1], step))
|
||
|
|
? domain(nice(d, interval))
|
||
|
|
: scale;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return copy(scale, calendar(year, month, week, day, hour, minute, second, millisecond, format));
|
||
|
|
};
|
||
|
|
|
||
|
|
return scale;
|
||
|
|
}
|
||
|
|
|
||
|
|
function time() {
|
||
|
|
return calendar(d3Time.timeYear, d3Time.timeMonth, d3Time.timeWeek, d3Time.timeDay, d3Time.timeHour, d3Time.timeMinute, d3Time.timeSecond, d3Time.timeMillisecond, d3TimeFormat.timeFormat).domain([new Date(2000, 0, 1), new Date(2000, 0, 2)]);
|
||
|
|
}
|
||
|
|
|
||
|
|
function utcTime() {
|
||
|
|
return calendar(d3Time.utcYear, d3Time.utcMonth, d3Time.utcWeek, d3Time.utcDay, d3Time.utcHour, d3Time.utcMinute, d3Time.utcSecond, d3Time.utcMillisecond, d3TimeFormat.utcFormat).domain([Date.UTC(2000, 0, 1), Date.UTC(2000, 0, 2)]);
|
||
|
|
}
|
||
|
|
|
||
|
|
function sequential(interpolator) {
|
||
|
|
var x0 = 0,
|
||
|
|
x1 = 1,
|
||
|
|
k10 = 1,
|
||
|
|
clamp = false;
|
||
|
|
|
||
|
|
function scale(x) {
|
||
|
|
var t = (x - x0) * k10;
|
||
|
|
return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t);
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
return arguments.length ? (x0 = +_[0], x1 = +_[1], k10 = x0 === x1 ? 0 : 1 / (x1 - x0), scale) : [x0, x1];
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.clamp = function(_) {
|
||
|
|
return arguments.length ? (clamp = !!_, scale) : clamp;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.interpolator = function(_) {
|
||
|
|
return arguments.length ? (interpolator = _, scale) : interpolator;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return sequential(interpolator).domain([x0, x1]).clamp(clamp);
|
||
|
|
};
|
||
|
|
|
||
|
|
return linearish(scale);
|
||
|
|
}
|
||
|
|
|
||
|
|
function diverging(interpolator) {
|
||
|
|
var x0 = 0,
|
||
|
|
x1 = 0.5,
|
||
|
|
x2 = 1,
|
||
|
|
k10 = 1,
|
||
|
|
k21 = 1,
|
||
|
|
clamp = false;
|
||
|
|
|
||
|
|
function scale(x) {
|
||
|
|
var t = 0.5 + ((x = +x) - x1) * (x < x1 ? k10 : k21);
|
||
|
|
return interpolator(clamp ? Math.max(0, Math.min(1, t)) : t);
|
||
|
|
}
|
||
|
|
|
||
|
|
scale.domain = function(_) {
|
||
|
|
return arguments.length ? (x0 = +_[0], x1 = +_[1], x2 = +_[2], k10 = x0 === x1 ? 0 : 0.5 / (x1 - x0), k21 = x1 === x2 ? 0 : 0.5 / (x2 - x1), scale) : [x0, x1, x2];
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.clamp = function(_) {
|
||
|
|
return arguments.length ? (clamp = !!_, scale) : clamp;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.interpolator = function(_) {
|
||
|
|
return arguments.length ? (interpolator = _, scale) : interpolator;
|
||
|
|
};
|
||
|
|
|
||
|
|
scale.copy = function() {
|
||
|
|
return diverging(interpolator).domain([x0, x1, x2]).clamp(clamp);
|
||
|
|
};
|
||
|
|
|
||
|
|
return linearish(scale);
|
||
|
|
}
|
||
|
|
|
||
|
|
exports.scaleBand = band;
|
||
|
|
exports.scalePoint = point;
|
||
|
|
exports.scaleIdentity = identity;
|
||
|
|
exports.scaleLinear = linear;
|
||
|
|
exports.scaleLog = log;
|
||
|
|
exports.scaleOrdinal = ordinal;
|
||
|
|
exports.scaleImplicit = implicit;
|
||
|
|
exports.scalePow = pow;
|
||
|
|
exports.scaleSqrt = sqrt;
|
||
|
|
exports.scaleQuantile = quantile;
|
||
|
|
exports.scaleQuantize = quantize;
|
||
|
|
exports.scaleThreshold = threshold;
|
||
|
|
exports.scaleTime = time;
|
||
|
|
exports.scaleUtc = utcTime;
|
||
|
|
exports.scaleSequential = sequential;
|
||
|
|
exports.scaleDiverging = diverging;
|
||
|
|
|
||
|
|
Object.defineProperty(exports, '__esModule', { value: true });
|
||
|
|
|
||
|
|
})));
|