Chen Xiao
+27
@@ -0,0 +1,27 @@
|
||||
Copyright 2015, Mike Bostock
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the author nor the names of contributors may be used to
|
||||
endorse or promote products derived from this software without specific prior
|
||||
written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
+249
@@ -0,0 +1,249 @@
|
||||
# d3-sankey
|
||||
|
||||
Sankey diagrams visualize the directed flow between nodes in an acyclic network. For example, this diagram shows a possible scenario of UK energy production and consumption in 2050:
|
||||
|
||||
[<img alt="Sankey diagram" src="https://raw.githubusercontent.com/d3/d3-sankey/master/img/energy.png" width="960">](https://observablehq.com/@d3/sankey-diagram)
|
||||
|
||||
Source: Department of Energy & Climate Change, Tom Counsell.
|
||||
|
||||
**For an interactive editor, see [Flow-o-Matic](https://observablehq.com/@mbostock/flow-o-matic).**
|
||||
|
||||
## Installing
|
||||
|
||||
If you use NPM, `npm install d3-sankey`. Otherwise, download the [latest release](https://github.com/d3/d3-sankey/releases/latest). You can also load directly from [unpkg.com](https://unpkg.com/d3-sankey/). AMD, CommonJS, and vanilla environments are supported. In vanilla, a `d3` global is exported:
|
||||
|
||||
```html
|
||||
<script src="https://unpkg.com/d3-array@1"></script>
|
||||
<script src="https://unpkg.com/d3-collection@1"></script>
|
||||
<script src="https://unpkg.com/d3-path@1"></script>
|
||||
<script src="https://unpkg.com/d3-shape@1"></script>
|
||||
<script src="https://unpkg.com/d3-sankey@0"></script>
|
||||
<script>
|
||||
|
||||
var sankey = d3.sankey();
|
||||
|
||||
</script>
|
||||
```
|
||||
|
||||
## API Reference
|
||||
|
||||
<a href="#sankey" name="sankey">#</a> d3.<b>sankey</b>() [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
Constructs a new Sankey generator with the default settings.
|
||||
|
||||
<a href="#_sankey" name="_sankey">#</a> <i>sankey</i>(<i>arguments</i>…) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
Computes the node and link positions for the given *arguments*, returning a *graph* representing the Sankey layout. The returned *graph* has the following properties:
|
||||
|
||||
* *graph*.nodes - the array of [nodes](#sankey_nodes)
|
||||
* *graph*.links - the array of [links](#sankey_links)
|
||||
|
||||
<a href="#sankey_update" name="sankey_update">#</a> <i>sankey</i>.<b>update</b>(<i>graph</i>) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
Recomputes the specified *graph*’s links’ positions, updating the following properties of each *link*:
|
||||
|
||||
* *link*.y0 - the link’s vertical starting position (at source node)
|
||||
* *link*.y1 - the link’s vertical end position (at target node)
|
||||
|
||||
This method is intended to be called after computing the initial [Sankey layout](#_sankey), for example when the diagram is repositioned interactively.
|
||||
|
||||
<a name="sankey_nodes" href="#sankey_nodes">#</a> <i>sankey</i>.<b>nodes</b>([<i>nodes</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *nodes* is specified, sets the Sankey generator’s nodes accessor to the specified function or array and returns this Sankey generator. If *nodes* is not specified, returns the current nodes accessor, which defaults to:
|
||||
|
||||
```js
|
||||
function nodes(graph) {
|
||||
return graph.nodes;
|
||||
}
|
||||
```
|
||||
|
||||
If *nodes* is specified as a function, the function is invoked when the Sankey layout is [generated](#_sankey), being passed any arguments passed to the Sankey generator. This function must return an array of nodes. If *nodes* is not a function, it must be a constant array of *nodes*.
|
||||
|
||||
Each *node* must be an object. The following properties are assigned by the [Sankey generator](#_sankey):
|
||||
|
||||
* *node*.sourceLinks - the array of outgoing [links](#sankey_links) which have this node as their source
|
||||
* *node*.targetLinks - the array of incoming [links](#sankey_links) which have this node as their target
|
||||
* *node*.value - the node’s value; this is the sum of *link*.value for the node’s incoming [links](#sankey_links), or *node*.fixedValue if defined
|
||||
* *node*.index - the node’s zero-based index within the array of nodes
|
||||
* *node*.depth - the node’s zero-based graph depth, derived from the graph topology
|
||||
* *node*.height - the node’s zero-based graph height, derived from the graph topology
|
||||
* *node*.layer - the node’s zero-based column index, corresponding to its horizontal position
|
||||
* *node*.x0 - the node’s minimum horizontal position, derived from *node*.depth
|
||||
* *node*.x1 - the node’s maximum horizontal position (*node*.x0 + [*sankey*.nodeWidth](#sankey_nodeWidth))
|
||||
* *node*.y0 - the node’s minimum vertical position
|
||||
* *node*.y1 - the node’s maximum vertical position (*node*.y1 - *node*.y0 is proportional to *node*.value)
|
||||
|
||||
See also [*sankey*.links](#sankey_links).
|
||||
|
||||
<a name="sankey_links" href="#sankey_links">#</a> <i>sankey</i>.<b>links</b>([<i>links</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *links* is specified, sets the Sankey generator’s links accessor to the specified function or array and returns this Sankey generator. If *links* is not specified, returns the current links accessor, which defaults to:
|
||||
|
||||
```js
|
||||
function links(graph) {
|
||||
return graph.links;
|
||||
}
|
||||
```
|
||||
|
||||
If *links* is specified as a function, the function is invoked when the Sankey layout is [generated](#_sankey), being passed any arguments passed to the Sankey generator. This function must return an array of links. If *links* is not a function, it must be a constant array of *links*.
|
||||
|
||||
Each *link* must be an object with the following properties:
|
||||
|
||||
* *link*.source - the link’s source [node](#sankey_nodes)
|
||||
* *link*.target - the link’s target [node](#sankey_nodes)
|
||||
* *link*.value - the link’s numeric value
|
||||
|
||||
For convenience, a link’s source and target may be initialized using numeric or string identifiers rather than object references; see [*sankey*.nodeId](#sankey_nodeId). The following properties are assigned to each link by the [Sankey generator](#_sankey):
|
||||
|
||||
* *link*.y0 - the link’s vertical starting position (at source node)
|
||||
* *link*.y1 - the link’s vertical end position (at target node)
|
||||
* *link*.width - the link’s width (proportional to *link*.value)
|
||||
* *link*.index - the zero-based index of *link* within the array of links
|
||||
|
||||
<a name="sankey_linkSort" href="#sankey_linkSort">#</a> <i>sankey</i>.<b>linkSort</b>([<i>sort</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *sort* is specified, sets the link sort method and returns this Sankey generator. If *sort* is not specified, returns the current link sort method, which defaults to *undefined*, indicating that vertical order of links within each node will be determined automatically by the layout. If *sort* is null, the order is fixed by the input. Otherwise, the specified *sort* function determines the order; the function is passed two links, and must return a value less than 0 if the first link should be above the second, and a value greater than 0 if the second link should be above the first, or 0 if the order is not specified.
|
||||
|
||||
<a name="sankey_nodeId" href="#sankey_nodeId">#</a> <i>sankey</i>.<b>nodeId</b>([<i>id</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *id* is specified, sets the node id accessor to the specified function and returns this Sankey generator. If *id* is not specified, returns the current node id accessor, which defaults to the numeric *node*.index:
|
||||
|
||||
```js
|
||||
function id(d) {
|
||||
return d.index;
|
||||
}
|
||||
```
|
||||
|
||||
The default id accessor allows each link’s source and target to be specified as a zero-based index into the [nodes](#sankey_nodes) array. For example:
|
||||
|
||||
```js
|
||||
var nodes = [
|
||||
{"id": "Alice"},
|
||||
{"id": "Bob"},
|
||||
{"id": "Carol"}
|
||||
];
|
||||
|
||||
var links = [
|
||||
{"source": 0, "target": 1}, // Alice → Bob
|
||||
{"source": 1, "target": 2} // Bob → Carol
|
||||
];
|
||||
```
|
||||
|
||||
Now consider a different id accessor that returns a string:
|
||||
|
||||
```js
|
||||
function id(d) {
|
||||
return d.id;
|
||||
}
|
||||
```
|
||||
|
||||
With this accessor, you can use named sources and targets:
|
||||
|
||||
```js
|
||||
var nodes = [
|
||||
{"id": "Alice"},
|
||||
{"id": "Bob"},
|
||||
{"id": "Carol"}
|
||||
];
|
||||
|
||||
var links = [
|
||||
{"source": "Alice", "target": "Bob"},
|
||||
{"source": "Bob", "target": "Carol"}
|
||||
];
|
||||
```
|
||||
|
||||
This is particularly useful when representing graphs in JSON, as JSON does not allow references. See [this example](https://bl.ocks.org/mbostock/f584aa36df54c451c94a9d0798caed35).
|
||||
|
||||
<a name="sankey_nodeAlign" href="#sankey_nodeAlign">#</a> <i>sankey</i>.<b>nodeAlign</b>([<i>align</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *align* is specified, sets the node [alignment method](#alignments) to the specified function and returns this Sankey generator. If *align* is not specified, returns the current node alignment method, which defaults to [d3.sankeyJustify](#sankeyJustify). The specified function is evaluated for each input *node* in order, being passed the current *node* and the total depth *n* of the graph (one plus the maximum *node*.depth), and must return an integer between 0 and *n* - 1 that indicates the desired horizontal position of the node in the generated Sankey diagram.
|
||||
|
||||
<a name="sankey_nodeSort" href="#sankey_nodeSort">#</a> <i>sankey</i>.<b>nodeSort</b>([<i>sort</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *sort* is specified, sets the node sort method and returns this Sankey generator. If *sort* is not specified, returns the current node sort method, which defaults to *undefined*, indicating that vertical order of nodes within each column will be determined automatically by the layout. If *sort* is null, the order is fixed by the input. Otherwise, the specified *sort* function determines the order; the function is passed two nodes, and must return a value less than 0 if the first node should be above the second, and a value greater than 0 if the second node should be above the first, or 0 if the order is not specified.
|
||||
|
||||
<a name="sankey_nodeWidth" href="#sankey_nodeWidth">#</a> <i>sankey</i>.<b>nodeWidth</b>([<i>width</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *width* is specified, sets the node width to the specified number and returns this Sankey generator. If *width* is not specified, returns the current node width, which defaults to 24.
|
||||
|
||||
<a name="sankey_nodePadding" href="#sankey_nodePadding">#</a> <i>sankey</i>.<b>nodePadding</b>([<i>padding</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *padding* is specified, sets the vertical separation between nodes at each column to the specified number and returns this Sankey generator. If *padding* is not specified, returns the current node padding, which defaults to 8.
|
||||
|
||||
<a name="sankey_extent" href="#sankey_extent">#</a> <i>sankey</i>.<b>extent</b>([<i>extent</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *extent* is specified, sets the extent of the Sankey layout to the specified bounds and returns the layout. The *extent* bounds are specified as an array \[\[<i>x0</i>, <i>y0</i>\], \[<i>x1</i>, <i>y1</i>\]\], where *x0* is the left side of the extent, *y0* is the top, *x1* is the right and *y1* is the bottom. If *extent* is not specified, returns the current extent which defaults to [[0, 0], [1, 1]].
|
||||
|
||||
<a name="sankey_size" href="#sankey_size">#</a> <i>sankey</i>.<b>size</b>([<i>size</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
An alias for [*sankey*.extent](#sankey_extent) where the minimum *x* and *y* of the extent are ⟨0,0⟩. Equivalent to:
|
||||
|
||||
```js
|
||||
sankey.extent([[0, 0], size]);
|
||||
```
|
||||
|
||||
<a name="sankey_iterations" href="#sankey_iterations">#</a> <i>sankey</i>.<b>iterations</b>([<i>iterations</i>]) [<>](https://github.com/d3/d3-sankey/blob/master/src/sankey.js "Source")
|
||||
|
||||
If *iterations* is specified, sets the number of relaxation iterations when [generating the layout](#_sankey) and returns this Sankey generator. If *iterations* is not specified, returns the current number of relaxation iterations, which defaults to 6.
|
||||
|
||||
### Alignments
|
||||
|
||||
See [*sankey*.nodeAlign](#sankey_nodeAlign).
|
||||
|
||||
<a name="sankeyLeft" href="#sankeyLeft">#</a> d3.<b>sankeyLeft</b>(<i>node</i>, <i>n</i>) [<>](https://github.com/d3/d3-sankey/blob/master/src/align.js "Source")
|
||||
|
||||
[<img alt="left" src="https://raw.githubusercontent.com/d3/d3-sankey/master/img/align-left.png" width="480">](https://observablehq.com/@d3/sankey-diagram?align=left)
|
||||
|
||||
Returns *node*.depth.
|
||||
|
||||
<a name="sankeyRight" href="#sankeyRight">#</a> d3.<b>sankeyRight</b>(<i>node</i>, <i>n</i>) [<>](https://github.com/d3/d3-sankey/blob/master/src/align.js "Source")
|
||||
|
||||
[<img alt="right" src="https://raw.githubusercontent.com/d3/d3-sankey/master/img/align-right.png" width="480">](https://observablehq.com/@d3/sankey-diagram?align=right)
|
||||
|
||||
Returns *n* - 1 - *node*.height.
|
||||
|
||||
<a name="sankeyCenter" href="#sankeyCenter">#</a> d3.<b>sankeyCenter</b>(<i>node</i>, <i>n</i>) [<>](https://github.com/d3/d3-sankey/blob/master/src/align.js "Source")
|
||||
|
||||
[<img alt="center" src="https://raw.githubusercontent.com/d3/d3-sankey/master/img/align-center.png" width="480">](https://observablehq.com/@d3/sankey-diagram?align=center)
|
||||
|
||||
Like [d3.sankeyLeft](#sankeyLeft), except that nodes without any incoming links are moved as right as possible.
|
||||
|
||||
<a name="sankeyJustify" href="#sankeyJustify">#</a> d3.<b>sankeyJustify</b>(<i>node</i>, <i>n</i>) [<>](https://github.com/d3/d3-sankey/blob/master/src/align.js "Source")
|
||||
|
||||
[<img alt="justify" src="https://raw.githubusercontent.com/d3/d3-sankey/master/img/energy.png" width="480">](https://observablehq.com/@d3/sankey-diagram)
|
||||
|
||||
Like [d3.sankeyLeft](#sankeyLeft), except that nodes without any outgoing links are moved to the far right.
|
||||
|
||||
### Links
|
||||
|
||||
<a name="sankeyLinkHorizontal" href="#sankeyLinkHorizontal">#</a> d3.<b>sankeyLinkHorizontal</b>() [<>](https://github.com/d3/d3-sankey/blob/master/src/sankeyLinkHorizontal.js "Source")
|
||||
|
||||
Returns a [horizontal link shape](https://github.com/d3/d3-shape/blob/master/README.md#linkHorizontal) suitable for a Sankey diagram. The [source accessor](https://github.com/d3/d3-shape/blob/master/README.md#link_source) is defined as:
|
||||
|
||||
```js
|
||||
function source(d) {
|
||||
return [d.source.x1, d.y0];
|
||||
}
|
||||
```
|
||||
|
||||
The [target accessor](https://github.com/d3/d3-shape/blob/master/README.md#link_target) is defined as:
|
||||
|
||||
```js
|
||||
function target(d) {
|
||||
return [d.target.x0, d.y1];
|
||||
}
|
||||
```
|
||||
|
||||
For example, to render the links of a Sankey diagram in SVG, you might say:
|
||||
|
||||
```js
|
||||
svg.append("g")
|
||||
.attr("fill", "none")
|
||||
.attr("stroke", "#000")
|
||||
.attr("stroke-opacity", 0.2)
|
||||
.selectAll("path")
|
||||
.data(graph.links)
|
||||
.join("path")
|
||||
.attr("d", d3.sankeyLinkHorizontal())
|
||||
.attr("stroke-width", function(d) { return d.width; });
|
||||
```
|
||||
+425
@@ -0,0 +1,425 @@
|
||||
// https://github.com/d3/d3-sankey v0.12.3 Copyright 2019 Mike Bostock
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('d3-array'), require('d3-shape')) :
|
||||
typeof define === 'function' && define.amd ? define(['exports', 'd3-array', 'd3-shape'], factory) :
|
||||
(global = global || self, factory(global.d3 = global.d3 || {}, global.d3, global.d3));
|
||||
}(this, function (exports, d3Array, d3Shape) { 'use strict';
|
||||
|
||||
function targetDepth(d) {
|
||||
return d.target.depth;
|
||||
}
|
||||
|
||||
function left(node) {
|
||||
return node.depth;
|
||||
}
|
||||
|
||||
function right(node, n) {
|
||||
return n - 1 - node.height;
|
||||
}
|
||||
|
||||
function justify(node, n) {
|
||||
return node.sourceLinks.length ? node.depth : n - 1;
|
||||
}
|
||||
|
||||
function center(node) {
|
||||
return node.targetLinks.length ? node.depth
|
||||
: node.sourceLinks.length ? d3Array.min(node.sourceLinks, targetDepth) - 1
|
||||
: 0;
|
||||
}
|
||||
|
||||
function constant(x) {
|
||||
return function() {
|
||||
return x;
|
||||
};
|
||||
}
|
||||
|
||||
function ascendingSourceBreadth(a, b) {
|
||||
return ascendingBreadth(a.source, b.source) || a.index - b.index;
|
||||
}
|
||||
|
||||
function ascendingTargetBreadth(a, b) {
|
||||
return ascendingBreadth(a.target, b.target) || a.index - b.index;
|
||||
}
|
||||
|
||||
function ascendingBreadth(a, b) {
|
||||
return a.y0 - b.y0;
|
||||
}
|
||||
|
||||
function value(d) {
|
||||
return d.value;
|
||||
}
|
||||
|
||||
function defaultId(d) {
|
||||
return d.index;
|
||||
}
|
||||
|
||||
function defaultNodes(graph) {
|
||||
return graph.nodes;
|
||||
}
|
||||
|
||||
function defaultLinks(graph) {
|
||||
return graph.links;
|
||||
}
|
||||
|
||||
function find(nodeById, id) {
|
||||
const node = nodeById.get(id);
|
||||
if (!node) throw new Error("missing: " + id);
|
||||
return node;
|
||||
}
|
||||
|
||||
function computeLinkBreadths({nodes}) {
|
||||
for (const node of nodes) {
|
||||
let y0 = node.y0;
|
||||
let y1 = y0;
|
||||
for (const link of node.sourceLinks) {
|
||||
link.y0 = y0 + link.width / 2;
|
||||
y0 += link.width;
|
||||
}
|
||||
for (const link of node.targetLinks) {
|
||||
link.y1 = y1 + link.width / 2;
|
||||
y1 += link.width;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function Sankey() {
|
||||
let x0 = 0, y0 = 0, x1 = 1, y1 = 1; // extent
|
||||
let dx = 24; // nodeWidth
|
||||
let dy = 8, py; // nodePadding
|
||||
let id = defaultId;
|
||||
let align = justify;
|
||||
let sort;
|
||||
let linkSort;
|
||||
let nodes = defaultNodes;
|
||||
let links = defaultLinks;
|
||||
let iterations = 6;
|
||||
|
||||
function sankey() {
|
||||
const graph = {nodes: nodes.apply(null, arguments), links: links.apply(null, arguments)};
|
||||
computeNodeLinks(graph);
|
||||
computeNodeValues(graph);
|
||||
computeNodeDepths(graph);
|
||||
computeNodeHeights(graph);
|
||||
computeNodeBreadths(graph);
|
||||
computeLinkBreadths(graph);
|
||||
return graph;
|
||||
}
|
||||
|
||||
sankey.update = function(graph) {
|
||||
computeLinkBreadths(graph);
|
||||
return graph;
|
||||
};
|
||||
|
||||
sankey.nodeId = function(_) {
|
||||
return arguments.length ? (id = typeof _ === "function" ? _ : constant(_), sankey) : id;
|
||||
};
|
||||
|
||||
sankey.nodeAlign = function(_) {
|
||||
return arguments.length ? (align = typeof _ === "function" ? _ : constant(_), sankey) : align;
|
||||
};
|
||||
|
||||
sankey.nodeSort = function(_) {
|
||||
return arguments.length ? (sort = _, sankey) : sort;
|
||||
};
|
||||
|
||||
sankey.nodeWidth = function(_) {
|
||||
return arguments.length ? (dx = +_, sankey) : dx;
|
||||
};
|
||||
|
||||
sankey.nodePadding = function(_) {
|
||||
return arguments.length ? (dy = py = +_, sankey) : dy;
|
||||
};
|
||||
|
||||
sankey.nodes = function(_) {
|
||||
return arguments.length ? (nodes = typeof _ === "function" ? _ : constant(_), sankey) : nodes;
|
||||
};
|
||||
|
||||
sankey.links = function(_) {
|
||||
return arguments.length ? (links = typeof _ === "function" ? _ : constant(_), sankey) : links;
|
||||
};
|
||||
|
||||
sankey.linkSort = function(_) {
|
||||
return arguments.length ? (linkSort = _, sankey) : linkSort;
|
||||
};
|
||||
|
||||
sankey.size = function(_) {
|
||||
return arguments.length ? (x0 = y0 = 0, x1 = +_[0], y1 = +_[1], sankey) : [x1 - x0, y1 - y0];
|
||||
};
|
||||
|
||||
sankey.extent = function(_) {
|
||||
return arguments.length ? (x0 = +_[0][0], x1 = +_[1][0], y0 = +_[0][1], y1 = +_[1][1], sankey) : [[x0, y0], [x1, y1]];
|
||||
};
|
||||
|
||||
sankey.iterations = function(_) {
|
||||
return arguments.length ? (iterations = +_, sankey) : iterations;
|
||||
};
|
||||
|
||||
function computeNodeLinks({nodes, links}) {
|
||||
for (const [i, node] of nodes.entries()) {
|
||||
node.index = i;
|
||||
node.sourceLinks = [];
|
||||
node.targetLinks = [];
|
||||
}
|
||||
const nodeById = new Map(nodes.map((d, i) => [id(d, i, nodes), d]));
|
||||
for (const [i, link] of links.entries()) {
|
||||
link.index = i;
|
||||
let {source, target} = link;
|
||||
if (typeof source !== "object") source = link.source = find(nodeById, source);
|
||||
if (typeof target !== "object") target = link.target = find(nodeById, target);
|
||||
source.sourceLinks.push(link);
|
||||
target.targetLinks.push(link);
|
||||
}
|
||||
if (linkSort != null) {
|
||||
for (const {sourceLinks, targetLinks} of nodes) {
|
||||
sourceLinks.sort(linkSort);
|
||||
targetLinks.sort(linkSort);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function computeNodeValues({nodes}) {
|
||||
for (const node of nodes) {
|
||||
node.value = node.fixedValue === undefined
|
||||
? Math.max(d3Array.sum(node.sourceLinks, value), d3Array.sum(node.targetLinks, value))
|
||||
: node.fixedValue;
|
||||
}
|
||||
}
|
||||
|
||||
function computeNodeDepths({nodes}) {
|
||||
const n = nodes.length;
|
||||
let current = new Set(nodes);
|
||||
let next = new Set;
|
||||
let x = 0;
|
||||
while (current.size) {
|
||||
for (const node of current) {
|
||||
node.depth = x;
|
||||
for (const {target} of node.sourceLinks) {
|
||||
next.add(target);
|
||||
}
|
||||
}
|
||||
if (++x > n) throw new Error("circular link");
|
||||
current = next;
|
||||
next = new Set;
|
||||
}
|
||||
}
|
||||
|
||||
function computeNodeHeights({nodes}) {
|
||||
const n = nodes.length;
|
||||
let current = new Set(nodes);
|
||||
let next = new Set;
|
||||
let x = 0;
|
||||
while (current.size) {
|
||||
for (const node of current) {
|
||||
node.height = x;
|
||||
for (const {source} of node.targetLinks) {
|
||||
next.add(source);
|
||||
}
|
||||
}
|
||||
if (++x > n) throw new Error("circular link");
|
||||
current = next;
|
||||
next = new Set;
|
||||
}
|
||||
}
|
||||
|
||||
function computeNodeLayers({nodes}) {
|
||||
const x = d3Array.max(nodes, d => d.depth) + 1;
|
||||
const kx = (x1 - x0 - dx) / (x - 1);
|
||||
const columns = new Array(x);
|
||||
for (const node of nodes) {
|
||||
const i = Math.max(0, Math.min(x - 1, Math.floor(align.call(null, node, x))));
|
||||
node.layer = i;
|
||||
node.x0 = x0 + i * kx;
|
||||
node.x1 = node.x0 + dx;
|
||||
if (columns[i]) columns[i].push(node);
|
||||
else columns[i] = [node];
|
||||
}
|
||||
if (sort) for (const column of columns) {
|
||||
column.sort(sort);
|
||||
}
|
||||
return columns;
|
||||
}
|
||||
|
||||
function initializeNodeBreadths(columns) {
|
||||
const ky = d3Array.min(columns, c => (y1 - y0 - (c.length - 1) * py) / d3Array.sum(c, value));
|
||||
for (const nodes of columns) {
|
||||
let y = y0;
|
||||
for (const node of nodes) {
|
||||
node.y0 = y;
|
||||
node.y1 = y + node.value * ky;
|
||||
y = node.y1 + py;
|
||||
for (const link of node.sourceLinks) {
|
||||
link.width = link.value * ky;
|
||||
}
|
||||
}
|
||||
y = (y1 - y + py) / (nodes.length + 1);
|
||||
for (let i = 0; i < nodes.length; ++i) {
|
||||
const node = nodes[i];
|
||||
node.y0 += y * (i + 1);
|
||||
node.y1 += y * (i + 1);
|
||||
}
|
||||
reorderLinks(nodes);
|
||||
}
|
||||
}
|
||||
|
||||
function computeNodeBreadths(graph) {
|
||||
const columns = computeNodeLayers(graph);
|
||||
py = Math.min(dy, (y1 - y0) / (d3Array.max(columns, c => c.length) - 1));
|
||||
initializeNodeBreadths(columns);
|
||||
for (let i = 0; i < iterations; ++i) {
|
||||
const alpha = Math.pow(0.99, i);
|
||||
const beta = Math.max(1 - alpha, (i + 1) / iterations);
|
||||
relaxRightToLeft(columns, alpha, beta);
|
||||
relaxLeftToRight(columns, alpha, beta);
|
||||
}
|
||||
}
|
||||
|
||||
// Reposition each node based on its incoming (target) links.
|
||||
function relaxLeftToRight(columns, alpha, beta) {
|
||||
for (let i = 1, n = columns.length; i < n; ++i) {
|
||||
const column = columns[i];
|
||||
for (const target of column) {
|
||||
let y = 0;
|
||||
let w = 0;
|
||||
for (const {source, value} of target.targetLinks) {
|
||||
let v = value * (target.layer - source.layer);
|
||||
y += targetTop(source, target) * v;
|
||||
w += v;
|
||||
}
|
||||
if (!(w > 0)) continue;
|
||||
let dy = (y / w - target.y0) * alpha;
|
||||
target.y0 += dy;
|
||||
target.y1 += dy;
|
||||
reorderNodeLinks(target);
|
||||
}
|
||||
if (sort === undefined) column.sort(ascendingBreadth);
|
||||
resolveCollisions(column, beta);
|
||||
}
|
||||
}
|
||||
|
||||
// Reposition each node based on its outgoing (source) links.
|
||||
function relaxRightToLeft(columns, alpha, beta) {
|
||||
for (let n = columns.length, i = n - 2; i >= 0; --i) {
|
||||
const column = columns[i];
|
||||
for (const source of column) {
|
||||
let y = 0;
|
||||
let w = 0;
|
||||
for (const {target, value} of source.sourceLinks) {
|
||||
let v = value * (target.layer - source.layer);
|
||||
y += sourceTop(source, target) * v;
|
||||
w += v;
|
||||
}
|
||||
if (!(w > 0)) continue;
|
||||
let dy = (y / w - source.y0) * alpha;
|
||||
source.y0 += dy;
|
||||
source.y1 += dy;
|
||||
reorderNodeLinks(source);
|
||||
}
|
||||
if (sort === undefined) column.sort(ascendingBreadth);
|
||||
resolveCollisions(column, beta);
|
||||
}
|
||||
}
|
||||
|
||||
function resolveCollisions(nodes, alpha) {
|
||||
const i = nodes.length >> 1;
|
||||
const subject = nodes[i];
|
||||
resolveCollisionsBottomToTop(nodes, subject.y0 - py, i - 1, alpha);
|
||||
resolveCollisionsTopToBottom(nodes, subject.y1 + py, i + 1, alpha);
|
||||
resolveCollisionsBottomToTop(nodes, y1, nodes.length - 1, alpha);
|
||||
resolveCollisionsTopToBottom(nodes, y0, 0, alpha);
|
||||
}
|
||||
|
||||
// Push any overlapping nodes down.
|
||||
function resolveCollisionsTopToBottom(nodes, y, i, alpha) {
|
||||
for (; i < nodes.length; ++i) {
|
||||
const node = nodes[i];
|
||||
const dy = (y - node.y0) * alpha;
|
||||
if (dy > 1e-6) node.y0 += dy, node.y1 += dy;
|
||||
y = node.y1 + py;
|
||||
}
|
||||
}
|
||||
|
||||
// Push any overlapping nodes up.
|
||||
function resolveCollisionsBottomToTop(nodes, y, i, alpha) {
|
||||
for (; i >= 0; --i) {
|
||||
const node = nodes[i];
|
||||
const dy = (node.y1 - y) * alpha;
|
||||
if (dy > 1e-6) node.y0 -= dy, node.y1 -= dy;
|
||||
y = node.y0 - py;
|
||||
}
|
||||
}
|
||||
|
||||
function reorderNodeLinks({sourceLinks, targetLinks}) {
|
||||
if (linkSort === undefined) {
|
||||
for (const {source: {sourceLinks}} of targetLinks) {
|
||||
sourceLinks.sort(ascendingTargetBreadth);
|
||||
}
|
||||
for (const {target: {targetLinks}} of sourceLinks) {
|
||||
targetLinks.sort(ascendingSourceBreadth);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function reorderLinks(nodes) {
|
||||
if (linkSort === undefined) {
|
||||
for (const {sourceLinks, targetLinks} of nodes) {
|
||||
sourceLinks.sort(ascendingTargetBreadth);
|
||||
targetLinks.sort(ascendingSourceBreadth);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Returns the target.y0 that would produce an ideal link from source to target.
|
||||
function targetTop(source, target) {
|
||||
let y = source.y0 - (source.sourceLinks.length - 1) * py / 2;
|
||||
for (const {target: node, width} of source.sourceLinks) {
|
||||
if (node === target) break;
|
||||
y += width + py;
|
||||
}
|
||||
for (const {source: node, width} of target.targetLinks) {
|
||||
if (node === source) break;
|
||||
y -= width;
|
||||
}
|
||||
return y;
|
||||
}
|
||||
|
||||
// Returns the source.y0 that would produce an ideal link from source to target.
|
||||
function sourceTop(source, target) {
|
||||
let y = target.y0 - (target.targetLinks.length - 1) * py / 2;
|
||||
for (const {source: node, width} of target.targetLinks) {
|
||||
if (node === source) break;
|
||||
y += width + py;
|
||||
}
|
||||
for (const {target: node, width} of source.sourceLinks) {
|
||||
if (node === target) break;
|
||||
y -= width;
|
||||
}
|
||||
return y;
|
||||
}
|
||||
|
||||
return sankey;
|
||||
}
|
||||
|
||||
function horizontalSource(d) {
|
||||
return [d.source.x1, d.y0];
|
||||
}
|
||||
|
||||
function horizontalTarget(d) {
|
||||
return [d.target.x0, d.y1];
|
||||
}
|
||||
|
||||
function sankeyLinkHorizontal() {
|
||||
return d3Shape.linkHorizontal()
|
||||
.source(horizontalSource)
|
||||
.target(horizontalTarget);
|
||||
}
|
||||
|
||||
exports.sankey = Sankey;
|
||||
exports.sankeyCenter = center;
|
||||
exports.sankeyJustify = justify;
|
||||
exports.sankeyLeft = left;
|
||||
exports.sankeyLinkHorizontal = sankeyLinkHorizontal;
|
||||
exports.sankeyRight = right;
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
}));
|
||||
+2
File diff suppressed because one or more lines are too long
+27
@@ -0,0 +1,27 @@
|
||||
Copyright 2010-2020 Mike Bostock
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the author nor the names of contributors may be used to
|
||||
endorse or promote products derived from this software without specific prior
|
||||
written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
+871
@@ -0,0 +1,871 @@
|
||||
# d3-array
|
||||
|
||||
Data in JavaScript is often represented by an iterable (such as an [array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array), [set](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Set) or [generator](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Generator)), and so iterable manipulation is a common task when analyzing or visualizing data. For example, you might take a contiguous slice (subset) of an array, filter an array using a predicate function, or map an array to a parallel set of values using a transform function. Before looking at the methods that d3-array provides, familiarize yourself with the powerful [array methods built-in to JavaScript](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array).
|
||||
|
||||
JavaScript includes **mutation methods** that modify the array:
|
||||
|
||||
* [*array*.pop](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/pop) - Remove the last element from the array.
|
||||
* [*array*.push](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/push) - Add one or more elements to the end of the array.
|
||||
* [*array*.reverse](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse) - Reverse the order of the elements of the array.
|
||||
* [*array*.shift](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/shift) - Remove the first element from the array.
|
||||
* [*array*.sort](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) - Sort the elements of the array.
|
||||
* [*array*.splice](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) - Add or remove elements from the array.
|
||||
* [*array*.unshift](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) - Add one or more elements to the front of the array.
|
||||
|
||||
There are also **access methods** that return some representation of the array:
|
||||
|
||||
* [*array*.concat](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/concat) - Join the array with other array(s) or value(s).
|
||||
* [*array*.join](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/join) - Join all elements of the array into a string.
|
||||
* [*array*.slice](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/slice) - Extract a section of the array.
|
||||
* [*array*.indexOf](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf) - Find the first occurrence of a value within the array.
|
||||
* [*array*.lastIndexOf](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) - Find the last occurrence of a value within the array.
|
||||
|
||||
And finally **iteration methods** that apply functions to elements in the array:
|
||||
|
||||
* [*array*.filter](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/filter) - Create a new array with only the elements for which a predicate is true.
|
||||
* [*array*.forEach](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach) - Call a function for each element in the array.
|
||||
* [*array*.every](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/every) - See if every element in the array satisfies a predicate.
|
||||
* [*array*.map](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/map) - Create a new array with the result of calling a function on every element in the array.
|
||||
* [*array*.some](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/some) - See if at least one element in the array satisfies a predicate.
|
||||
* [*array*.reduce](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce) - Apply a function to reduce the array to a single value (from left-to-right).
|
||||
* [*array*.reduceRight](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/reduceRight) - Apply a function to reduce the array to a single value (from right-to-left).
|
||||
|
||||
## Installing
|
||||
|
||||
If you use NPM, `npm install d3-array`. Otherwise, download the [latest release](https://github.com/d3/d3-array/releases/latest). You can also load directly from [d3js.org](https://d3js.org), either as a [standalone library](https://d3js.org/d3-array.v2.min.js) or as part of [D3](https://github.com/d3/d3). AMD, CommonJS, and vanilla environments are supported. In vanilla, a `d3` global is exported:
|
||||
|
||||
```html
|
||||
<script src="https://d3js.org/d3-array.v2.min.js"></script>
|
||||
<script>
|
||||
|
||||
var min = d3.min(array);
|
||||
|
||||
</script>
|
||||
```
|
||||
|
||||
## API Reference
|
||||
|
||||
* [Statistics](#statistics)
|
||||
* [Search](#search)
|
||||
* [Transformations](#transformations)
|
||||
* [Iterables](#iterables)
|
||||
* [Sets](#sets)
|
||||
* [Bins](#bins)
|
||||
* [Interning](#interning)
|
||||
|
||||
### Statistics
|
||||
|
||||
Methods for computing basic summary statistics.
|
||||
|
||||
<a name="min" href="#min">#</a> d3.<b>min</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/min.js), [Examples](https://observablehq.com/@d3/d3-extent)
|
||||
|
||||
Returns the minimum value in the given *iterable* using natural order. If the iterable contains no comparable values, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the minimum value.
|
||||
|
||||
Unlike the built-in [Math.min](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Math/min), this method ignores undefined, null and NaN values; this is useful for ignoring missing data. In addition, elements are compared using natural order rather than numeric order. For example, the minimum of the strings [“20”, “3”] is “20”, while the minimum of the numbers [20, 3] is 3.
|
||||
|
||||
See also [extent](#extent).
|
||||
|
||||
<a name="minIndex" href="#minIndex">#</a> d3.<b>minIndex</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/minIndex.js), [Examples](https://observablehq.com/@d3/d3-extent)
|
||||
|
||||
Returns the index of the minimum value in the given *iterable* using natural order. If the iterable contains no comparable values, returns -1. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the minimum value.
|
||||
|
||||
Unlike the built-in [Math.min](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Math/min), this method ignores undefined, null and NaN values; this is useful for ignoring missing data. In addition, elements are compared using natural order rather than numeric order. For example, the minimum of the strings [“20”, “3”] is “20”, while the minimum of the numbers [20, 3] is 3.
|
||||
|
||||
<a name="max" href="#max">#</a> d3.<b>max</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/max.js), [Examples](https://observablehq.com/@d3/d3-extent)
|
||||
|
||||
Returns the maximum value in the given *iterable* using natural order. If the iterable contains no comparable values, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the maximum value.
|
||||
|
||||
Unlike the built-in [Math.max](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Math/max), this method ignores undefined values; this is useful for ignoring missing data. In addition, elements are compared using natural order rather than numeric order. For example, the maximum of the strings [“20”, “3”] is “3”, while the maximum of the numbers [20, 3] is 20.
|
||||
|
||||
See also [extent](#extent).
|
||||
|
||||
<a name="maxIndex" href="#maxIndex">#</a> d3.<b>maxIndex</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/maxIndex.js), [Examples](https://observablehq.com/@d3/d3-extent)
|
||||
|
||||
Returns the index of the maximum value in the given *iterable* using natural order. If the iterable contains no comparable values, returns -1. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the maximum value.
|
||||
|
||||
Unlike the built-in [Math.max](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Math/max), this method ignores undefined values; this is useful for ignoring missing data. In addition, elements are compared using natural order rather than numeric order. For example, the maximum of the strings [“20”, “3”] is “3”, while the maximum of the numbers [20, 3] is 20.
|
||||
|
||||
<a name="extent" href="#extent">#</a> d3.<b>extent</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/extent.js), [Examples](https://observablehq.com/@d3/d3-extent)
|
||||
|
||||
Returns the [minimum](#min) and [maximum](#max) value in the given *iterable* using natural order. If the iterable contains no comparable values, returns [undefined, undefined]. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the extent.
|
||||
|
||||
<a name="sum" href="#sum">#</a> d3.<b>sum</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/sum.js), [Examples](https://observablehq.com/@d3/d3-sum)
|
||||
|
||||
Returns the sum of the given *iterable* of numbers. If the iterable contains no numbers, returns 0. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the sum. This method ignores undefined and NaN values; this is useful for ignoring missing data.
|
||||
|
||||
<a name="mean" href="#mean">#</a> d3.<b>mean</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/mean.js), [Examples](https://observablehq.com/@d3/d3-mean-d3-median-and-friends)
|
||||
|
||||
Returns the mean of the given *iterable* of numbers. If the iterable contains no numbers, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the mean. This method ignores undefined and NaN values; this is useful for ignoring missing data.
|
||||
|
||||
<a name="median" href="#median">#</a> d3.<b>median</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/median.js), [Examples](https://observablehq.com/@d3/d3-mean-d3-median-and-friends)
|
||||
|
||||
Returns the median of the given *iterable* of numbers using the [R-7 method](https://en.wikipedia.org/wiki/Quantile#Estimating_quantiles_from_a_sample). If the iterable contains no numbers, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the median. This method ignores undefined and NaN values; this is useful for ignoring missing data.
|
||||
|
||||
<a name="cumsum" href="#cumsum">#</a> d3.<b>cumsum</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/cumsum.js), [Examples](https://observablehq.com/@d3/d3-cumsum)
|
||||
|
||||
Returns the cumulative sum of the given *iterable* of numbers, as a Float64Array of the same length. If the iterable contains no numbers, returns zeros. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the cumulative sum. This method ignores undefined and NaN values; this is useful for ignoring missing data.
|
||||
|
||||
<a name="quantile" href="#quantile">#</a> d3.<b>quantile</b>(<i>iterable</i>, <i>p</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/quantile.js), [Examples](https://observablehq.com/@d3/d3-mean-d3-median-and-friends)
|
||||
|
||||
Returns the *p*-quantile of the given *iterable* of numbers, where *p* is a number in the range [0, 1]. For example, the median can be computed using *p* = 0.5, the first quartile at *p* = 0.25, and the third quartile at *p* = 0.75. This particular implementation uses the [R-7 method](http://en.wikipedia.org/wiki/Quantile#Quantiles_of_a_population), which is the default for the R programming language and Excel. For example:
|
||||
|
||||
```js
|
||||
var a = [0, 10, 30];
|
||||
d3.quantile(a, 0); // 0
|
||||
d3.quantile(a, 0.5); // 10
|
||||
d3.quantile(a, 1); // 30
|
||||
d3.quantile(a, 0.25); // 5
|
||||
d3.quantile(a, 0.75); // 20
|
||||
d3.quantile(a, 0.1); // 2
|
||||
```
|
||||
|
||||
An optional *accessor* function may be specified, which is equivalent to calling *array*.map(*accessor*) before computing the quantile.
|
||||
|
||||
<a name="quantileSorted" href="#quantileSorted">#</a> d3.<b>quantileSorted</b>(<i>array</i>, <i>p</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/quantile.js), [Examples](https://observablehq.com/@d3/d3-mean-d3-median-and-friends)
|
||||
|
||||
Similar to *quantile*, but expects the input to be a **sorted** *array* of values. In contrast with *quantile*, the accessor is only called on the elements needed to compute the quantile.
|
||||
|
||||
<a name="variance" href="#variance">#</a> d3.<b>variance</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/variance.js), [Examples](https://observablehq.com/@d3/d3-mean-d3-median-and-friends)
|
||||
|
||||
Returns an [unbiased estimator of the population variance](http://mathworld.wolfram.com/SampleVariance.html) of the given *iterable* of numbers using [Welford’s algorithm](https://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Welford's_online_algorithm). If the iterable has fewer than two numbers, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the variance. This method ignores undefined and NaN values; this is useful for ignoring missing data.
|
||||
|
||||
<a name="deviation" href="#deviation">#</a> d3.<b>deviation</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/deviation.js), [Examples](https://observablehq.com/@d3/d3-mean-d3-median-and-friends)
|
||||
|
||||
Returns the standard deviation, defined as the square root of the [bias-corrected variance](#variance), of the given *iterable* of numbers. If the iterable has fewer than two numbers, returns undefined. An optional *accessor* function may be specified, which is equivalent to calling Array.from before computing the standard deviation. This method ignores undefined and NaN values; this is useful for ignoring missing data.
|
||||
|
||||
<a name="fsum" href="#fsum">#</a> d3.<b>fsum</b>([<i>values</i>][, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/fsum.js), [Examples](https://observablehq.com/@d3/d3-fsum)
|
||||
|
||||
Returns a full precision summation of the given *values*.
|
||||
|
||||
```js
|
||||
d3.fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1]); // 1
|
||||
d3.sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1]); // 0.9999999999999999
|
||||
```
|
||||
|
||||
Although slower, d3.fsum can replace d3.sum wherever greater precision is needed. Uses <a href="#adder">d3.Adder</a>.
|
||||
|
||||
<a name="fcumsum" href="#fcumsum">#</a> d3.<b>fcumsum</b>([<i>values</i>][, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/fsum.js), [Examples](https://observablehq.com/@d3/d3-fcumsum)
|
||||
|
||||
Returns a full precision cumulative sum of the given *values*.
|
||||
|
||||
```js
|
||||
d3.fcumsum([1, 1e-14, -1]); // [1, 1.00000000000001, 1e-14]
|
||||
d3.cumsum([1, 1e-14, -1]); // [1, 1.00000000000001, 9.992e-15]
|
||||
```
|
||||
|
||||
Although slower, d3.fcumsum can replace d3.cumsum when greater precision is needed. Uses <a href="#adder">d3.Adder</a>.
|
||||
|
||||
<a name="adder" href="#adder">#</a> new d3.<b>Adder</b>()
|
||||
|
||||
Creates a full precision adder for [IEEE 754](https://en.wikipedia.org/wiki/IEEE_754) floating point numbers, setting its initial value to 0.
|
||||
|
||||
<a name="adder_add" href="#adder_add">#</a> *adder*.<b>add</b>(<i>number</i>)
|
||||
|
||||
Adds the specified *number* to the adder’s current value and returns the adder.
|
||||
|
||||
<a name="adder_valueOf" href="#adder_valueOf">#</a> *adder*.<b>valueOf</b>()
|
||||
|
||||
Returns the IEEE 754 double precision representation of the adder’s current value. Most useful as the short-hand notation `+adder`.
|
||||
|
||||
### Search
|
||||
|
||||
Methods for searching arrays for a specific element.
|
||||
|
||||
<a name="least" href="#least">#</a> d3.<b>least</b>(<i>iterable</i>[, <i>comparator</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/least.js), [Examples](https://observablehq.com/@d3/d3-least)
|
||||
<br><a name="least" href="#least">#</a> d3.<b>least</b>(<i>iterable</i>[, <i>accessor</i>])
|
||||
|
||||
Returns the least element of the specified *iterable* according to the specified *comparator* or *accessor*. If the given *iterable* contains no comparable elements (*i.e.*, the comparator returns NaN when comparing each element to itself), returns undefined. If *comparator* is not specified, it defaults to [ascending](#ascending). For example:
|
||||
|
||||
```js
|
||||
const array = [{foo: 42}, {foo: 91}];
|
||||
d3.least(array, (a, b) => a.foo - b.foo); // {foo: 42}
|
||||
d3.least(array, (a, b) => b.foo - a.foo); // {foo: 91}
|
||||
d3.least(array, a => a.foo); // {foo: 42}
|
||||
```
|
||||
|
||||
This function is similar to [min](#min), except it allows the use of a comparator rather than an accessor.
|
||||
|
||||
<a name="leastIndex" href="#leastIndex">#</a> d3.<b>leastIndex</b>(<i>iterable</i>[, <i>comparator</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/leastIndex.js), [Examples](https://observablehq.com/@d3/d3-least)
|
||||
<br><a name="leastIndex" href="#leastIndex">#</a> d3.<b>leastIndex</b>(<i>iterable</i>[, <i>accessor</i>])
|
||||
|
||||
Returns the index of the least element of the specified *iterable* according to the specified *comparator* or *accessor*. If the given *iterable* contains no comparable elements (*i.e.*, the comparator returns NaN when comparing each element to itself), returns -1. If *comparator* is not specified, it defaults to [ascending](#ascending). For example:
|
||||
|
||||
```js
|
||||
const array = [{foo: 42}, {foo: 91}];
|
||||
d3.leastIndex(array, (a, b) => a.foo - b.foo); // 0
|
||||
d3.leastIndex(array, (a, b) => b.foo - a.foo); // 1
|
||||
d3.leastIndex(array, a => a.foo); // 0
|
||||
```
|
||||
|
||||
This function is similar to [minIndex](#minIndex), except it allows the use of a comparator rather than an accessor.
|
||||
|
||||
<a name="greatest" href="#greatest">#</a> d3.<b>greatest</b>(<i>iterable</i>[, <i>comparator</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/greatest.js), [Examples](https://observablehq.com/@d3/d3-least)
|
||||
<br><a name="greatest" href="#greatest">#</a> d3.<b>greatest</b>(<i>iterable</i>[, <i>accessor</i>])
|
||||
|
||||
Returns the greatest element of the specified *iterable* according to the specified *comparator* or *accessor*. If the given *iterable* contains no comparable elements (*i.e.*, the comparator returns NaN when comparing each element to itself), returns undefined. If *comparator* is not specified, it defaults to [ascending](#ascending). For example:
|
||||
|
||||
```js
|
||||
const array = [{foo: 42}, {foo: 91}];
|
||||
d3.greatest(array, (a, b) => a.foo - b.foo); // {foo: 91}
|
||||
d3.greatest(array, (a, b) => b.foo - a.foo); // {foo: 42}
|
||||
d3.greatest(array, a => a.foo); // {foo: 91}
|
||||
```
|
||||
|
||||
This function is similar to [max](#max), except it allows the use of a comparator rather than an accessor.
|
||||
|
||||
<a name="greatestIndex" href="#greatestIndex">#</a> d3.<b>greatestIndex</b>(<i>iterable</i>[, <i>comparator</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/greatestIndex.js), [Examples](https://observablehq.com/@d3/d3-least)
|
||||
<br><a name="greatestIndex" href="#greatestIndex">#</a> d3.<b>greatestIndex</b>(<i>iterable</i>[, <i>accessor</i>])
|
||||
|
||||
Returns the index of the greatest element of the specified *iterable* according to the specified *comparator* or *accessor*. If the given *iterable* contains no comparable elements (*i.e.*, the comparator returns NaN when comparing each element to itself), returns -1. If *comparator* is not specified, it defaults to [ascending](#ascending). For example:
|
||||
|
||||
```js
|
||||
const array = [{foo: 42}, {foo: 91}];
|
||||
d3.greatestIndex(array, (a, b) => a.foo - b.foo); // 1
|
||||
d3.greatestIndex(array, (a, b) => b.foo - a.foo); // 0
|
||||
d3.greatestIndex(array, a => a.foo); // 1
|
||||
```
|
||||
|
||||
This function is similar to [maxIndex](#maxIndex), except it allows the use of a comparator rather than an accessor.
|
||||
|
||||
<a name="bisectLeft" href="#bisectLeft">#</a> d3.<b>bisectLeft</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) · [Source](https://github.com/d3/d3-array/blob/master/src/bisect.js)
|
||||
|
||||
Returns the insertion point for *x* in *array* to maintain sorted order. The arguments *lo* and *hi* may be used to specify a subset of the array which should be considered; by default the entire array is used. If *x* is already present in *array*, the insertion point will be before (to the left of) any existing entries. The return value is suitable for use as the first argument to [splice](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/splice) assuming that *array* is already sorted. The returned insertion point *i* partitions the *array* into two halves so that all *v* < *x* for *v* in *array*.slice(*lo*, *i*) for the left side and all *v* >= *x* for *v* in *array*.slice(*i*, *hi*) for the right side.
|
||||
|
||||
<a name="bisect" href="#bisect">#</a> d3.<b>bisect</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) · [Source](https://github.com/d3/d3-array/blob/master/src/bisect.js), [Examples](https://observablehq.com/@d3/d3-bisect)
|
||||
<br><a name="bisectRight" href="#bisectRight">#</a> d3.<b>bisectRight</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]])
|
||||
|
||||
Similar to [bisectLeft](#bisectLeft), but returns an insertion point which comes after (to the right of) any existing entries of *x* in *array*. The returned insertion point *i* partitions the *array* into two halves so that all *v* <= *x* for *v* in *array*.slice(*lo*, *i*) for the left side and all *v* > *x* for *v* in *array*.slice(*i*, *hi*) for the right side.
|
||||
|
||||
<a name="bisectCenter" href="#bisectCenter">#</a> d3.<b>bisectCenter</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) · [Source](https://github.com/d3/d3-array/blob/master/src/bisect.js), [Examples](https://observablehq.com/@d3/multi-line-chart)
|
||||
|
||||
Returns the index of the value closest to *x* in the given *array* of numbers. The arguments *lo* (inclusive) and *hi* (exclusive) may be used to specify a subset of the array which should be considered; by default the entire array is used.
|
||||
|
||||
See [*bisector*.center](#bisector_center).
|
||||
|
||||
<a name="bisector" href="#bisector">#</a> d3.<b>bisector</b>(<i>accessor</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/bisector.js)
|
||||
<br><a name="bisector" href="#bisector">#</a> d3.<b>bisector</b>(<i>comparator</i>)
|
||||
|
||||
Returns a new bisector using the specified *accessor* or *comparator* function. This method can be used to bisect arrays of objects instead of being limited to simple arrays of primitives. For example, given the following array of objects:
|
||||
|
||||
```js
|
||||
var data = [
|
||||
{date: new Date(2011, 1, 1), value: 0.5},
|
||||
{date: new Date(2011, 2, 1), value: 0.6},
|
||||
{date: new Date(2011, 3, 1), value: 0.7},
|
||||
{date: new Date(2011, 4, 1), value: 0.8}
|
||||
];
|
||||
```
|
||||
|
||||
A suitable bisect function could be constructed as:
|
||||
|
||||
```js
|
||||
var bisectDate = d3.bisector(function(d) { return d.date; }).right;
|
||||
```
|
||||
|
||||
This is equivalent to specifying a comparator:
|
||||
|
||||
```js
|
||||
var bisectDate = d3.bisector(function(d, x) { return d.date - x; }).right;
|
||||
```
|
||||
|
||||
And then applied as *bisectDate*(*array*, *date*), returning an index. Note that the comparator is always passed the search value *x* as the second argument. Use a comparator rather than an accessor if you want values to be sorted in an order different than natural order, such as in descending rather than ascending order.
|
||||
|
||||
<a name="bisector_left" href="#bisector_left">#</a> <i>bisector</i>.<b>left</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) · [Source](https://github.com/d3/d3-array/blob/master/src/bisector.js)
|
||||
|
||||
Equivalent to [bisectLeft](#bisectLeft), but uses this bisector’s associated comparator.
|
||||
|
||||
<a name="bisector_right" href="#bisector_right">#</a> <i>bisector</i>.<b>right</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) · [Source](https://github.com/d3/d3-array/blob/master/src/bisector.js)
|
||||
|
||||
Equivalent to [bisectRight](#bisectRight), but uses this bisector’s associated comparator.
|
||||
|
||||
<a name="bisector_center" href="#bisector_center">#</a> <i>bisector</i>.<b>center</b>(<i>array</i>, <i>x</i>[, <i>lo</i>[, <i>hi</i>]]) · [Source](https://github.com/d3/d3-array/blob/master/src/bisector.js)
|
||||
|
||||
Returns the index of the closest value to *x* in the given sorted *array*. This expects that the bisector’s associated accessor returns a quantitative value, or that the bisector’s associated comparator returns a signed distance; otherwise, this method is equivalent to *bisector*.left.
|
||||
|
||||
<a name="quickselect" href="#quickselect">#</a> d3.<b>quickselect</b>(<i>array</i>, <i>k</i>, <i>left</i> = 0, <i>right</i> = <i>array</i>.length - 1, <i>compare</i> = ascending) · [Source](https://github.com/d3/d3-array/blob/master/src/quickselect.js), [Examples](https://observablehq.com/@d3/d3-quickselect)
|
||||
|
||||
See [mourner/quickselect](https://github.com/mourner/quickselect/blob/master/README.md).
|
||||
|
||||
<a name="ascending" href="#ascending">#</a> d3.<b>ascending</b>(<i>a</i>, <i>b</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/ascending.js), [Examples](https://observablehq.com/@d3/d3-ascending)
|
||||
|
||||
Returns -1 if *a* is less than *b*, or 1 if *a* is greater than *b*, or 0. This is the comparator function for natural order, and can be used in conjunction with the built-in [*array*.sort](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/sort) method to arrange elements in ascending order. It is implemented as:
|
||||
|
||||
```js
|
||||
function ascending(a, b) {
|
||||
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
|
||||
}
|
||||
```
|
||||
|
||||
Note that if no comparator function is specified to the built-in sort method, the default order is lexicographic (alphabetical), not natural! This can lead to surprising behavior when sorting an array of numbers.
|
||||
|
||||
<a name="descending" href="#descending">#</a> d3.<b>descending</b>(<i>a</i>, <i>b</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/descending.js), [Examples](https://observablehq.com/@d3/d3-ascending)
|
||||
|
||||
Returns -1 if *a* is greater than *b*, or 1 if *a* is less than *b*, or 0. This is the comparator function for reverse natural order, and can be used in conjunction with the built-in array sort method to arrange elements in descending order. It is implemented as:
|
||||
|
||||
```js
|
||||
function descending(a, b) {
|
||||
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
|
||||
}
|
||||
```
|
||||
|
||||
Note that if no comparator function is specified to the built-in sort method, the default order is lexicographic (alphabetical), not natural! This can lead to surprising behavior when sorting an array of numbers.
|
||||
|
||||
### Transformations
|
||||
|
||||
Methods for transforming arrays and for generating new arrays.
|
||||
|
||||
<a name="group" href="#group">#</a> d3.<b>group</b>(<i>iterable</i>, <i>...keys</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/group.js), [Examples](https://observablehq.com/@d3/d3-group-d3-rollup)
|
||||
|
||||
Groups the specified *iterable* of values into an [InternMap](#InternMap) from *key* to array of value. For example, given some data:
|
||||
|
||||
```js
|
||||
data = [
|
||||
{name: "jim", amount: "34.0", date: "11/12/2015"},
|
||||
{name: "carl", amount: "120.11", date: "11/12/2015"},
|
||||
{name: "stacy", amount: "12.01", date: "01/04/2016"},
|
||||
{name: "stacy", amount: "34.05", date: "01/04/2016"}
|
||||
]
|
||||
```
|
||||
|
||||
To group the data by name:
|
||||
|
||||
```js
|
||||
d3.group(data, d => d.name)
|
||||
```
|
||||
|
||||
This produces:
|
||||
|
||||
```js
|
||||
Map(3) {
|
||||
"jim" => Array(1)
|
||||
"carl" => Array(1)
|
||||
"stacy" => Array(2)
|
||||
}
|
||||
```
|
||||
|
||||
If more than one *key* is specified, a nested InternMap is returned. For example:
|
||||
|
||||
```js
|
||||
d3.group(data, d => d.name, d => d.date)
|
||||
```
|
||||
|
||||
This produces:
|
||||
|
||||
```js
|
||||
Map(3) {
|
||||
"jim" => Map(1) {
|
||||
"11/12/2015" => Array(1)
|
||||
}
|
||||
"carl" => Map(1) {
|
||||
"11/12/2015" => Array(1)
|
||||
}
|
||||
"stacy" => Map(1) {
|
||||
"01/04/2016" => Array(2)
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
To convert a Map to an Array, use [Array.from](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from). For example:
|
||||
|
||||
```js
|
||||
Array.from(d3.group(data, d => d.name))
|
||||
```
|
||||
|
||||
This produces:
|
||||
|
||||
```js
|
||||
[
|
||||
["jim", Array(1)],
|
||||
["carl", Array(1)],
|
||||
["stacy", Array(2)]
|
||||
]
|
||||
```
|
||||
|
||||
You can also simultaneously convert the [*key*, *value*] to some other representation by passing a map function to Array.from:
|
||||
|
||||
```js
|
||||
Array.from(d3.group(data, d => d.name), ([key, value]) => ({key, value}))
|
||||
```
|
||||
|
||||
This produces:
|
||||
|
||||
```js
|
||||
[
|
||||
{key: "jim", value: Array(1)},
|
||||
{key: "carl", value: Array(1)},
|
||||
{key: "stacy", value: Array(2)}
|
||||
]
|
||||
```
|
||||
|
||||
[*selection*.data](https://github.com/d3/d3-selection/blob/master/README.md#selection_data) accepts iterables directly, meaning that you can use a Map (or Set or other iterable) to perform a data join without first needing to convert to an array.
|
||||
|
||||
<a name="groups" href="#groups">#</a> d3.<b>groups</b>(<i>iterable</i>, <i>...keys</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/group.js), [Examples](https://observablehq.com/@d3/d3-group-d3-rollup)
|
||||
|
||||
Equivalent to [group](#group), but returns nested arrays instead of nested maps.
|
||||
|
||||
<a name="index" href="#index">#</a> d3.<b>index</b>(<i>iterable</i>, <i>...keys</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/group.js), [Examples](https://observablehq.com/@d3/d3-group)
|
||||
|
||||
Equivalent to [group](#group) but returns a unique value per compound key instead of an array, throwing if the key is not unique.
|
||||
|
||||
For example, given the data defined above,
|
||||
|
||||
```js
|
||||
d3.index(data, d => d.amount)
|
||||
```
|
||||
|
||||
returns
|
||||
|
||||
```js
|
||||
Map(4) {
|
||||
"34.0" => Object {name: "jim", amount: "34.0", date: "11/12/2015"}
|
||||
"120.11" => Object {name: "carl", amount: "120.11", date: "11/12/2015"}
|
||||
"12.01" => Object {name: "stacy", amount: "12.01", date: "01/04/2016"}
|
||||
"34.05" => Object {name: "stacy", amount: "34.05", date: "01/04/2016"}
|
||||
}
|
||||
```
|
||||
|
||||
On the other hand,
|
||||
|
||||
```js
|
||||
d3.index(data, d => d.name)
|
||||
```
|
||||
|
||||
throws an error because two objects share the same name.
|
||||
|
||||
<a name="indexes" href="#indexes">#</a> d3.<b>indexes</b>(<i>iterable</i>, <i>...keys</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/group.js), [Examples](https://observablehq.com/@d3/d3-group)
|
||||
|
||||
Equivalent to [index](#index), but returns nested arrays instead of nested maps.
|
||||
|
||||
<a name="rollup" href="#rollup">#</a> d3.<b>rollup</b>(<i>iterable</i>, <i>reduce</i>, <i>...keys</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/group.js), [Examples](https://observablehq.com/@d3/d3-group-d3-rollup)
|
||||
|
||||
[Groups](#group) and reduces the specified *iterable* of values into an InternMap from *key* to value. For example, given some data:
|
||||
|
||||
```js
|
||||
data = [
|
||||
{name: "jim", amount: "34.0", date: "11/12/2015"},
|
||||
{name: "carl", amount: "120.11", date: "11/12/2015"},
|
||||
{name: "stacy", amount: "12.01", date: "01/04/2016"},
|
||||
{name: "stacy", amount: "34.05", date: "01/04/2016"}
|
||||
]
|
||||
```
|
||||
|
||||
To count the number of elements by name:
|
||||
|
||||
```js
|
||||
d3.rollup(data, v => v.length, d => d.name)
|
||||
```
|
||||
|
||||
This produces:
|
||||
|
||||
```js
|
||||
Map(3) {
|
||||
"jim" => 1
|
||||
"carl" => 1
|
||||
"stacy" => 2
|
||||
}
|
||||
```
|
||||
|
||||
If more than one *key* is specified, a nested Map is returned. For example:
|
||||
|
||||
```js
|
||||
d3.rollup(data, v => v.length, d => d.name, d => d.date)
|
||||
```
|
||||
|
||||
This produces:
|
||||
|
||||
```js
|
||||
Map(3) {
|
||||
"jim" => Map(1) {
|
||||
"11/12/2015" => 1
|
||||
}
|
||||
"carl" => Map(1) {
|
||||
"11/12/2015" => 1
|
||||
}
|
||||
"stacy" => Map(1) {
|
||||
"01/04/2016" => 2
|
||||
}
|
||||
}
|
||||
```
|
||||
|
||||
To convert a Map to an Array, use [Array.from](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from). See [d3.group](#group) for examples.
|
||||
|
||||
<a name="rollups" href="#rollups">#</a> d3.<b>rollups</b>(<i>iterable</i>, <i>...keys</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/group.js), [Examples](https://observablehq.com/@d3/d3-group-d3-rollup)
|
||||
|
||||
Equivalent to [rollup](#rollup), but returns nested arrays instead of nested maps.
|
||||
|
||||
<a name="groupSort" href="#groupSort">#</a> d3.<b>groupSort</b>(<i>iterable</i>, <i>comparator</i>, <i>key</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/groupSort.js), [Examples](https://observablehq.com/@d3/d3-groupsort)
|
||||
<br><a name="groupSort" href="#groupSort">#</a> d3.<b>groupSort</b>(<i>iterable</i>, <i>accessor</i>, <i>key</i>)
|
||||
|
||||
Groups the specified *iterable* of elements according to the specified *key* function, sorts the groups according to the specified *comparator*, and then returns an array of keys in sorted order. For example, if you had a table of barley yields for different varieties, sites, and years, to sort the barley varieties by ascending median yield:
|
||||
|
||||
```js
|
||||
d3.groupSort(barley, g => d3.median(g, d => d.yield), d => d.variety)
|
||||
```
|
||||
|
||||
For descending order, negate the group value:
|
||||
|
||||
```js
|
||||
d3.groupSort(barley, g => -d3.median(g, d => d.yield), d => d.variety)
|
||||
```
|
||||
|
||||
If a *comparator* is passed instead of an *accessor* (i.e., if the second argument is a function that takes two arguments), it will be asked to compare two groups *a* and *b* and should return a negative value if *a* should be before *b*, a positive value if *a* should be after *b*, or zero for a partial ordering.
|
||||
|
||||
<a name="count" href="#count">#</a> d3.<b>count</b>(<i>iterable</i>[, <i>accessor</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/count.js), [Examples](https://observablehq.com/@d3/d3-count)
|
||||
|
||||
Returns the number of valid number values (*i.e.*, not null, NaN, or undefined) in the specified *iterable*; accepts an accessor.
|
||||
|
||||
For example:
|
||||
|
||||
```js
|
||||
d3.count([{n: "Alice", age: NaN}, {n: "Bob", age: 18}, {n: "Other"}], d => d.age) // 1
|
||||
```
|
||||
<a name="cross" href="#cross">#</a> d3.<b>cross</b>(<i>...iterables</i>[, <i>reducer</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/cross.js), [Examples](https://observablehq.com/@d3/d3-cross)
|
||||
|
||||
Returns the [Cartesian product](https://en.wikipedia.org/wiki/Cartesian_product) of the specified *iterables*. For example, if two iterables *a* and *b* are specified, for each element *i* in the iterable *a* and each element *j* in the iterable *b*, in order, invokes the specified *reducer* function passing the element *i* and element *j*. If a *reducer* is not specified, it defaults to a function which creates a two-element array for each pair:
|
||||
|
||||
```js
|
||||
function pair(a, b) {
|
||||
return [a, b];
|
||||
}
|
||||
```
|
||||
|
||||
For example:
|
||||
|
||||
```js
|
||||
d3.cross([1, 2], ["x", "y"]); // returns [[1, "x"], [1, "y"], [2, "x"], [2, "y"]]
|
||||
d3.cross([1, 2], ["x", "y"], (a, b) => a + b); // returns ["1x", "1y", "2x", "2y"]
|
||||
```
|
||||
|
||||
<a name="merge" href="#merge">#</a> d3.<b>merge</b>(<i>iterables</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/merge.js), [Examples](https://observablehq.com/@d3/d3-merge)
|
||||
|
||||
Merges the specified iterable of *iterables* into a single array. This method is similar to the built-in array concat method; the only difference is that it is more convenient when you have an array of arrays.
|
||||
|
||||
```js
|
||||
d3.merge([[1], [2, 3]]); // returns [1, 2, 3]
|
||||
```
|
||||
|
||||
<a name="pairs" href="#pairs">#</a> d3.<b>pairs</b>(<i>iterable</i>[, <i>reducer</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/pairs.js), [Examples](https://observablehq.com/@d3/d3-pairs)
|
||||
|
||||
For each adjacent pair of elements in the specified *iterable*, in order, invokes the specified *reducer* function passing the element *i* and element *i* - 1. If a *reducer* is not specified, it defaults to a function which creates a two-element array for each pair:
|
||||
|
||||
```js
|
||||
function pair(a, b) {
|
||||
return [a, b];
|
||||
}
|
||||
```
|
||||
|
||||
For example:
|
||||
|
||||
```js
|
||||
d3.pairs([1, 2, 3, 4]); // returns [[1, 2], [2, 3], [3, 4]]
|
||||
d3.pairs([1, 2, 3, 4], (a, b) => b - a); // returns [1, 1, 1];
|
||||
```
|
||||
|
||||
If the specified iterable has fewer than two elements, returns the empty array.
|
||||
|
||||
<a name="permute" href="#permute">#</a> d3.<b>permute</b>(<i>source</i>, <i>keys</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/permute.js), [Examples](https://observablehq.com/@d3/d3-permute)
|
||||
|
||||
Returns a permutation of the specified *source* object (or array) using the specified iterable of *keys*. The returned array contains the corresponding property of the source object for each key in *keys*, in order. For example:
|
||||
|
||||
```js
|
||||
permute(["a", "b", "c"], [1, 2, 0]); // returns ["b", "c", "a"]
|
||||
```
|
||||
|
||||
It is acceptable to have more keys than source elements, and for keys to be duplicated or omitted.
|
||||
|
||||
This method can also be used to extract the values from an object into an array with a stable order. Extracting keyed values in order can be useful for generating data arrays in nested selections. For example:
|
||||
|
||||
```js
|
||||
let object = {yield: 27, variety: "Manchuria", year: 1931, site: "University Farm"};
|
||||
let fields = ["site", "variety", "yield"];
|
||||
|
||||
d3.permute(object, fields); // returns ["University Farm", "Manchuria", 27]
|
||||
```
|
||||
|
||||
<a name="shuffle" href="#shuffle">#</a> d3.<b>shuffle</b>(<i>array</i>[, <i>start</i>[, <i>stop</i>]]) · [Source](https://github.com/d3/d3-array/blob/master/src/shuffle.js), [Examples](https://observablehq.com/@d3/d3-shuffle)
|
||||
|
||||
Randomizes the order of the specified *array* in-place using the [Fisher–Yates shuffle](https://bost.ocks.org/mike/shuffle/) and returns the *array*. If *start* is specified, it is the starting index (inclusive) of the *array* to shuffle; if *start* is not specified, it defaults to zero. If *stop* is specified, it is the ending index (exclusive) of the *array* to shuffle; if *stop* is not specified, it defaults to *array*.length. For example, to shuffle the first ten elements of the *array*: shuffle(*array*, 0, 10).
|
||||
|
||||
<a name="shuffler" href="#shuffler">#</a> d3.<b>shuffler</b>(<i>random</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/shuffle.js)
|
||||
|
||||
Returns a [shuffle function](#shuffle) given the specified random source. For example, using [d3.randomLcg](https://github.com/d3/d3-random/blob/master/README.md#randomLcg):
|
||||
|
||||
```js
|
||||
const random = d3.randomLcg(0.9051667019185816);
|
||||
const shuffle = d3.shuffler(random);
|
||||
|
||||
shuffle([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]); // returns [7, 4, 5, 3, 9, 0, 6, 1, 2, 8]
|
||||
```
|
||||
|
||||
<a name="ticks" href="#ticks">#</a> d3.<b>ticks</b>(<i>start</i>, <i>stop</i>, <i>count</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/ticks.js), [Examples](https://observablehq.com/@d3/d3-ticks)
|
||||
|
||||
Returns an array of approximately *count* + 1 uniformly-spaced, nicely-rounded values between *start* and *stop* (inclusive). Each value is a power of ten multiplied by 1, 2 or 5. See also [d3.tickIncrement](#tickIncrement), [d3.tickStep](#tickStep) and [*linear*.ticks](https://github.com/d3/d3-scale/blob/master/README.md#linear_ticks).
|
||||
|
||||
Ticks are inclusive in the sense that they may include the specified *start* and *stop* values if (and only if) they are exact, nicely-rounded values consistent with the inferred [step](#tickStep). More formally, each returned tick *t* satisfies *start* ≤ *t* and *t* ≤ *stop*.
|
||||
|
||||
<a name="tickIncrement" href="#tickIncrement">#</a> d3.<b>tickIncrement</b>(<i>start</i>, <i>stop</i>, <i>count</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/ticks.js), [Examples](https://observablehq.com/@d3/d3-ticks)
|
||||
|
||||
Like [d3.tickStep](#tickStep), except requires that *start* is always less than or equal to *stop*, and if the tick step for the given *start*, *stop* and *count* would be less than one, returns the negative inverse tick step instead. This method is always guaranteed to return an integer, and is used by [d3.ticks](#ticks) to guarantee that the returned tick values are represented as precisely as possible in IEEE 754 floating point.
|
||||
|
||||
<a name="tickStep" href="#tickStep">#</a> d3.<b>tickStep</b>(<i>start</i>, <i>stop</i>, <i>count</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/ticks.js), [Examples](https://observablehq.com/@d3/d3-ticks)
|
||||
|
||||
Returns the difference between adjacent tick values if the same arguments were passed to [d3.ticks](#ticks): a nicely-rounded value that is a power of ten multiplied by 1, 2 or 5. Note that due to the limited precision of IEEE 754 floating point, the returned value may not be exact decimals; use [d3-format](https://github.com/d3/d3-format) to format numbers for human consumption.
|
||||
|
||||
<a name="nice" href="#nice">#</a> d3.<b>nice</b>(<i>start</i>, <i>stop</i>, <i>count</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/nice.js)
|
||||
|
||||
Returns a new interval [*niceStart*, *niceStop*] covering the given interval [*start*, *stop*] and where *niceStart* and *niceStop* are guaranteed to align with the corresponding [tick step](#tickStep). Like [d3.tickIncrement](#tickIncrement), this requires that *start* is less than or equal to *stop*.
|
||||
|
||||
<a name="range" href="#range">#</a> d3.<b>range</b>([<i>start</i>, ]<i>stop</i>[, <i>step</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/range.js), [Examples](https://observablehq.com/@d3/d3-range)
|
||||
|
||||
Returns an array containing an arithmetic progression, similar to the Python built-in [range](http://docs.python.org/library/functions.html#range). This method is often used to iterate over a sequence of uniformly-spaced numeric values, such as the indexes of an array or the ticks of a linear scale. (See also [d3.ticks](#ticks) for nicely-rounded values.)
|
||||
|
||||
If *step* is omitted, it defaults to 1. If *start* is omitted, it defaults to 0. The *stop* value is exclusive; it is not included in the result. If *step* is positive, the last element is the largest *start* + *i* \* *step* less than *stop*; if *step* is negative, the last element is the smallest *start* + *i* \* *step* greater than *stop*. If the returned array would contain an infinite number of values, an empty range is returned.
|
||||
|
||||
The arguments are not required to be integers; however, the results are more predictable if they are. The values in the returned array are defined as *start* + *i* \* *step*, where *i* is an integer from zero to one minus the total number of elements in the returned array. For example:
|
||||
|
||||
```js
|
||||
d3.range(0, 1, 0.2) // [0, 0.2, 0.4, 0.6000000000000001, 0.8]
|
||||
```
|
||||
|
||||
This unexpected behavior is due to IEEE 754 double-precision floating point, which defines 0.2 * 3 = 0.6000000000000001. Use [d3-format](https://github.com/d3/d3-format) to format numbers for human consumption with appropriate rounding; see also [linear.tickFormat](https://github.com/d3/d3-scale/blob/master/README.md#linear_tickFormat) in [d3-scale](https://github.com/d3/d3-scale).
|
||||
|
||||
Likewise, if the returned array should have a specific length, consider using [array.map](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Array/map) on an integer range. For example:
|
||||
|
||||
```js
|
||||
d3.range(0, 1, 1 / 49); // BAD: returns 50 elements!
|
||||
d3.range(49).map(function(d) { return d / 49; }); // GOOD: returns 49 elements.
|
||||
```
|
||||
|
||||
<a name="transpose" href="#transpose">#</a> d3.<b>transpose</b>(<i>matrix</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/transpose.js), [Examples](https://observablehq.com/@d3/d3-transpose)
|
||||
|
||||
Uses the [zip](#zip) operator as a two-dimensional [matrix transpose](http://en.wikipedia.org/wiki/Transpose).
|
||||
|
||||
<a name="zip" href="#zip">#</a> d3.<b>zip</b>(<i>arrays…</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/zip.js), [Examples](https://observablehq.com/@d3/d3-transpose)
|
||||
|
||||
Returns an array of arrays, where the *i*th array contains the *i*th element from each of the argument *arrays*. The returned array is truncated in length to the shortest array in *arrays*. If *arrays* contains only a single array, the returned array contains one-element arrays. With no arguments, the returned array is empty.
|
||||
|
||||
```js
|
||||
d3.zip([1, 2], [3, 4]); // returns [[1, 3], [2, 4]]
|
||||
```
|
||||
|
||||
### Iterables
|
||||
|
||||
These are equivalent to built-in array methods, but work with any iterable including Map, Set, and Generator.
|
||||
|
||||
<a name="every" href="#every">#</a> d3.<b>every</b>(<i>iterable</i>, <i>test</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/every.js)
|
||||
|
||||
Returns true if the given *test* function returns true for every value in the given *iterable*. This method returns as soon as *test* returns a non-truthy value or all values are iterated over. Equivalent to [*array*.every](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every):
|
||||
|
||||
```js
|
||||
d3.every(new Set([1, 3, 5, 7]), x => x & 1) // true
|
||||
```
|
||||
|
||||
<a name="some" href="#some">#</a> d3.<b>some</b>(<i>iterable</i>, <i>test</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/some.js)
|
||||
|
||||
Returns true if the given *test* function returns true for any value in the given *iterable*. This method returns as soon as *test* returns a truthy value or all values are iterated over. Equivalent to [*array*.some](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some):
|
||||
|
||||
```js
|
||||
d3.some(new Set([0, 2, 3, 4]), x => x & 1) // true
|
||||
```
|
||||
|
||||
<a name="filter" href="#filter">#</a> d3.<b>filter</b>(<i>iterable</i>, <i>test</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/filter.js)
|
||||
|
||||
Returns a new array containing the values from *iterable*, in order, for which the given *test* function returns true. Equivalent to [*array*.filter](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter):
|
||||
|
||||
```js
|
||||
d3.filter(new Set([0, 2, 3, 4]), x => x & 1) // [3]
|
||||
```
|
||||
|
||||
<a name="map" href="#map">#</a> d3.<b>map</b>(<i>iterable</i>, <i>mapper</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/map.js)
|
||||
|
||||
Returns a new array containing the mapped values from *iterable*, in order, as defined by given *mapper* function. Equivalent to [*array*.map](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map) and [Array.from](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from):
|
||||
|
||||
```js
|
||||
d3.map(new Set([0, 2, 3, 4]), x => x & 1) // [0, 0, 1, 0]
|
||||
```
|
||||
|
||||
<a name="reduce" href="#reduce">#</a> d3.<b>reduce</b>(<i>iterable</i>, <i>reducer</i>[, <i>initialValue</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/reduce.js)
|
||||
|
||||
Returns the reduced value defined by given *reducer* function, which is repeatedly invoked for each value in *iterable*, being passed the current reduced value and the next value. Equivalent to [*array*.reduce](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reduce):
|
||||
|
||||
```js
|
||||
d3.reduce(new Set([0, 2, 3, 4]), (p, v) => p + v, 0) // 9
|
||||
```
|
||||
|
||||
<a name="reverse" href="#reverse">#</a> d3.<b>reverse</b>(<i>iterable</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/reverse.js)
|
||||
|
||||
Returns an array containing the values in the given *iterable* in reverse order. Equivalent to [*array*.reverse](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse), except that it does not mutate the given *iterable*:
|
||||
|
||||
```js
|
||||
d3.reverse(new Set([0, 2, 3, 1])) // [1, 3, 2, 0]
|
||||
```
|
||||
|
||||
<a name="sort" href="#sort">#</a> d3.<b>sort</b>(<i>iterable</i>, <i>comparator</i> = d3.ascending) · [Source](https://github.com/d3/d3-array/blob/master/src/sort.js)
|
||||
<br><a name="sort" href="#sort">#</a> d3.<b>sort</b>(<i>iterable</i>, ...<i>accessors</i>)
|
||||
|
||||
Returns an array containing the values in the given *iterable* in the sorted order defined by the given *comparator* or *accessor* function. If *comparator* is not specified, it defaults to [d3.ascending](#ascending). Equivalent to [*array*.sort](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort), except that it does not mutate the given *iterable*, and the comparator defaults to natural order instead of lexicographic order:
|
||||
|
||||
```js
|
||||
d3.sort(new Set([0, 2, 3, 1])) // [0, 1, 2, 3]
|
||||
```
|
||||
|
||||
If an *accessor* (a function that takes a single argument) is specified,
|
||||
|
||||
```js
|
||||
d3.sort(data, d => d.value)
|
||||
```
|
||||
|
||||
it is equivalent to a *comparator* using [natural order](#ascending):
|
||||
|
||||
```js
|
||||
d3.sort(data, (a, b) => d3.ascending(a.value, b.value))
|
||||
```
|
||||
|
||||
The *accessor* is only invoked once per element, and thus the returned sorted order is consistent even if the accessor is nondeterministic.
|
||||
|
||||
Multiple accessors may be specified to break ties:
|
||||
|
||||
```js
|
||||
d3.sort(points, ({x}) => x, ({y}) => y)
|
||||
```
|
||||
|
||||
This is equivalent to:
|
||||
|
||||
```js
|
||||
d3.sort(data, (a, b) => d3.ascending(a.x, b.x) || d3.ascending(a.y, b.y))
|
||||
```
|
||||
|
||||
### Sets
|
||||
|
||||
This methods implement basic set operations for any iterable.
|
||||
|
||||
<a name="difference" href="#difference">#</a> d3.<b>difference</b>(<i>iterable</i>, ...<i>others</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/difference.js)
|
||||
|
||||
Returns a new Set containing every value in *iterable* that is not in any of the *others* iterables.
|
||||
|
||||
```js
|
||||
d3.difference([0, 1, 2, 0], [1]) // Set {0, 2}
|
||||
```
|
||||
|
||||
<a name="union" href="#union">#</a> d3.<b>union</b>(...<i>iterables</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/union.js)
|
||||
|
||||
Returns a new Set containing every (distinct) value that appears in any of the given *iterables*. The order of values in the returned Set is based on their first occurrence in the given *iterables*.
|
||||
|
||||
```js
|
||||
d3.union([0, 2, 1, 0], [1, 3]) // Set {0, 2, 1, 3}
|
||||
```
|
||||
|
||||
<a name="intersection" href="#intersection">#</a> d3.<b>intersection</b>(...<i>iterables</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/intersection.js)
|
||||
|
||||
Returns a new Set containing every (distinct) value that appears in all of the given *iterables*. The order of values in the returned Set is based on their first occurrence in the given *iterables*.
|
||||
|
||||
```js
|
||||
d3.intersection([0, 2, 1, 0], [1, 3]) // Set {1}
|
||||
```
|
||||
|
||||
<a name="superset" href="#superset">#</a> d3.<b>superset</b>(<i>a</i>, <i>b</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/superset.js)
|
||||
|
||||
Returns true if *a* is a superset of *b*: if every value in the given iterable *b* is also in the given iterable *a*.
|
||||
|
||||
```js
|
||||
d3.superset([0, 2, 1, 3, 0], [1, 3]) // true
|
||||
```
|
||||
|
||||
<a name="subset" href="#subset">#</a> d3.<b>subset</b>(<i>a</i>, <i>b</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/subset.js)
|
||||
|
||||
Returns true if *a* is a subset of *b*: if every value in the given iterable *a* is also in the given iterable *b*.
|
||||
|
||||
```js
|
||||
d3.subset([1, 3], [0, 2, 1, 3, 0]) // true
|
||||
```
|
||||
|
||||
<a name="disjoint" href="#disjoint">#</a> d3.<b>disjoint</b>(<i>a</i>, <i>b</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/disjoint.js)
|
||||
|
||||
Returns true if *a* and *b* are disjoint: if *a* and *b* contain no shared value.
|
||||
|
||||
```js
|
||||
d3.disjoint([1, 3], [2, 4]) // true
|
||||
```
|
||||
|
||||
### Bins
|
||||
|
||||
[<img src="https://raw.githubusercontent.com/d3/d3-array/master/img/histogram.png" width="480" height="250" alt="Histogram">](http://bl.ocks.org/mbostock/3048450)
|
||||
|
||||
Binning groups discrete samples into a smaller number of consecutive, non-overlapping intervals. They are often used to visualize the distribution of numerical data as histograms.
|
||||
|
||||
<a name="bin" href="#bin">#</a> d3.<b>bin</b>() · [Source](https://github.com/d3/d3-array/blob/master/src/bin.js), [Examples](https://observablehq.com/@d3/d3-bin)
|
||||
|
||||
Constructs a new bin generator with the default settings.
|
||||
|
||||
<a name="_bin" href="#_bin">#</a> <i>bin</i>(<i>data</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/bin.js), [Examples](https://observablehq.com/@d3/d3-bin)
|
||||
|
||||
Bins the given iterable of *data* samples. Returns an array of bins, where each bin is an array containing the associated elements from the input *data*. Thus, the `length` of the bin is the number of elements in that bin. Each bin has two additional attributes:
|
||||
|
||||
* `x0` - the lower bound of the bin (inclusive).
|
||||
* `x1` - the upper bound of the bin (exclusive, except for the last bin).
|
||||
|
||||
<a name="bin_value" href="#bin_value">#</a> <i>bin</i>.<b>value</b>([<i>value</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/bin.js), [Examples](https://observablehq.com/@d3/d3-bin)
|
||||
|
||||
If *value* is specified, sets the value accessor to the specified function or constant and returns this bin generator. If *value* is not specified, returns the current value accessor, which defaults to the identity function.
|
||||
|
||||
When bins are [generated](#_bin), the value accessor will be invoked for each element in the input data array, being passed the element `d`, the index `i`, and the array `data` as three arguments. The default value accessor assumes that the input data are orderable (comparable), such as numbers or dates. If your data are not, then you should specify an accessor that returns the corresponding orderable value for a given datum.
|
||||
|
||||
This is similar to mapping your data to values before invoking the bin generator, but has the benefit that the input data remains associated with the returned bins, thereby making it easier to access other fields of the data.
|
||||
|
||||
<a name="bin_domain" href="#bin_domain">#</a> <i>bin</i>.<b>domain</b>([<i>domain</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/bin.js), [Examples](https://observablehq.com/@d3/d3-bin)
|
||||
|
||||
If *domain* is specified, sets the domain accessor to the specified function or array and returns this bin generator. If *domain* is not specified, returns the current domain accessor, which defaults to [extent](#extent). The bin domain is defined as an array [*min*, *max*], where *min* is the minimum observable value and *max* is the maximum observable value; both values are inclusive. Any value outside of this domain will be ignored when the bins are [generated](#_bin).
|
||||
|
||||
For example, if you are using the bin generator in conjunction with a [linear scale](https://github.com/d3/d3-scale/blob/master/README.md#linear-scales) `x`, you might say:
|
||||
|
||||
```js
|
||||
var bin = d3.bin()
|
||||
.domain(x.domain())
|
||||
.thresholds(x.ticks(20));
|
||||
```
|
||||
|
||||
You can then compute the bins from an array of numbers like so:
|
||||
|
||||
```js
|
||||
var bins = bin(numbers);
|
||||
```
|
||||
|
||||
If the default [extent](#extent) domain is used and the [thresholds](#bin_thresholds) are specified as a count (rather than explicit values), then the computed domain will be [niced](#nice) such that all bins are uniform width.
|
||||
|
||||
Note that the domain accessor is invoked on the materialized array of [values](#bin_value), not on the input data array.
|
||||
|
||||
<a name="bin_thresholds" href="#bin_thresholds">#</a> <i>bin</i>.<b>thresholds</b>([<i>count</i>]) · [Source](https://github.com/d3/d3-array/blob/master/src/bin.js), [Examples](https://observablehq.com/@d3/d3-bin)
|
||||
<br><a name="bin_thresholds" href="#bin_thresholds">#</a> <i>bin</i>.<b>thresholds</b>([<i>thresholds</i>])
|
||||
|
||||
If *thresholds* is specified, sets the [threshold generator](#bin-thresholds) to the specified function or array and returns this bin generator. If *thresholds* is not specified, returns the current threshold generator, which by default implements [Sturges’ formula](#thresholdSturges). (Thus by default, the values to be binned must be numbers!) Thresholds are defined as an array of values [*x0*, *x1*, …]. Any value less than *x0* will be placed in the first bin; any value greater than or equal to *x0* but less than *x1* will be placed in the second bin; and so on. Thus, the [generated bins](#_bin) will have *thresholds*.length + 1 bins. See [bin thresholds](#bin-thresholds) for more information.
|
||||
|
||||
Any threshold values outside the [domain](#bin_domain) are ignored. The first *bin*.x0 is always equal to the minimum domain value, and the last *bin*.x1 is always equal to the maximum domain value.
|
||||
|
||||
If a *count* is specified instead of an array of *thresholds*, then the [domain](#bin_domain) will be uniformly divided into approximately *count* bins; see [ticks](#ticks).
|
||||
|
||||
#### Bin Thresholds
|
||||
|
||||
These functions are typically not used directly; instead, pass them to [*bin*.thresholds](#bin_thresholds).
|
||||
|
||||
<a name="thresholdFreedmanDiaconis" href="#thresholdFreedmanDiaconis">#</a> d3.<b>thresholdFreedmanDiaconis</b>(<i>values</i>, <i>min</i>, <i>max</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/threshold/freedmanDiaconis.js), [Examples](https://observablehq.com/@d3/d3-bin)
|
||||
|
||||
Returns the number of bins according to the [Freedman–Diaconis rule](https://en.wikipedia.org/wiki/Histogram#Mathematical_definition); the input *values* must be numbers.
|
||||
|
||||
<a name="thresholdScott" href="#thresholdScott">#</a> d3.<b>thresholdScott</b>(<i>values</i>, <i>min</i>, <i>max</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/threshold/scott.js), [Examples](https://observablehq.com/@d3/d3-bin)
|
||||
|
||||
Returns the number of bins according to [Scott’s normal reference rule](https://en.wikipedia.org/wiki/Histogram#Mathematical_definition); the input *values* must be numbers.
|
||||
|
||||
<a name="thresholdSturges" href="#thresholdSturges">#</a> d3.<b>thresholdSturges</b>(<i>values</i>) · [Source](https://github.com/d3/d3-array/blob/master/src/threshold/sturges.js), [Examples](https://observablehq.com/@d3/d3-bin)
|
||||
|
||||
Returns the number of bins according to [Sturges’ formula](https://en.wikipedia.org/wiki/Histogram#Mathematical_definition); the input *values* must be numbers.
|
||||
|
||||
You may also implement your own threshold generator taking three arguments: the array of input [*values*](#bin_value) derived from the data, and the [observable domain](#bin_domain) represented as *min* and *max*. The generator may then return either the array of numeric thresholds or the *count* of bins; in the latter case the domain is divided uniformly into approximately *count* bins; see [ticks](#ticks).
|
||||
|
||||
For instance, when binning date values, you might want to use the ticks from a time scale ([Example](https://observablehq.com/@d3/d3-bin-time-thresholds)).
|
||||
|
||||
### Interning
|
||||
|
||||
<a name="InternMap" href="#InternMap">#</a> new d3.<b>InternMap</b>([<i>iterable</i>][, <i>key</i>]) · [Source](https://github.com/mbostock/internmap/blob/main/src/index.js), [Examples](https://observablehq.com/d/d4c5f6ad343866b9)
|
||||
<br><a name="InternSet" href="#InternSet">#</a> new d3.<b>InternSet</b>([<i>iterable</i>][, <i>key</i>]) · [Source](https://github.com/mbostock/internmap/blob/main/src/index.js), [Examples](https://observablehq.com/d/d4c5f6ad343866b9)
|
||||
|
||||
The [InternMap and InternSet](https://github.com/mbostock/internmap) classes extend the native JavaScript Map and Set classes, respectively, allowing Dates and other non-primitive keys by bypassing the [SameValueZero algorithm](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness) when determining key equality. d3.group, d3.rollup and d3.index use an InternMap rather than a native Map. These two classes are exported for convenience.
|
||||
+1182
File diff suppressed because it is too large
Load Diff
+2
File diff suppressed because one or more lines are too long
+53
@@ -0,0 +1,53 @@
|
||||
{
|
||||
"name": "d3-array",
|
||||
"version": "2.12.1",
|
||||
"description": "Array manipulation, ordering, searching, summarizing, etc.",
|
||||
"keywords": [
|
||||
"d3",
|
||||
"d3-module",
|
||||
"histogram",
|
||||
"bisect",
|
||||
"shuffle",
|
||||
"statistics",
|
||||
"search",
|
||||
"sort",
|
||||
"array"
|
||||
],
|
||||
"homepage": "https://d3js.org/d3-array/",
|
||||
"license": "BSD-3-Clause",
|
||||
"author": {
|
||||
"name": "Mike Bostock",
|
||||
"url": "http://bost.ocks.org/mike"
|
||||
},
|
||||
"main": "dist/d3-array.js",
|
||||
"unpkg": "dist/d3-array.min.js",
|
||||
"module": "src/index.js",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/d3/d3-array.git"
|
||||
},
|
||||
"files": [
|
||||
"dist/**/*.js",
|
||||
"src/**/*.js"
|
||||
],
|
||||
"scripts": {
|
||||
"pretest": "rollup -c",
|
||||
"test": "./test/run.sh",
|
||||
"prepublishOnly": "rm -rf dist && yarn test",
|
||||
"postpublish": "git push && git push --tags && cd ../d3.github.com && git pull && cp ../${npm_package_name}/dist/${npm_package_name}.js ${npm_package_name}.v${npm_package_version%%.*}.js && cp ../${npm_package_name}/dist/${npm_package_name}.min.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git add ${npm_package_name}.v${npm_package_version%%.*}.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git commit -m \"${npm_package_name} ${npm_package_version}\" && git push && cd - && zip -j dist/${npm_package_name}.zip -- LICENSE README.md dist/${npm_package_name}.js dist/${npm_package_name}.min.js"
|
||||
},
|
||||
"sideEffects": false,
|
||||
"devDependencies": {
|
||||
"@rollup/plugin-node-resolve": "11",
|
||||
"d3-random": "2",
|
||||
"eslint": "7",
|
||||
"jsdom": "16",
|
||||
"rollup": "2",
|
||||
"rollup-plugin-terser": "7",
|
||||
"tape": "4",
|
||||
"tape-await": "0.1"
|
||||
},
|
||||
"dependencies": {
|
||||
"internmap": "^1.0.0"
|
||||
}
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
var array = Array.prototype;
|
||||
|
||||
export var slice = array.slice;
|
||||
export var map = array.map;
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
export default function(a, b) {
|
||||
return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
|
||||
}
|
||||
+101
@@ -0,0 +1,101 @@
|
||||
import {slice} from "./array.js";
|
||||
import bisect from "./bisect.js";
|
||||
import constant from "./constant.js";
|
||||
import extent from "./extent.js";
|
||||
import identity from "./identity.js";
|
||||
import nice from "./nice.js";
|
||||
import ticks, {tickIncrement} from "./ticks.js";
|
||||
import sturges from "./threshold/sturges.js";
|
||||
|
||||
export default function() {
|
||||
var value = identity,
|
||||
domain = extent,
|
||||
threshold = sturges;
|
||||
|
||||
function histogram(data) {
|
||||
if (!Array.isArray(data)) data = Array.from(data);
|
||||
|
||||
var i,
|
||||
n = data.length,
|
||||
x,
|
||||
values = new Array(n);
|
||||
|
||||
for (i = 0; i < n; ++i) {
|
||||
values[i] = value(data[i], i, data);
|
||||
}
|
||||
|
||||
var xz = domain(values),
|
||||
x0 = xz[0],
|
||||
x1 = xz[1],
|
||||
tz = threshold(values, x0, x1);
|
||||
|
||||
// Convert number of thresholds into uniform thresholds, and nice the
|
||||
// default domain accordingly.
|
||||
if (!Array.isArray(tz)) {
|
||||
const max = x1, tn = +tz;
|
||||
if (domain === extent) [x0, x1] = nice(x0, x1, tn);
|
||||
tz = ticks(x0, x1, tn);
|
||||
|
||||
// If the last threshold is coincident with the domain’s upper bound, the
|
||||
// last bin will be zero-width. If the default domain is used, and this
|
||||
// last threshold is coincident with the maximum input value, we can
|
||||
// extend the niced upper bound by one tick to ensure uniform bin widths;
|
||||
// otherwise, we simply remove the last threshold. Note that we don’t
|
||||
// coerce values or the domain to numbers, and thus must be careful to
|
||||
// compare order (>=) rather than strict equality (===)!
|
||||
if (tz[tz.length - 1] >= x1) {
|
||||
if (max >= x1 && domain === extent) {
|
||||
const step = tickIncrement(x0, x1, tn);
|
||||
if (isFinite(step)) {
|
||||
if (step > 0) {
|
||||
x1 = (Math.floor(x1 / step) + 1) * step;
|
||||
} else if (step < 0) {
|
||||
x1 = (Math.ceil(x1 * -step) + 1) / -step;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
tz.pop();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Remove any thresholds outside the domain.
|
||||
var m = tz.length;
|
||||
while (tz[0] <= x0) tz.shift(), --m;
|
||||
while (tz[m - 1] > x1) tz.pop(), --m;
|
||||
|
||||
var bins = new Array(m + 1),
|
||||
bin;
|
||||
|
||||
// Initialize bins.
|
||||
for (i = 0; i <= m; ++i) {
|
||||
bin = bins[i] = [];
|
||||
bin.x0 = i > 0 ? tz[i - 1] : x0;
|
||||
bin.x1 = i < m ? tz[i] : x1;
|
||||
}
|
||||
|
||||
// Assign data to bins by value, ignoring any outside the domain.
|
||||
for (i = 0; i < n; ++i) {
|
||||
x = values[i];
|
||||
if (x0 <= x && x <= x1) {
|
||||
bins[bisect(tz, x, 0, m)].push(data[i]);
|
||||
}
|
||||
}
|
||||
|
||||
return bins;
|
||||
}
|
||||
|
||||
histogram.value = function(_) {
|
||||
return arguments.length ? (value = typeof _ === "function" ? _ : constant(_), histogram) : value;
|
||||
};
|
||||
|
||||
histogram.domain = function(_) {
|
||||
return arguments.length ? (domain = typeof _ === "function" ? _ : constant([_[0], _[1]]), histogram) : domain;
|
||||
};
|
||||
|
||||
histogram.thresholds = function(_) {
|
||||
return arguments.length ? (threshold = typeof _ === "function" ? _ : Array.isArray(_) ? constant(slice.call(_)) : constant(_), histogram) : threshold;
|
||||
};
|
||||
|
||||
return histogram;
|
||||
}
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
import ascending from "./ascending.js";
|
||||
import bisector from "./bisector.js";
|
||||
import number from "./number.js";
|
||||
|
||||
const ascendingBisect = bisector(ascending);
|
||||
export const bisectRight = ascendingBisect.right;
|
||||
export const bisectLeft = ascendingBisect.left;
|
||||
export const bisectCenter = bisector(number).center;
|
||||
export default bisectRight;
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
import ascending from "./ascending.js";
|
||||
|
||||
export default function(f) {
|
||||
let delta = f;
|
||||
let compare = f;
|
||||
|
||||
if (f.length === 1) {
|
||||
delta = (d, x) => f(d) - x;
|
||||
compare = ascendingComparator(f);
|
||||
}
|
||||
|
||||
function left(a, x, lo, hi) {
|
||||
if (lo == null) lo = 0;
|
||||
if (hi == null) hi = a.length;
|
||||
while (lo < hi) {
|
||||
const mid = (lo + hi) >>> 1;
|
||||
if (compare(a[mid], x) < 0) lo = mid + 1;
|
||||
else hi = mid;
|
||||
}
|
||||
return lo;
|
||||
}
|
||||
|
||||
function right(a, x, lo, hi) {
|
||||
if (lo == null) lo = 0;
|
||||
if (hi == null) hi = a.length;
|
||||
while (lo < hi) {
|
||||
const mid = (lo + hi) >>> 1;
|
||||
if (compare(a[mid], x) > 0) hi = mid;
|
||||
else lo = mid + 1;
|
||||
}
|
||||
return lo;
|
||||
}
|
||||
|
||||
function center(a, x, lo, hi) {
|
||||
if (lo == null) lo = 0;
|
||||
if (hi == null) hi = a.length;
|
||||
const i = left(a, x, lo, hi - 1);
|
||||
return i > lo && delta(a[i - 1], x) > -delta(a[i], x) ? i - 1 : i;
|
||||
}
|
||||
|
||||
return {left, center, right};
|
||||
}
|
||||
|
||||
function ascendingComparator(f) {
|
||||
return (d, x) => ascending(f(d), x);
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
export default function(x) {
|
||||
return function() {
|
||||
return x;
|
||||
};
|
||||
}
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
export default function count(values, valueof) {
|
||||
let count = 0;
|
||||
if (valueof === undefined) {
|
||||
for (let value of values) {
|
||||
if (value != null && (value = +value) >= value) {
|
||||
++count;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let index = -1;
|
||||
for (let value of values) {
|
||||
if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
|
||||
++count;
|
||||
}
|
||||
}
|
||||
}
|
||||
return count;
|
||||
}
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
function length(array) {
|
||||
return array.length | 0;
|
||||
}
|
||||
|
||||
function empty(length) {
|
||||
return !(length > 0);
|
||||
}
|
||||
|
||||
function arrayify(values) {
|
||||
return typeof values !== "object" || "length" in values ? values : Array.from(values);
|
||||
}
|
||||
|
||||
function reducer(reduce) {
|
||||
return values => reduce(...values);
|
||||
}
|
||||
|
||||
export default function cross(...values) {
|
||||
const reduce = typeof values[values.length - 1] === "function" && reducer(values.pop());
|
||||
values = values.map(arrayify);
|
||||
const lengths = values.map(length);
|
||||
const j = values.length - 1;
|
||||
const index = new Array(j + 1).fill(0);
|
||||
const product = [];
|
||||
if (j < 0 || lengths.some(empty)) return product;
|
||||
while (true) {
|
||||
product.push(index.map((j, i) => values[i][j]));
|
||||
let i = j;
|
||||
while (++index[i] === lengths[i]) {
|
||||
if (i === 0) return reduce ? product.map(reduce) : product;
|
||||
index[i--] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
export default function cumsum(values, valueof) {
|
||||
var sum = 0, index = 0;
|
||||
return Float64Array.from(values, valueof === undefined
|
||||
? v => (sum += +v || 0)
|
||||
: v => (sum += +valueof(v, index++, values) || 0));
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
export default function(a, b) {
|
||||
return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
import variance from "./variance.js";
|
||||
|
||||
export default function deviation(values, valueof) {
|
||||
const v = variance(values, valueof);
|
||||
return v ? Math.sqrt(v) : v;
|
||||
}
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
export default function difference(values, ...others) {
|
||||
values = new Set(values);
|
||||
for (const other of others) {
|
||||
for (const value of other) {
|
||||
values.delete(value);
|
||||
}
|
||||
}
|
||||
return values;
|
||||
}
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
export default function disjoint(values, other) {
|
||||
const iterator = other[Symbol.iterator](), set = new Set();
|
||||
for (const v of values) {
|
||||
if (set.has(v)) return false;
|
||||
let value, done;
|
||||
while (({value, done} = iterator.next())) {
|
||||
if (done) break;
|
||||
if (Object.is(v, value)) return false;
|
||||
set.add(value);
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
export default function every(values, test) {
|
||||
if (typeof test !== "function") throw new TypeError("test is not a function");
|
||||
let index = -1;
|
||||
for (const value of values) {
|
||||
if (!test(value, ++index, values)) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
export default function(values, valueof) {
|
||||
let min;
|
||||
let max;
|
||||
if (valueof === undefined) {
|
||||
for (const value of values) {
|
||||
if (value != null) {
|
||||
if (min === undefined) {
|
||||
if (value >= value) min = max = value;
|
||||
} else {
|
||||
if (min > value) min = value;
|
||||
if (max < value) max = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let index = -1;
|
||||
for (let value of values) {
|
||||
if ((value = valueof(value, ++index, values)) != null) {
|
||||
if (min === undefined) {
|
||||
if (value >= value) min = max = value;
|
||||
} else {
|
||||
if (min > value) min = value;
|
||||
if (max < value) max = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return [min, max];
|
||||
}
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
export default function filter(values, test) {
|
||||
if (typeof test !== "function") throw new TypeError("test is not a function");
|
||||
const array = [];
|
||||
let index = -1;
|
||||
for (const value of values) {
|
||||
if (test(value, ++index, values)) {
|
||||
array.push(value);
|
||||
}
|
||||
}
|
||||
return array;
|
||||
}
|
||||
+69
@@ -0,0 +1,69 @@
|
||||
// https://github.com/python/cpython/blob/a74eea238f5baba15797e2e8b570d153bc8690a7/Modules/mathmodule.c#L1423
|
||||
export class Adder {
|
||||
constructor() {
|
||||
this._partials = new Float64Array(32);
|
||||
this._n = 0;
|
||||
}
|
||||
add(x) {
|
||||
const p = this._partials;
|
||||
let i = 0;
|
||||
for (let j = 0; j < this._n && j < 32; j++) {
|
||||
const y = p[j],
|
||||
hi = x + y,
|
||||
lo = Math.abs(x) < Math.abs(y) ? x - (hi - y) : y - (hi - x);
|
||||
if (lo) p[i++] = lo;
|
||||
x = hi;
|
||||
}
|
||||
p[i] = x;
|
||||
this._n = i + 1;
|
||||
return this;
|
||||
}
|
||||
valueOf() {
|
||||
const p = this._partials;
|
||||
let n = this._n, x, y, lo, hi = 0;
|
||||
if (n > 0) {
|
||||
hi = p[--n];
|
||||
while (n > 0) {
|
||||
x = hi;
|
||||
y = p[--n];
|
||||
hi = x + y;
|
||||
lo = y - (hi - x);
|
||||
if (lo) break;
|
||||
}
|
||||
if (n > 0 && ((lo < 0 && p[n - 1] < 0) || (lo > 0 && p[n - 1] > 0))) {
|
||||
y = lo * 2;
|
||||
x = hi + y;
|
||||
if (y == x - hi) hi = x;
|
||||
}
|
||||
}
|
||||
return hi;
|
||||
}
|
||||
}
|
||||
|
||||
export function fsum(values, valueof) {
|
||||
const adder = new Adder();
|
||||
if (valueof === undefined) {
|
||||
for (let value of values) {
|
||||
if (value = +value) {
|
||||
adder.add(value);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let index = -1;
|
||||
for (let value of values) {
|
||||
if (value = +valueof(value, ++index, values)) {
|
||||
adder.add(value);
|
||||
}
|
||||
}
|
||||
}
|
||||
return +adder;
|
||||
}
|
||||
|
||||
export function fcumsum(values, valueof) {
|
||||
const adder = new Adder();
|
||||
let index = -1;
|
||||
return Float64Array.from(values, valueof === undefined
|
||||
? v => adder.add(+v || 0)
|
||||
: v => adder.add(+valueof(v, ++index, values) || 0)
|
||||
);
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
import ascending from "./ascending.js";
|
||||
|
||||
export default function greatest(values, compare = ascending) {
|
||||
let max;
|
||||
let defined = false;
|
||||
if (compare.length === 1) {
|
||||
let maxValue;
|
||||
for (const element of values) {
|
||||
const value = compare(element);
|
||||
if (defined
|
||||
? ascending(value, maxValue) > 0
|
||||
: ascending(value, value) === 0) {
|
||||
max = element;
|
||||
maxValue = value;
|
||||
defined = true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (const value of values) {
|
||||
if (defined
|
||||
? compare(value, max) > 0
|
||||
: compare(value, value) === 0) {
|
||||
max = value;
|
||||
defined = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return max;
|
||||
}
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
import ascending from "./ascending.js";
|
||||
import maxIndex from "./maxIndex.js";
|
||||
|
||||
export default function greatestIndex(values, compare = ascending) {
|
||||
if (compare.length === 1) return maxIndex(values, compare);
|
||||
let maxValue;
|
||||
let max = -1;
|
||||
let index = -1;
|
||||
for (const value of values) {
|
||||
++index;
|
||||
if (max < 0
|
||||
? compare(value, value) === 0
|
||||
: compare(value, maxValue) > 0) {
|
||||
maxValue = value;
|
||||
max = index;
|
||||
}
|
||||
}
|
||||
return max;
|
||||
}
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
import {InternMap} from "internmap";
|
||||
import identity from "./identity.js";
|
||||
|
||||
export default function group(values, ...keys) {
|
||||
return nest(values, identity, identity, keys);
|
||||
}
|
||||
|
||||
export function groups(values, ...keys) {
|
||||
return nest(values, Array.from, identity, keys);
|
||||
}
|
||||
|
||||
export function rollup(values, reduce, ...keys) {
|
||||
return nest(values, identity, reduce, keys);
|
||||
}
|
||||
|
||||
export function rollups(values, reduce, ...keys) {
|
||||
return nest(values, Array.from, reduce, keys);
|
||||
}
|
||||
|
||||
export function index(values, ...keys) {
|
||||
return nest(values, identity, unique, keys);
|
||||
}
|
||||
|
||||
export function indexes(values, ...keys) {
|
||||
return nest(values, Array.from, unique, keys);
|
||||
}
|
||||
|
||||
function unique(values) {
|
||||
if (values.length !== 1) throw new Error("duplicate key");
|
||||
return values[0];
|
||||
}
|
||||
|
||||
function nest(values, map, reduce, keys) {
|
||||
return (function regroup(values, i) {
|
||||
if (i >= keys.length) return reduce(values);
|
||||
const groups = new InternMap();
|
||||
const keyof = keys[i++];
|
||||
let index = -1;
|
||||
for (const value of values) {
|
||||
const key = keyof(value, ++index, values);
|
||||
const group = groups.get(key);
|
||||
if (group) group.push(value);
|
||||
else groups.set(key, [value]);
|
||||
}
|
||||
for (const [key, values] of groups) {
|
||||
groups.set(key, regroup(values, i));
|
||||
}
|
||||
return map(groups);
|
||||
})(values, 0);
|
||||
}
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
import ascending from "./ascending.js";
|
||||
import group, {rollup} from "./group.js";
|
||||
import sort from "./sort.js";
|
||||
|
||||
export default function groupSort(values, reduce, key) {
|
||||
return (reduce.length === 1
|
||||
? sort(rollup(values, reduce, key), (([ak, av], [bk, bv]) => ascending(av, bv) || ascending(ak, bk)))
|
||||
: sort(group(values, key), (([ak, av], [bk, bv]) => reduce(av, bv) || ascending(ak, bk))))
|
||||
.map(([key]) => key);
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
export default function(x) {
|
||||
return x;
|
||||
}
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
export {default as bisect, bisectRight, bisectLeft, bisectCenter} from "./bisect.js";
|
||||
export {default as ascending} from "./ascending.js";
|
||||
export {default as bisector} from "./bisector.js";
|
||||
export {default as count} from "./count.js";
|
||||
export {default as cross} from "./cross.js";
|
||||
export {default as cumsum} from "./cumsum.js";
|
||||
export {default as descending} from "./descending.js";
|
||||
export {default as deviation} from "./deviation.js";
|
||||
export {default as extent} from "./extent.js";
|
||||
export {Adder, fsum, fcumsum} from "./fsum.js";
|
||||
export {default as group, groups, index, indexes, rollup, rollups} from "./group.js";
|
||||
export {default as groupSort} from "./groupSort.js";
|
||||
export {default as bin, default as histogram} from "./bin.js"; // Deprecated; use bin.
|
||||
export {default as thresholdFreedmanDiaconis} from "./threshold/freedmanDiaconis.js";
|
||||
export {default as thresholdScott} from "./threshold/scott.js";
|
||||
export {default as thresholdSturges} from "./threshold/sturges.js";
|
||||
export {default as max} from "./max.js";
|
||||
export {default as maxIndex} from "./maxIndex.js";
|
||||
export {default as mean} from "./mean.js";
|
||||
export {default as median} from "./median.js";
|
||||
export {default as merge} from "./merge.js";
|
||||
export {default as min} from "./min.js";
|
||||
export {default as minIndex} from "./minIndex.js";
|
||||
export {default as nice} from "./nice.js";
|
||||
export {default as pairs} from "./pairs.js";
|
||||
export {default as permute} from "./permute.js";
|
||||
export {default as quantile, quantileSorted} from "./quantile.js";
|
||||
export {default as quickselect} from "./quickselect.js";
|
||||
export {default as range} from "./range.js";
|
||||
export {default as least} from "./least.js";
|
||||
export {default as leastIndex} from "./leastIndex.js";
|
||||
export {default as greatest} from "./greatest.js";
|
||||
export {default as greatestIndex} from "./greatestIndex.js";
|
||||
export {default as scan} from "./scan.js"; // Deprecated; use leastIndex.
|
||||
export {default as shuffle, shuffler} from "./shuffle.js";
|
||||
export {default as sum} from "./sum.js";
|
||||
export {default as ticks, tickIncrement, tickStep} from "./ticks.js";
|
||||
export {default as transpose} from "./transpose.js";
|
||||
export {default as variance} from "./variance.js";
|
||||
export {default as zip} from "./zip.js";
|
||||
export {default as every} from "./every.js";
|
||||
export {default as some} from "./some.js";
|
||||
export {default as filter} from "./filter.js";
|
||||
export {default as map} from "./map.js";
|
||||
export {default as reduce} from "./reduce.js";
|
||||
export {default as reverse} from "./reverse.js";
|
||||
export {default as sort} from "./sort.js";
|
||||
export {default as difference} from "./difference.js";
|
||||
export {default as disjoint} from "./disjoint.js";
|
||||
export {default as intersection} from "./intersection.js";
|
||||
export {default as subset} from "./subset.js";
|
||||
export {default as superset} from "./superset.js";
|
||||
export {default as union} from "./union.js";
|
||||
export {InternMap, InternSet} from "internmap";
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
import set from "./set.js";
|
||||
|
||||
export default function intersection(values, ...others) {
|
||||
values = new Set(values);
|
||||
others = others.map(set);
|
||||
out: for (const value of values) {
|
||||
for (const other of others) {
|
||||
if (!other.has(value)) {
|
||||
values.delete(value);
|
||||
continue out;
|
||||
}
|
||||
}
|
||||
}
|
||||
return values;
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
import ascending from "./ascending.js";
|
||||
|
||||
export default function least(values, compare = ascending) {
|
||||
let min;
|
||||
let defined = false;
|
||||
if (compare.length === 1) {
|
||||
let minValue;
|
||||
for (const element of values) {
|
||||
const value = compare(element);
|
||||
if (defined
|
||||
? ascending(value, minValue) < 0
|
||||
: ascending(value, value) === 0) {
|
||||
min = element;
|
||||
minValue = value;
|
||||
defined = true;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (const value of values) {
|
||||
if (defined
|
||||
? compare(value, min) < 0
|
||||
: compare(value, value) === 0) {
|
||||
min = value;
|
||||
defined = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return min;
|
||||
}
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
import ascending from "./ascending.js";
|
||||
import minIndex from "./minIndex.js";
|
||||
|
||||
export default function leastIndex(values, compare = ascending) {
|
||||
if (compare.length === 1) return minIndex(values, compare);
|
||||
let minValue;
|
||||
let min = -1;
|
||||
let index = -1;
|
||||
for (const value of values) {
|
||||
++index;
|
||||
if (min < 0
|
||||
? compare(value, value) === 0
|
||||
: compare(value, minValue) < 0) {
|
||||
minValue = value;
|
||||
min = index;
|
||||
}
|
||||
}
|
||||
return min;
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
export default function map(values, mapper) {
|
||||
if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable");
|
||||
if (typeof mapper !== "function") throw new TypeError("mapper is not a function");
|
||||
return Array.from(values, (value, index) => mapper(value, index, values));
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
export default function max(values, valueof) {
|
||||
let max;
|
||||
if (valueof === undefined) {
|
||||
for (const value of values) {
|
||||
if (value != null
|
||||
&& (max < value || (max === undefined && value >= value))) {
|
||||
max = value;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let index = -1;
|
||||
for (let value of values) {
|
||||
if ((value = valueof(value, ++index, values)) != null
|
||||
&& (max < value || (max === undefined && value >= value))) {
|
||||
max = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return max;
|
||||
}
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
export default function maxIndex(values, valueof) {
|
||||
let max;
|
||||
let maxIndex = -1;
|
||||
let index = -1;
|
||||
if (valueof === undefined) {
|
||||
for (const value of values) {
|
||||
++index;
|
||||
if (value != null
|
||||
&& (max < value || (max === undefined && value >= value))) {
|
||||
max = value, maxIndex = index;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (let value of values) {
|
||||
if ((value = valueof(value, ++index, values)) != null
|
||||
&& (max < value || (max === undefined && value >= value))) {
|
||||
max = value, maxIndex = index;
|
||||
}
|
||||
}
|
||||
}
|
||||
return maxIndex;
|
||||
}
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
export default function mean(values, valueof) {
|
||||
let count = 0;
|
||||
let sum = 0;
|
||||
if (valueof === undefined) {
|
||||
for (let value of values) {
|
||||
if (value != null && (value = +value) >= value) {
|
||||
++count, sum += value;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let index = -1;
|
||||
for (let value of values) {
|
||||
if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
|
||||
++count, sum += value;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (count) return sum / count;
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
import quantile from "./quantile.js";
|
||||
|
||||
export default function(values, valueof) {
|
||||
return quantile(values, 0.5, valueof);
|
||||
}
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
function* flatten(arrays) {
|
||||
for (const array of arrays) {
|
||||
yield* array;
|
||||
}
|
||||
}
|
||||
|
||||
export default function merge(arrays) {
|
||||
return Array.from(flatten(arrays));
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
export default function min(values, valueof) {
|
||||
let min;
|
||||
if (valueof === undefined) {
|
||||
for (const value of values) {
|
||||
if (value != null
|
||||
&& (min > value || (min === undefined && value >= value))) {
|
||||
min = value;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let index = -1;
|
||||
for (let value of values) {
|
||||
if ((value = valueof(value, ++index, values)) != null
|
||||
&& (min > value || (min === undefined && value >= value))) {
|
||||
min = value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return min;
|
||||
}
|
||||
+22
@@ -0,0 +1,22 @@
|
||||
export default function minIndex(values, valueof) {
|
||||
let min;
|
||||
let minIndex = -1;
|
||||
let index = -1;
|
||||
if (valueof === undefined) {
|
||||
for (const value of values) {
|
||||
++index;
|
||||
if (value != null
|
||||
&& (min > value || (min === undefined && value >= value))) {
|
||||
min = value, minIndex = index;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (let value of values) {
|
||||
if ((value = valueof(value, ++index, values)) != null
|
||||
&& (min > value || (min === undefined && value >= value))) {
|
||||
min = value, minIndex = index;
|
||||
}
|
||||
}
|
||||
}
|
||||
return minIndex;
|
||||
}
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
import {tickIncrement} from "./ticks.js";
|
||||
|
||||
export default function nice(start, stop, count) {
|
||||
let prestep;
|
||||
while (true) {
|
||||
const step = tickIncrement(start, stop, count);
|
||||
if (step === prestep || step === 0 || !isFinite(step)) {
|
||||
return [start, stop];
|
||||
} 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;
|
||||
}
|
||||
prestep = step;
|
||||
}
|
||||
}
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
export default function(x) {
|
||||
return x === null ? NaN : +x;
|
||||
}
|
||||
|
||||
export function* numbers(values, valueof) {
|
||||
if (valueof === undefined) {
|
||||
for (let value of values) {
|
||||
if (value != null && (value = +value) >= value) {
|
||||
yield value;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let index = -1;
|
||||
for (let value of values) {
|
||||
if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
|
||||
yield value;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
export default function pairs(values, pairof = pair) {
|
||||
const pairs = [];
|
||||
let previous;
|
||||
let first = false;
|
||||
for (const value of values) {
|
||||
if (first) pairs.push(pairof(previous, value));
|
||||
previous = value;
|
||||
first = true;
|
||||
}
|
||||
return pairs;
|
||||
}
|
||||
|
||||
export function pair(a, b) {
|
||||
return [a, b];
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
export default function(source, keys) {
|
||||
return Array.from(keys, key => source[key]);
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
import max from "./max.js";
|
||||
import min from "./min.js";
|
||||
import quickselect from "./quickselect.js";
|
||||
import number, {numbers} from "./number.js";
|
||||
|
||||
export default function quantile(values, p, valueof) {
|
||||
values = Float64Array.from(numbers(values, valueof));
|
||||
if (!(n = values.length)) return;
|
||||
if ((p = +p) <= 0 || n < 2) return min(values);
|
||||
if (p >= 1) return max(values);
|
||||
var n,
|
||||
i = (n - 1) * p,
|
||||
i0 = Math.floor(i),
|
||||
value0 = max(quickselect(values, i0).subarray(0, i0 + 1)),
|
||||
value1 = min(values.subarray(i0 + 1));
|
||||
return value0 + (value1 - value0) * (i - i0);
|
||||
}
|
||||
|
||||
export function quantileSorted(values, p, valueof = number) {
|
||||
if (!(n = values.length)) return;
|
||||
if ((p = +p) <= 0 || n < 2) return +valueof(values[0], 0, values);
|
||||
if (p >= 1) return +valueof(values[n - 1], n - 1, values);
|
||||
var n,
|
||||
i = (n - 1) * p,
|
||||
i0 = Math.floor(i),
|
||||
value0 = +valueof(values[i0], i0, values),
|
||||
value1 = +valueof(values[i0 + 1], i0 + 1, values);
|
||||
return value0 + (value1 - value0) * (i - i0);
|
||||
}
|
||||
+44
@@ -0,0 +1,44 @@
|
||||
import ascending from "./ascending.js";
|
||||
|
||||
// Based on https://github.com/mourner/quickselect
|
||||
// ISC license, Copyright 2018 Vladimir Agafonkin.
|
||||
export default function quickselect(array, k, left = 0, right = array.length - 1, compare = ascending) {
|
||||
while (right > left) {
|
||||
if (right - left > 600) {
|
||||
const n = right - left + 1;
|
||||
const m = k - left + 1;
|
||||
const z = Math.log(n);
|
||||
const s = 0.5 * Math.exp(2 * z / 3);
|
||||
const sd = 0.5 * Math.sqrt(z * s * (n - s) / n) * (m - n / 2 < 0 ? -1 : 1);
|
||||
const newLeft = Math.max(left, Math.floor(k - m * s / n + sd));
|
||||
const newRight = Math.min(right, Math.floor(k + (n - m) * s / n + sd));
|
||||
quickselect(array, k, newLeft, newRight, compare);
|
||||
}
|
||||
|
||||
const t = array[k];
|
||||
let i = left;
|
||||
let j = right;
|
||||
|
||||
swap(array, left, k);
|
||||
if (compare(array[right], t) > 0) swap(array, left, right);
|
||||
|
||||
while (i < j) {
|
||||
swap(array, i, j), ++i, --j;
|
||||
while (compare(array[i], t) < 0) ++i;
|
||||
while (compare(array[j], t) > 0) --j;
|
||||
}
|
||||
|
||||
if (compare(array[left], t) === 0) swap(array, left, j);
|
||||
else ++j, swap(array, j, right);
|
||||
|
||||
if (j <= k) left = j + 1;
|
||||
if (k <= j) right = j - 1;
|
||||
}
|
||||
return array;
|
||||
}
|
||||
|
||||
function swap(array, i, j) {
|
||||
const t = array[i];
|
||||
array[i] = array[j];
|
||||
array[j] = t;
|
||||
}
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
export default function(start, stop, step) {
|
||||
start = +start, stop = +stop, step = (n = arguments.length) < 2 ? (stop = start, start = 0, 1) : n < 3 ? 1 : +step;
|
||||
|
||||
var i = -1,
|
||||
n = Math.max(0, Math.ceil((stop - start) / step)) | 0,
|
||||
range = new Array(n);
|
||||
|
||||
while (++i < n) {
|
||||
range[i] = start + i * step;
|
||||
}
|
||||
|
||||
return range;
|
||||
}
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
export default function reduce(values, reducer, value) {
|
||||
if (typeof reducer !== "function") throw new TypeError("reducer is not a function");
|
||||
const iterator = values[Symbol.iterator]();
|
||||
let done, next, index = -1;
|
||||
if (arguments.length < 3) {
|
||||
({done, value} = iterator.next());
|
||||
if (done) return;
|
||||
++index;
|
||||
}
|
||||
while (({done, value: next} = iterator.next()), !done) {
|
||||
value = reducer(value, next, ++index, values);
|
||||
}
|
||||
return value;
|
||||
}
|
||||
+4
@@ -0,0 +1,4 @@
|
||||
export default function reverse(values) {
|
||||
if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable");
|
||||
return Array.from(values).reverse();
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
import leastIndex from "./leastIndex.js";
|
||||
|
||||
export default function scan(values, compare) {
|
||||
const index = leastIndex(values, compare);
|
||||
return index < 0 ? undefined : index;
|
||||
}
|
||||
+3
@@ -0,0 +1,3 @@
|
||||
export default function set(values) {
|
||||
return values instanceof Set ? values : new Set(values);
|
||||
}
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
export default shuffler(Math.random);
|
||||
|
||||
export function shuffler(random) {
|
||||
return function shuffle(array, i0 = 0, i1 = array.length) {
|
||||
let m = i1 - (i0 = +i0);
|
||||
while (m) {
|
||||
const i = random() * m-- | 0, t = array[m + i0];
|
||||
array[m + i0] = array[i + i0];
|
||||
array[i + i0] = t;
|
||||
}
|
||||
return array;
|
||||
};
|
||||
}
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
export default function some(values, test) {
|
||||
if (typeof test !== "function") throw new TypeError("test is not a function");
|
||||
let index = -1;
|
||||
for (const value of values) {
|
||||
if (test(value, ++index, values)) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
import ascending from "./ascending.js";
|
||||
import permute from "./permute.js";
|
||||
|
||||
export default function sort(values, ...F) {
|
||||
if (typeof values[Symbol.iterator] !== "function") throw new TypeError("values is not iterable");
|
||||
values = Array.from(values);
|
||||
let [f = ascending] = F;
|
||||
if (f.length === 1 || F.length > 1) {
|
||||
const index = Uint32Array.from(values, (d, i) => i);
|
||||
if (F.length > 1) {
|
||||
F = F.map(f => values.map(f));
|
||||
index.sort((i, j) => {
|
||||
for (const f of F) {
|
||||
const c = ascending(f[i], f[j]);
|
||||
if (c) return c;
|
||||
}
|
||||
});
|
||||
} else {
|
||||
f = values.map(f);
|
||||
index.sort((i, j) => ascending(f[i], f[j]));
|
||||
}
|
||||
return permute(values, index);
|
||||
}
|
||||
return values.sort(f);
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
import superset from "./superset.js";
|
||||
|
||||
export default function subset(values, other) {
|
||||
return superset(other, values);
|
||||
}
|
||||
+18
@@ -0,0 +1,18 @@
|
||||
export default function sum(values, valueof) {
|
||||
let sum = 0;
|
||||
if (valueof === undefined) {
|
||||
for (let value of values) {
|
||||
if (value = +value) {
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let index = -1;
|
||||
for (let value of values) {
|
||||
if (value = +valueof(value, ++index, values)) {
|
||||
sum += value;
|
||||
}
|
||||
}
|
||||
}
|
||||
return sum;
|
||||
}
|
||||
+13
@@ -0,0 +1,13 @@
|
||||
export default function superset(values, other) {
|
||||
const iterator = values[Symbol.iterator](), set = new Set();
|
||||
for (const o of other) {
|
||||
if (set.has(o)) continue;
|
||||
let value, done;
|
||||
while (({value, done} = iterator.next())) {
|
||||
if (done) return false;
|
||||
set.add(value);
|
||||
if (Object.is(o, value)) break;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
Generated
Vendored
+6
@@ -0,0 +1,6 @@
|
||||
import count from "../count.js";
|
||||
import quantile from "../quantile.js";
|
||||
|
||||
export default function(values, min, max) {
|
||||
return Math.ceil((max - min) / (2 * (quantile(values, 0.75) - quantile(values, 0.25)) * Math.pow(count(values), -1 / 3)));
|
||||
}
|
||||
+6
@@ -0,0 +1,6 @@
|
||||
import count from "../count.js";
|
||||
import deviation from "../deviation.js";
|
||||
|
||||
export default function(values, min, max) {
|
||||
return Math.ceil((max - min) / (3.5 * deviation(values) * Math.pow(count(values), -1 / 3)));
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
import count from "../count.js";
|
||||
|
||||
export default function(values) {
|
||||
return Math.ceil(Math.log(count(values)) / Math.LN2) + 1;
|
||||
}
|
||||
+54
@@ -0,0 +1,54 @@
|
||||
var e10 = Math.sqrt(50),
|
||||
e5 = Math.sqrt(10),
|
||||
e2 = Math.sqrt(2);
|
||||
|
||||
export default function(start, stop, count) {
|
||||
var reverse,
|
||||
i = -1,
|
||||
n,
|
||||
ticks,
|
||||
step;
|
||||
|
||||
stop = +stop, start = +start, count = +count;
|
||||
if (start === stop && count > 0) return [start];
|
||||
if (reverse = stop < start) n = start, start = stop, stop = n;
|
||||
if ((step = tickIncrement(start, stop, count)) === 0 || !isFinite(step)) return [];
|
||||
|
||||
if (step > 0) {
|
||||
let r0 = Math.round(start / step), r1 = Math.round(stop / step);
|
||||
if (r0 * step < start) ++r0;
|
||||
if (r1 * step > stop) --r1;
|
||||
ticks = new Array(n = r1 - r0 + 1);
|
||||
while (++i < n) ticks[i] = (r0 + i) * step;
|
||||
} else {
|
||||
step = -step;
|
||||
let r0 = Math.round(start * step), r1 = Math.round(stop * step);
|
||||
if (r0 / step < start) ++r0;
|
||||
if (r1 / step > stop) --r1;
|
||||
ticks = new Array(n = r1 - r0 + 1);
|
||||
while (++i < n) ticks[i] = (r0 + i) / step;
|
||||
}
|
||||
|
||||
if (reverse) ticks.reverse();
|
||||
|
||||
return ticks;
|
||||
}
|
||||
|
||||
export function tickIncrement(start, stop, count) {
|
||||
var step = (stop - start) / Math.max(0, count),
|
||||
power = Math.floor(Math.log(step) / Math.LN10),
|
||||
error = step / Math.pow(10, power);
|
||||
return power >= 0
|
||||
? (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1) * Math.pow(10, power)
|
||||
: -Math.pow(10, -power) / (error >= e10 ? 10 : error >= e5 ? 5 : error >= e2 ? 2 : 1);
|
||||
}
|
||||
|
||||
export function tickStep(start, stop, count) {
|
||||
var step0 = Math.abs(stop - start) / Math.max(0, count),
|
||||
step1 = Math.pow(10, Math.floor(Math.log(step0) / Math.LN10)),
|
||||
error = step0 / step1;
|
||||
if (error >= e10) step1 *= 10;
|
||||
else if (error >= e5) step1 *= 5;
|
||||
else if (error >= e2) step1 *= 2;
|
||||
return stop < start ? -step1 : step1;
|
||||
}
|
||||
+15
@@ -0,0 +1,15 @@
|
||||
import min from "./min.js";
|
||||
|
||||
export default function(matrix) {
|
||||
if (!(n = matrix.length)) return [];
|
||||
for (var i = -1, m = min(matrix, length), transpose = new Array(m); ++i < m;) {
|
||||
for (var j = -1, n, row = transpose[i] = new Array(n); ++j < n;) {
|
||||
row[j] = matrix[j][i];
|
||||
}
|
||||
}
|
||||
return transpose;
|
||||
}
|
||||
|
||||
function length(d) {
|
||||
return d.length;
|
||||
}
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
export default function union(...others) {
|
||||
const set = new Set();
|
||||
for (const other of others) {
|
||||
for (const o of other) {
|
||||
set.add(o);
|
||||
}
|
||||
}
|
||||
return set;
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
export default function variance(values, valueof) {
|
||||
let count = 0;
|
||||
let delta;
|
||||
let mean = 0;
|
||||
let sum = 0;
|
||||
if (valueof === undefined) {
|
||||
for (let value of values) {
|
||||
if (value != null && (value = +value) >= value) {
|
||||
delta = value - mean;
|
||||
mean += delta / ++count;
|
||||
sum += delta * (value - mean);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
let index = -1;
|
||||
for (let value of values) {
|
||||
if ((value = valueof(value, ++index, values)) != null && (value = +value) >= value) {
|
||||
delta = value - mean;
|
||||
mean += delta / ++count;
|
||||
sum += delta * (value - mean);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (count > 1) return sum / (count - 1);
|
||||
}
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
import transpose from "./transpose.js";
|
||||
|
||||
export default function() {
|
||||
return transpose(arguments);
|
||||
}
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
Copyright 2015-2016 Mike Bostock
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the author nor the names of contributors may be used to
|
||||
endorse or promote products derived from this software without specific prior
|
||||
written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
+78
@@ -0,0 +1,78 @@
|
||||
# d3-path
|
||||
|
||||
Say you have some code that draws to a 2D canvas:
|
||||
|
||||
```js
|
||||
function drawCircle(context, radius) {
|
||||
context.moveTo(radius, 0);
|
||||
context.arc(0, 0, radius, 0, 2 * Math.PI);
|
||||
}
|
||||
```
|
||||
|
||||
The d3-path module lets you take this exact code and additionally render to [SVG](http://www.w3.org/TR/SVG/paths.html). It works by [serializing](#path_toString) [CanvasPathMethods](http://www.w3.org/TR/2dcontext/#canvaspathmethods) calls to [SVG path data](http://www.w3.org/TR/SVG/paths.html#PathData). For example:
|
||||
|
||||
```js
|
||||
var context = d3.path();
|
||||
drawCircle(context, 40);
|
||||
pathElement.setAttribute("d", context.toString());
|
||||
```
|
||||
|
||||
Now code you write once can be used with both Canvas (for performance) and SVG (for convenience). For a practical example, see [d3-shape](https://github.com/d3/d3-shape).
|
||||
|
||||
## Installing
|
||||
|
||||
If you use NPM, `npm install d3-path`. Otherwise, download the [latest release](https://github.com/d3/d3-path/releases/latest). You can also load directly from [d3js.org](https://d3js.org), either as a [standalone library](https://d3js.org/d3-path.v1.min.js) or as part of [D3 4.0](https://github.com/d3/d3). AMD, CommonJS, and vanilla environments are supported. In vanilla, a `d3` global is exported:
|
||||
|
||||
```html
|
||||
<script src="https://d3js.org/d3-path.v1.min.js"></script>
|
||||
<script>
|
||||
|
||||
var path = d3.path();
|
||||
path.moveTo(1, 2);
|
||||
path.lineTo(3, 4);
|
||||
path.closePath();
|
||||
|
||||
</script>
|
||||
```
|
||||
|
||||
## API Reference
|
||||
|
||||
<a name="path" href="#path">#</a> d3.<b>path</b>() · [Source](https://github.com/d3/d3-path/blob/master/src/path.js), [Examples](https://observablehq.com/@d3/d3-path)
|
||||
|
||||
Constructs a new path serializer that implements [CanvasPathMethods](http://www.w3.org/TR/2dcontext/#canvaspathmethods).
|
||||
|
||||
<a name="path_moveTo" href="#path_moveTo">#</a> <i>path</i>.<b>moveTo</b>(<i>x</i>, <i>y</i>)
|
||||
|
||||
Move to the specified point ⟨*x*, *y*⟩. Equivalent to [*context*.moveTo](http://www.w3.org/TR/2dcontext/#dom-context-2d-moveto) and SVG’s [“moveto” command](http://www.w3.org/TR/SVG/paths.html#PathDataMovetoCommands).
|
||||
|
||||
<a name="path_closePath" href="#path_closePath">#</A> <i>path</i>.<b>closePath</b>()
|
||||
|
||||
Ends the current subpath and causes an automatic straight line to be drawn from the current point to the initial point of the current subpath. Equivalent to [*context*.closePath](http://www.w3.org/TR/2dcontext/#dom-context-2d-closepath) and SVG’s [“closepath” command](http://www.w3.org/TR/SVG/paths.html#PathDataClosePathCommand).
|
||||
|
||||
<a name="path_lineTo" href="#path_lineTo">#</a> <i>path</i>.<b>lineTo</b>(<i>x</i>, <i>y</i>)
|
||||
|
||||
Draws a straight line from the current point to the specified point ⟨*x*, *y*⟩. Equivalent to [*context*.lineTo](http://www.w3.org/TR/2dcontext/#dom-context-2d-lineto) and SVG’s [“lineto” command](http://www.w3.org/TR/SVG/paths.html#PathDataLinetoCommands).
|
||||
|
||||
<a name="path_quadraticCurveTo" href="#path_quadraticCurveTo">#</a> <i>path</i>.<b>quadraticCurveTo</b>(<i>cpx</i>, <i>cpy</i>, <i>x</i>, <i>y</i>)
|
||||
|
||||
Draws a quadratic Bézier segment from the current point to the specified point ⟨*x*, *y*⟩, with the specified control point ⟨*cpx*, *cpy*⟩. Equivalent to [*context*.quadraticCurveTo](http://www.w3.org/TR/2dcontext/#dom-context-2d-quadraticcurveto) and SVG’s [quadratic Bézier curve commands](http://www.w3.org/TR/SVG/paths.html#PathDataQuadraticBezierCommands).
|
||||
|
||||
<a name="path_bezierCurveTo" href="#path_bezierCurveTo">#</a> <i>path</i>.<b>bezierCurveTo</b>(<i>cpx1</i>, <i>cpy1</i>, <i>cpx2</i>, <i>cpy2</i>, <i>x</i>, <i>y</i>)
|
||||
|
||||
Draws a cubic Bézier segment from the current point to the specified point ⟨*x*, *y*⟩, with the specified control points ⟨*cpx1*, *cpy1*⟩ and ⟨*cpx2*, *cpy2*⟩. Equivalent to [*context*.bezierCurveTo](http://www.w3.org/TR/2dcontext/#dom-context-2d-beziercurveto) and SVG’s [cubic Bézier curve commands](http://www.w3.org/TR/SVG/paths.html#PathDataCubicBezierCommands).
|
||||
|
||||
<a name="path_arcTo" href="#path_arcTo">#</a> <i>path</i>.<b>arcTo</b>(<i>x1</i>, <i>y1</i>, <i>x2</i>, <i>y2</i>, <i>radius</i>)
|
||||
|
||||
Draws a circular arc segment with the specified *radius* that starts tangent to the line between the current point and the specified point ⟨*x1*, *y1*⟩ and ends tangent to the line between the specified points ⟨*x1*, *y1*⟩ and ⟨*x2*, *y2*⟩. If the first tangent point is not equal to the current point, a straight line is drawn between the current point and the first tangent point. Equivalent to [*context*.arcTo](http://www.w3.org/TR/2dcontext/#dom-context-2d-arcto) and uses SVG’s [elliptical arc curve commands](http://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands).
|
||||
|
||||
<a name="path_arc" href="#path_arc">#</a> <i>path</i>.<b>arc</b>(<i>x</i>, <i>y</i>, <i>radius</i>, <i>startAngle</i>, <i>endAngle</i>[, <i>anticlockwise</i>])
|
||||
|
||||
Draws a circular arc segment with the specified center ⟨*x*, *y*⟩, *radius*, *startAngle* and *endAngle*. If *anticlockwise* is true, the arc is drawn in the anticlockwise direction; otherwise, it is drawn in the clockwise direction. If the current point is not equal to the starting point of the arc, a straight line is drawn from the current point to the start of the arc. Equivalent to [*context*.arc](http://www.w3.org/TR/2dcontext/#dom-context-2d-arc) and uses SVG’s [elliptical arc curve commands](http://www.w3.org/TR/SVG/paths.html#PathDataEllipticalArcCommands).
|
||||
|
||||
<a name="path_rect" href="#path_rect">#</a> <i>path</i>.<b>rect</b>(<i>x</i>, <i>y</i>, <i>w</i>, <i>h</i>)
|
||||
|
||||
Creates a new subpath containing just the four points ⟨*x*, *y*⟩, ⟨*x* + *w*, *y*⟩, ⟨*x* + *w*, *y* + *h*⟩, ⟨*x*, *y* + *h*⟩, with those four points connected by straight lines, and then marks the subpath as closed. Equivalent to [*context*.rect](http://www.w3.org/TR/2dcontext/#dom-context-2d-rect) and uses SVG’s [“lineto” commands](http://www.w3.org/TR/SVG/paths.html#PathDataLinetoCommands).
|
||||
|
||||
<a name="path_toString" href="#path_toString">#</a> <i>path</i>.<b>toString</b>()
|
||||
|
||||
Returns the string representation of this *path* according to SVG’s [path data specification](http://www.w3.org/TR/SVG/paths.html#PathData).
|
||||
+141
@@ -0,0 +1,141 @@
|
||||
// https://d3js.org/d3-path/ v1.0.9 Copyright 2019 Mike Bostock
|
||||
(function (global, factory) {
|
||||
typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
|
||||
typeof define === 'function' && define.amd ? define(['exports'], factory) :
|
||||
(global = global || self, factory(global.d3 = global.d3 || {}));
|
||||
}(this, function (exports) { 'use strict';
|
||||
|
||||
var pi = Math.PI,
|
||||
tau = 2 * pi,
|
||||
epsilon = 1e-6,
|
||||
tauEpsilon = tau - epsilon;
|
||||
|
||||
function Path() {
|
||||
this._x0 = this._y0 = // start of current subpath
|
||||
this._x1 = this._y1 = null; // end of current subpath
|
||||
this._ = "";
|
||||
}
|
||||
|
||||
function path() {
|
||||
return new Path;
|
||||
}
|
||||
|
||||
Path.prototype = path.prototype = {
|
||||
constructor: Path,
|
||||
moveTo: function(x, y) {
|
||||
this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y);
|
||||
},
|
||||
closePath: function() {
|
||||
if (this._x1 !== null) {
|
||||
this._x1 = this._x0, this._y1 = this._y0;
|
||||
this._ += "Z";
|
||||
}
|
||||
},
|
||||
lineTo: function(x, y) {
|
||||
this._ += "L" + (this._x1 = +x) + "," + (this._y1 = +y);
|
||||
},
|
||||
quadraticCurveTo: function(x1, y1, x, y) {
|
||||
this._ += "Q" + (+x1) + "," + (+y1) + "," + (this._x1 = +x) + "," + (this._y1 = +y);
|
||||
},
|
||||
bezierCurveTo: function(x1, y1, x2, y2, x, y) {
|
||||
this._ += "C" + (+x1) + "," + (+y1) + "," + (+x2) + "," + (+y2) + "," + (this._x1 = +x) + "," + (this._y1 = +y);
|
||||
},
|
||||
arcTo: function(x1, y1, x2, y2, r) {
|
||||
x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
|
||||
var x0 = this._x1,
|
||||
y0 = this._y1,
|
||||
x21 = x2 - x1,
|
||||
y21 = y2 - y1,
|
||||
x01 = x0 - x1,
|
||||
y01 = y0 - y1,
|
||||
l01_2 = x01 * x01 + y01 * y01;
|
||||
|
||||
// Is the radius negative? Error.
|
||||
if (r < 0) throw new Error("negative radius: " + r);
|
||||
|
||||
// Is this path empty? Move to (x1,y1).
|
||||
if (this._x1 === null) {
|
||||
this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1);
|
||||
}
|
||||
|
||||
// Or, is (x1,y1) coincident with (x0,y0)? Do nothing.
|
||||
else if (!(l01_2 > epsilon));
|
||||
|
||||
// Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?
|
||||
// Equivalently, is (x1,y1) coincident with (x2,y2)?
|
||||
// Or, is the radius zero? Line to (x1,y1).
|
||||
else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) {
|
||||
this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1);
|
||||
}
|
||||
|
||||
// Otherwise, draw an arc!
|
||||
else {
|
||||
var x20 = x2 - x0,
|
||||
y20 = y2 - y0,
|
||||
l21_2 = x21 * x21 + y21 * y21,
|
||||
l20_2 = x20 * x20 + y20 * y20,
|
||||
l21 = Math.sqrt(l21_2),
|
||||
l01 = Math.sqrt(l01_2),
|
||||
l = r * Math.tan((pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),
|
||||
t01 = l / l01,
|
||||
t21 = l / l21;
|
||||
|
||||
// If the start tangent is not coincident with (x0,y0), line to.
|
||||
if (Math.abs(t01 - 1) > epsilon) {
|
||||
this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01);
|
||||
}
|
||||
|
||||
this._ += "A" + r + "," + r + ",0,0," + (+(y01 * x20 > x01 * y20)) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21);
|
||||
}
|
||||
},
|
||||
arc: function(x, y, r, a0, a1, ccw) {
|
||||
x = +x, y = +y, r = +r, ccw = !!ccw;
|
||||
var dx = r * Math.cos(a0),
|
||||
dy = r * Math.sin(a0),
|
||||
x0 = x + dx,
|
||||
y0 = y + dy,
|
||||
cw = 1 ^ ccw,
|
||||
da = ccw ? a0 - a1 : a1 - a0;
|
||||
|
||||
// Is the radius negative? Error.
|
||||
if (r < 0) throw new Error("negative radius: " + r);
|
||||
|
||||
// Is this path empty? Move to (x0,y0).
|
||||
if (this._x1 === null) {
|
||||
this._ += "M" + x0 + "," + y0;
|
||||
}
|
||||
|
||||
// Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).
|
||||
else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) {
|
||||
this._ += "L" + x0 + "," + y0;
|
||||
}
|
||||
|
||||
// Is this arc empty? We’re done.
|
||||
if (!r) return;
|
||||
|
||||
// Does the angle go the wrong way? Flip the direction.
|
||||
if (da < 0) da = da % tau + tau;
|
||||
|
||||
// Is this a complete circle? Draw two arcs to complete the circle.
|
||||
if (da > tauEpsilon) {
|
||||
this._ += "A" + r + "," + r + ",0,1," + cw + "," + (x - dx) + "," + (y - dy) + "A" + r + "," + r + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0);
|
||||
}
|
||||
|
||||
// Is this arc non-empty? Draw an arc!
|
||||
else if (da > epsilon) {
|
||||
this._ += "A" + r + "," + r + ",0," + (+(da >= pi)) + "," + cw + "," + (this._x1 = x + r * Math.cos(a1)) + "," + (this._y1 = y + r * Math.sin(a1));
|
||||
}
|
||||
},
|
||||
rect: function(x, y, w, h) {
|
||||
this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y) + "h" + (+w) + "v" + (+h) + "h" + (-w) + "Z";
|
||||
},
|
||||
toString: function() {
|
||||
return this._;
|
||||
}
|
||||
};
|
||||
|
||||
exports.path = path;
|
||||
|
||||
Object.defineProperty(exports, '__esModule', { value: true });
|
||||
|
||||
}));
|
||||
+2
@@ -0,0 +1,2 @@
|
||||
// https://d3js.org/d3-path/ v1.0.9 Copyright 2019 Mike Bostock
|
||||
!function(t,i){"object"==typeof exports&&"undefined"!=typeof module?i(exports):"function"==typeof define&&define.amd?define(["exports"],i):i((t=t||self).d3=t.d3||{})}(this,function(t){"use strict";var i=Math.PI,s=2*i,h=s-1e-6;function e(){this._x0=this._y0=this._x1=this._y1=null,this._=""}function _(){return new e}e.prototype=_.prototype={constructor:e,moveTo:function(t,i){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+i)},closePath:function(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")},lineTo:function(t,i){this._+="L"+(this._x1=+t)+","+(this._y1=+i)},quadraticCurveTo:function(t,i,s,h){this._+="Q"+ +t+","+ +i+","+(this._x1=+s)+","+(this._y1=+h)},bezierCurveTo:function(t,i,s,h,e,_){this._+="C"+ +t+","+ +i+","+ +s+","+ +h+","+(this._x1=+e)+","+(this._y1=+_)},arcTo:function(t,s,h,e,_){t=+t,s=+s,h=+h,e=+e,_=+_;var n=this._x1,o=this._y1,r=h-t,a=e-s,u=n-t,f=o-s,c=u*u+f*f;if(_<0)throw new Error("negative radius: "+_);if(null===this._x1)this._+="M"+(this._x1=t)+","+(this._y1=s);else if(c>1e-6)if(Math.abs(f*r-a*u)>1e-6&&_){var x=h-n,y=e-o,M=r*r+a*a,l=x*x+y*y,d=Math.sqrt(M),p=Math.sqrt(c),v=_*Math.tan((i-Math.acos((M+c-l)/(2*d*p)))/2),b=v/p,w=v/d;Math.abs(b-1)>1e-6&&(this._+="L"+(t+b*u)+","+(s+b*f)),this._+="A"+_+","+_+",0,0,"+ +(f*x>u*y)+","+(this._x1=t+w*r)+","+(this._y1=s+w*a)}else this._+="L"+(this._x1=t)+","+(this._y1=s);else;},arc:function(t,e,_,n,o,r){t=+t,e=+e,r=!!r;var a=(_=+_)*Math.cos(n),u=_*Math.sin(n),f=t+a,c=e+u,x=1^r,y=r?n-o:o-n;if(_<0)throw new Error("negative radius: "+_);null===this._x1?this._+="M"+f+","+c:(Math.abs(this._x1-f)>1e-6||Math.abs(this._y1-c)>1e-6)&&(this._+="L"+f+","+c),_&&(y<0&&(y=y%s+s),y>h?this._+="A"+_+","+_+",0,1,"+x+","+(t-a)+","+(e-u)+"A"+_+","+_+",0,1,"+x+","+(this._x1=f)+","+(this._y1=c):y>1e-6&&(this._+="A"+_+","+_+",0,"+ +(y>=i)+","+x+","+(this._x1=t+_*Math.cos(o))+","+(this._y1=e+_*Math.sin(o))))},rect:function(t,i,s,h){this._+="M"+(this._x0=this._x1=+t)+","+(this._y0=this._y1=+i)+"h"+ +s+"v"+ +h+"h"+-s+"Z"},toString:function(){return this._}},t.path=_,Object.defineProperty(t,"__esModule",{value:!0})});
|
||||
+47
@@ -0,0 +1,47 @@
|
||||
{
|
||||
"name": "d3-path",
|
||||
"version": "1.0.9",
|
||||
"description": "Serialize Canvas path commands to SVG.",
|
||||
"keywords": [
|
||||
"d3",
|
||||
"d3-module",
|
||||
"canvas",
|
||||
"path",
|
||||
"svg",
|
||||
"graphics",
|
||||
"CanvasRenderingContext2D",
|
||||
"CanvasPathMethods",
|
||||
"Path2D"
|
||||
],
|
||||
"homepage": "https://d3js.org/d3-path/",
|
||||
"license": "BSD-3-Clause",
|
||||
"author": {
|
||||
"name": "Mike Bostock",
|
||||
"url": "http://bost.ocks.org/mike"
|
||||
},
|
||||
"main": "dist/d3-path.js",
|
||||
"unpkg": "dist/d3-path.min.js",
|
||||
"jsdelivr": "dist/d3-path.min.js",
|
||||
"module": "src/index.js",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/d3/d3-path.git"
|
||||
},
|
||||
"files": [
|
||||
"dist/**/*.js",
|
||||
"src/**/*.js"
|
||||
],
|
||||
"scripts": {
|
||||
"pretest": "rollup -c",
|
||||
"test": "tape 'test/**/*-test.js' && eslint src test",
|
||||
"prepublishOnly": "rm -rf dist && yarn test",
|
||||
"postpublish": "git push && git push --tags && cd ../d3.github.com && git pull && cp ../${npm_package_name}/dist/${npm_package_name}.js ${npm_package_name}.v${npm_package_version%%.*}.js && cp ../${npm_package_name}/dist/${npm_package_name}.min.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git add ${npm_package_name}.v${npm_package_version%%.*}.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git commit -m \"${npm_package_name} ${npm_package_version}\" && git push && cd - && zip -j dist/${npm_package_name}.zip -- LICENSE README.md dist/${npm_package_name}.js dist/${npm_package_name}.min.js"
|
||||
},
|
||||
"sideEffects": false,
|
||||
"devDependencies": {
|
||||
"eslint": "6",
|
||||
"rollup": "1",
|
||||
"rollup-plugin-terser": "5",
|
||||
"tape": "4"
|
||||
}
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
export {default as path} from "./path.js";
|
||||
+130
@@ -0,0 +1,130 @@
|
||||
var pi = Math.PI,
|
||||
tau = 2 * pi,
|
||||
epsilon = 1e-6,
|
||||
tauEpsilon = tau - epsilon;
|
||||
|
||||
function Path() {
|
||||
this._x0 = this._y0 = // start of current subpath
|
||||
this._x1 = this._y1 = null; // end of current subpath
|
||||
this._ = "";
|
||||
}
|
||||
|
||||
function path() {
|
||||
return new Path;
|
||||
}
|
||||
|
||||
Path.prototype = path.prototype = {
|
||||
constructor: Path,
|
||||
moveTo: function(x, y) {
|
||||
this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y);
|
||||
},
|
||||
closePath: function() {
|
||||
if (this._x1 !== null) {
|
||||
this._x1 = this._x0, this._y1 = this._y0;
|
||||
this._ += "Z";
|
||||
}
|
||||
},
|
||||
lineTo: function(x, y) {
|
||||
this._ += "L" + (this._x1 = +x) + "," + (this._y1 = +y);
|
||||
},
|
||||
quadraticCurveTo: function(x1, y1, x, y) {
|
||||
this._ += "Q" + (+x1) + "," + (+y1) + "," + (this._x1 = +x) + "," + (this._y1 = +y);
|
||||
},
|
||||
bezierCurveTo: function(x1, y1, x2, y2, x, y) {
|
||||
this._ += "C" + (+x1) + "," + (+y1) + "," + (+x2) + "," + (+y2) + "," + (this._x1 = +x) + "," + (this._y1 = +y);
|
||||
},
|
||||
arcTo: function(x1, y1, x2, y2, r) {
|
||||
x1 = +x1, y1 = +y1, x2 = +x2, y2 = +y2, r = +r;
|
||||
var x0 = this._x1,
|
||||
y0 = this._y1,
|
||||
x21 = x2 - x1,
|
||||
y21 = y2 - y1,
|
||||
x01 = x0 - x1,
|
||||
y01 = y0 - y1,
|
||||
l01_2 = x01 * x01 + y01 * y01;
|
||||
|
||||
// Is the radius negative? Error.
|
||||
if (r < 0) throw new Error("negative radius: " + r);
|
||||
|
||||
// Is this path empty? Move to (x1,y1).
|
||||
if (this._x1 === null) {
|
||||
this._ += "M" + (this._x1 = x1) + "," + (this._y1 = y1);
|
||||
}
|
||||
|
||||
// Or, is (x1,y1) coincident with (x0,y0)? Do nothing.
|
||||
else if (!(l01_2 > epsilon));
|
||||
|
||||
// Or, are (x0,y0), (x1,y1) and (x2,y2) collinear?
|
||||
// Equivalently, is (x1,y1) coincident with (x2,y2)?
|
||||
// Or, is the radius zero? Line to (x1,y1).
|
||||
else if (!(Math.abs(y01 * x21 - y21 * x01) > epsilon) || !r) {
|
||||
this._ += "L" + (this._x1 = x1) + "," + (this._y1 = y1);
|
||||
}
|
||||
|
||||
// Otherwise, draw an arc!
|
||||
else {
|
||||
var x20 = x2 - x0,
|
||||
y20 = y2 - y0,
|
||||
l21_2 = x21 * x21 + y21 * y21,
|
||||
l20_2 = x20 * x20 + y20 * y20,
|
||||
l21 = Math.sqrt(l21_2),
|
||||
l01 = Math.sqrt(l01_2),
|
||||
l = r * Math.tan((pi - Math.acos((l21_2 + l01_2 - l20_2) / (2 * l21 * l01))) / 2),
|
||||
t01 = l / l01,
|
||||
t21 = l / l21;
|
||||
|
||||
// If the start tangent is not coincident with (x0,y0), line to.
|
||||
if (Math.abs(t01 - 1) > epsilon) {
|
||||
this._ += "L" + (x1 + t01 * x01) + "," + (y1 + t01 * y01);
|
||||
}
|
||||
|
||||
this._ += "A" + r + "," + r + ",0,0," + (+(y01 * x20 > x01 * y20)) + "," + (this._x1 = x1 + t21 * x21) + "," + (this._y1 = y1 + t21 * y21);
|
||||
}
|
||||
},
|
||||
arc: function(x, y, r, a0, a1, ccw) {
|
||||
x = +x, y = +y, r = +r, ccw = !!ccw;
|
||||
var dx = r * Math.cos(a0),
|
||||
dy = r * Math.sin(a0),
|
||||
x0 = x + dx,
|
||||
y0 = y + dy,
|
||||
cw = 1 ^ ccw,
|
||||
da = ccw ? a0 - a1 : a1 - a0;
|
||||
|
||||
// Is the radius negative? Error.
|
||||
if (r < 0) throw new Error("negative radius: " + r);
|
||||
|
||||
// Is this path empty? Move to (x0,y0).
|
||||
if (this._x1 === null) {
|
||||
this._ += "M" + x0 + "," + y0;
|
||||
}
|
||||
|
||||
// Or, is (x0,y0) not coincident with the previous point? Line to (x0,y0).
|
||||
else if (Math.abs(this._x1 - x0) > epsilon || Math.abs(this._y1 - y0) > epsilon) {
|
||||
this._ += "L" + x0 + "," + y0;
|
||||
}
|
||||
|
||||
// Is this arc empty? We’re done.
|
||||
if (!r) return;
|
||||
|
||||
// Does the angle go the wrong way? Flip the direction.
|
||||
if (da < 0) da = da % tau + tau;
|
||||
|
||||
// Is this a complete circle? Draw two arcs to complete the circle.
|
||||
if (da > tauEpsilon) {
|
||||
this._ += "A" + r + "," + r + ",0,1," + cw + "," + (x - dx) + "," + (y - dy) + "A" + r + "," + r + ",0,1," + cw + "," + (this._x1 = x0) + "," + (this._y1 = y0);
|
||||
}
|
||||
|
||||
// Is this arc non-empty? Draw an arc!
|
||||
else if (da > epsilon) {
|
||||
this._ += "A" + r + "," + r + ",0," + (+(da >= pi)) + "," + cw + "," + (this._x1 = x + r * Math.cos(a1)) + "," + (this._y1 = y + r * Math.sin(a1));
|
||||
}
|
||||
},
|
||||
rect: function(x, y, w, h) {
|
||||
this._ += "M" + (this._x0 = this._x1 = +x) + "," + (this._y0 = this._y1 = +y) + "h" + (+w) + "v" + (+h) + "h" + (-w) + "Z";
|
||||
},
|
||||
toString: function() {
|
||||
return this._;
|
||||
}
|
||||
};
|
||||
|
||||
export default path;
|
||||
+27
@@ -0,0 +1,27 @@
|
||||
Copyright 2010-2015 Mike Bostock
|
||||
All rights reserved.
|
||||
|
||||
Redistribution and use in source and binary forms, with or without modification,
|
||||
are permitted provided that the following conditions are met:
|
||||
|
||||
* Redistributions of source code must retain the above copyright notice, this
|
||||
list of conditions and the following disclaimer.
|
||||
|
||||
* Redistributions in binary form must reproduce the above copyright notice,
|
||||
this list of conditions and the following disclaimer in the documentation
|
||||
and/or other materials provided with the distribution.
|
||||
|
||||
* Neither the name of the author nor the names of contributors may be used to
|
||||
endorse or promote products derived from this software without specific prior
|
||||
written permission.
|
||||
|
||||
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||||
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||||
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||||
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
||||
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||||
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||||
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
||||
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||||
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||||
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||||
+1149
File diff suppressed because it is too large
Load Diff
+1949
File diff suppressed because it is too large
Load Diff
+2
File diff suppressed because one or more lines are too long
+48
@@ -0,0 +1,48 @@
|
||||
{
|
||||
"name": "d3-shape",
|
||||
"version": "1.3.7",
|
||||
"description": "Graphical primitives for visualization, such as lines and areas.",
|
||||
"keywords": [
|
||||
"d3",
|
||||
"d3-module",
|
||||
"graphics",
|
||||
"visualization",
|
||||
"canvas",
|
||||
"svg"
|
||||
],
|
||||
"homepage": "https://d3js.org/d3-shape/",
|
||||
"license": "BSD-3-Clause",
|
||||
"author": {
|
||||
"name": "Mike Bostock",
|
||||
"url": "http://bost.ocks.org/mike"
|
||||
},
|
||||
"main": "dist/d3-shape.js",
|
||||
"unpkg": "dist/d3-shape.min.js",
|
||||
"jsdelivr": "dist/d3-shape.min.js",
|
||||
"module": "src/index.js",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/d3/d3-shape.git"
|
||||
},
|
||||
"files": [
|
||||
"dist/**/*.js",
|
||||
"src/**/*.js"
|
||||
],
|
||||
"scripts": {
|
||||
"pretest": "rollup -c",
|
||||
"test": "tape 'test/**/*-test.js' && eslint src",
|
||||
"prepublishOnly": "rm -rf dist && yarn test",
|
||||
"postpublish": "git push && git push --tags && cd ../d3.github.com && git pull && cp ../${npm_package_name}/dist/${npm_package_name}.js ${npm_package_name}.v${npm_package_version%%.*}.js && cp ../${npm_package_name}/dist/${npm_package_name}.min.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git add ${npm_package_name}.v${npm_package_version%%.*}.js ${npm_package_name}.v${npm_package_version%%.*}.min.js && git commit -m \"${npm_package_name} ${npm_package_version}\" && git push && cd - && zip -j dist/${npm_package_name}.zip -- LICENSE README.md dist/${npm_package_name}.js dist/${npm_package_name}.min.js"
|
||||
},
|
||||
"dependencies": {
|
||||
"d3-path": "1"
|
||||
},
|
||||
"sideEffects": false,
|
||||
"devDependencies": {
|
||||
"d3-polygon": "1",
|
||||
"eslint": "6",
|
||||
"rollup": "1",
|
||||
"rollup-plugin-terser": "5",
|
||||
"tape": "4"
|
||||
}
|
||||
}
|
||||
+261
@@ -0,0 +1,261 @@
|
||||
import {path} from "d3-path";
|
||||
import constant from "./constant.js";
|
||||
import {abs, acos, asin, atan2, cos, epsilon, halfPi, max, min, pi, sin, sqrt, tau} from "./math.js";
|
||||
|
||||
function arcInnerRadius(d) {
|
||||
return d.innerRadius;
|
||||
}
|
||||
|
||||
function arcOuterRadius(d) {
|
||||
return d.outerRadius;
|
||||
}
|
||||
|
||||
function arcStartAngle(d) {
|
||||
return d.startAngle;
|
||||
}
|
||||
|
||||
function arcEndAngle(d) {
|
||||
return d.endAngle;
|
||||
}
|
||||
|
||||
function arcPadAngle(d) {
|
||||
return d && d.padAngle; // Note: optional!
|
||||
}
|
||||
|
||||
function intersect(x0, y0, x1, y1, x2, y2, x3, y3) {
|
||||
var x10 = x1 - x0, y10 = y1 - y0,
|
||||
x32 = x3 - x2, y32 = y3 - y2,
|
||||
t = y32 * x10 - x32 * y10;
|
||||
if (t * t < epsilon) return;
|
||||
t = (x32 * (y0 - y2) - y32 * (x0 - x2)) / t;
|
||||
return [x0 + t * x10, y0 + t * y10];
|
||||
}
|
||||
|
||||
// Compute perpendicular offset line of length rc.
|
||||
// http://mathworld.wolfram.com/Circle-LineIntersection.html
|
||||
function cornerTangents(x0, y0, x1, y1, r1, rc, cw) {
|
||||
var x01 = x0 - x1,
|
||||
y01 = y0 - y1,
|
||||
lo = (cw ? rc : -rc) / sqrt(x01 * x01 + y01 * y01),
|
||||
ox = lo * y01,
|
||||
oy = -lo * x01,
|
||||
x11 = x0 + ox,
|
||||
y11 = y0 + oy,
|
||||
x10 = x1 + ox,
|
||||
y10 = y1 + oy,
|
||||
x00 = (x11 + x10) / 2,
|
||||
y00 = (y11 + y10) / 2,
|
||||
dx = x10 - x11,
|
||||
dy = y10 - y11,
|
||||
d2 = dx * dx + dy * dy,
|
||||
r = r1 - rc,
|
||||
D = x11 * y10 - x10 * y11,
|
||||
d = (dy < 0 ? -1 : 1) * sqrt(max(0, r * r * d2 - D * D)),
|
||||
cx0 = (D * dy - dx * d) / d2,
|
||||
cy0 = (-D * dx - dy * d) / d2,
|
||||
cx1 = (D * dy + dx * d) / d2,
|
||||
cy1 = (-D * dx + dy * d) / d2,
|
||||
dx0 = cx0 - x00,
|
||||
dy0 = cy0 - y00,
|
||||
dx1 = cx1 - x00,
|
||||
dy1 = cy1 - y00;
|
||||
|
||||
// Pick the closer of the two intersection points.
|
||||
// TODO Is there a faster way to determine which intersection to use?
|
||||
if (dx0 * dx0 + dy0 * dy0 > dx1 * dx1 + dy1 * dy1) cx0 = cx1, cy0 = cy1;
|
||||
|
||||
return {
|
||||
cx: cx0,
|
||||
cy: cy0,
|
||||
x01: -ox,
|
||||
y01: -oy,
|
||||
x11: cx0 * (r1 / r - 1),
|
||||
y11: cy0 * (r1 / r - 1)
|
||||
};
|
||||
}
|
||||
|
||||
export default function() {
|
||||
var innerRadius = arcInnerRadius,
|
||||
outerRadius = arcOuterRadius,
|
||||
cornerRadius = constant(0),
|
||||
padRadius = null,
|
||||
startAngle = arcStartAngle,
|
||||
endAngle = arcEndAngle,
|
||||
padAngle = arcPadAngle,
|
||||
context = null;
|
||||
|
||||
function arc() {
|
||||
var buffer,
|
||||
r,
|
||||
r0 = +innerRadius.apply(this, arguments),
|
||||
r1 = +outerRadius.apply(this, arguments),
|
||||
a0 = startAngle.apply(this, arguments) - halfPi,
|
||||
a1 = endAngle.apply(this, arguments) - halfPi,
|
||||
da = abs(a1 - a0),
|
||||
cw = a1 > a0;
|
||||
|
||||
if (!context) context = buffer = path();
|
||||
|
||||
// Ensure that the outer radius is always larger than the inner radius.
|
||||
if (r1 < r0) r = r1, r1 = r0, r0 = r;
|
||||
|
||||
// Is it a point?
|
||||
if (!(r1 > epsilon)) context.moveTo(0, 0);
|
||||
|
||||
// Or is it a circle or annulus?
|
||||
else if (da > tau - epsilon) {
|
||||
context.moveTo(r1 * cos(a0), r1 * sin(a0));
|
||||
context.arc(0, 0, r1, a0, a1, !cw);
|
||||
if (r0 > epsilon) {
|
||||
context.moveTo(r0 * cos(a1), r0 * sin(a1));
|
||||
context.arc(0, 0, r0, a1, a0, cw);
|
||||
}
|
||||
}
|
||||
|
||||
// Or is it a circular or annular sector?
|
||||
else {
|
||||
var a01 = a0,
|
||||
a11 = a1,
|
||||
a00 = a0,
|
||||
a10 = a1,
|
||||
da0 = da,
|
||||
da1 = da,
|
||||
ap = padAngle.apply(this, arguments) / 2,
|
||||
rp = (ap > epsilon) && (padRadius ? +padRadius.apply(this, arguments) : sqrt(r0 * r0 + r1 * r1)),
|
||||
rc = min(abs(r1 - r0) / 2, +cornerRadius.apply(this, arguments)),
|
||||
rc0 = rc,
|
||||
rc1 = rc,
|
||||
t0,
|
||||
t1;
|
||||
|
||||
// Apply padding? Note that since r1 ≥ r0, da1 ≥ da0.
|
||||
if (rp > epsilon) {
|
||||
var p0 = asin(rp / r0 * sin(ap)),
|
||||
p1 = asin(rp / r1 * sin(ap));
|
||||
if ((da0 -= p0 * 2) > epsilon) p0 *= (cw ? 1 : -1), a00 += p0, a10 -= p0;
|
||||
else da0 = 0, a00 = a10 = (a0 + a1) / 2;
|
||||
if ((da1 -= p1 * 2) > epsilon) p1 *= (cw ? 1 : -1), a01 += p1, a11 -= p1;
|
||||
else da1 = 0, a01 = a11 = (a0 + a1) / 2;
|
||||
}
|
||||
|
||||
var x01 = r1 * cos(a01),
|
||||
y01 = r1 * sin(a01),
|
||||
x10 = r0 * cos(a10),
|
||||
y10 = r0 * sin(a10);
|
||||
|
||||
// Apply rounded corners?
|
||||
if (rc > epsilon) {
|
||||
var x11 = r1 * cos(a11),
|
||||
y11 = r1 * sin(a11),
|
||||
x00 = r0 * cos(a00),
|
||||
y00 = r0 * sin(a00),
|
||||
oc;
|
||||
|
||||
// Restrict the corner radius according to the sector angle.
|
||||
if (da < pi && (oc = intersect(x01, y01, x00, y00, x11, y11, x10, y10))) {
|
||||
var ax = x01 - oc[0],
|
||||
ay = y01 - oc[1],
|
||||
bx = x11 - oc[0],
|
||||
by = y11 - oc[1],
|
||||
kc = 1 / sin(acos((ax * bx + ay * by) / (sqrt(ax * ax + ay * ay) * sqrt(bx * bx + by * by))) / 2),
|
||||
lc = sqrt(oc[0] * oc[0] + oc[1] * oc[1]);
|
||||
rc0 = min(rc, (r0 - lc) / (kc - 1));
|
||||
rc1 = min(rc, (r1 - lc) / (kc + 1));
|
||||
}
|
||||
}
|
||||
|
||||
// Is the sector collapsed to a line?
|
||||
if (!(da1 > epsilon)) context.moveTo(x01, y01);
|
||||
|
||||
// Does the sector’s outer ring have rounded corners?
|
||||
else if (rc1 > epsilon) {
|
||||
t0 = cornerTangents(x00, y00, x01, y01, r1, rc1, cw);
|
||||
t1 = cornerTangents(x11, y11, x10, y10, r1, rc1, cw);
|
||||
|
||||
context.moveTo(t0.cx + t0.x01, t0.cy + t0.y01);
|
||||
|
||||
// Have the corners merged?
|
||||
if (rc1 < rc) context.arc(t0.cx, t0.cy, rc1, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw);
|
||||
|
||||
// Otherwise, draw the two corners and the ring.
|
||||
else {
|
||||
context.arc(t0.cx, t0.cy, rc1, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw);
|
||||
context.arc(0, 0, r1, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), !cw);
|
||||
context.arc(t1.cx, t1.cy, rc1, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw);
|
||||
}
|
||||
}
|
||||
|
||||
// Or is the outer ring just a circular arc?
|
||||
else context.moveTo(x01, y01), context.arc(0, 0, r1, a01, a11, !cw);
|
||||
|
||||
// Is there no inner ring, and it’s a circular sector?
|
||||
// Or perhaps it’s an annular sector collapsed due to padding?
|
||||
if (!(r0 > epsilon) || !(da0 > epsilon)) context.lineTo(x10, y10);
|
||||
|
||||
// Does the sector’s inner ring (or point) have rounded corners?
|
||||
else if (rc0 > epsilon) {
|
||||
t0 = cornerTangents(x10, y10, x11, y11, r0, -rc0, cw);
|
||||
t1 = cornerTangents(x01, y01, x00, y00, r0, -rc0, cw);
|
||||
|
||||
context.lineTo(t0.cx + t0.x01, t0.cy + t0.y01);
|
||||
|
||||
// Have the corners merged?
|
||||
if (rc0 < rc) context.arc(t0.cx, t0.cy, rc0, atan2(t0.y01, t0.x01), atan2(t1.y01, t1.x01), !cw);
|
||||
|
||||
// Otherwise, draw the two corners and the ring.
|
||||
else {
|
||||
context.arc(t0.cx, t0.cy, rc0, atan2(t0.y01, t0.x01), atan2(t0.y11, t0.x11), !cw);
|
||||
context.arc(0, 0, r0, atan2(t0.cy + t0.y11, t0.cx + t0.x11), atan2(t1.cy + t1.y11, t1.cx + t1.x11), cw);
|
||||
context.arc(t1.cx, t1.cy, rc0, atan2(t1.y11, t1.x11), atan2(t1.y01, t1.x01), !cw);
|
||||
}
|
||||
}
|
||||
|
||||
// Or is the inner ring just a circular arc?
|
||||
else context.arc(0, 0, r0, a10, a00, cw);
|
||||
}
|
||||
|
||||
context.closePath();
|
||||
|
||||
if (buffer) return context = null, buffer + "" || null;
|
||||
}
|
||||
|
||||
arc.centroid = function() {
|
||||
var r = (+innerRadius.apply(this, arguments) + +outerRadius.apply(this, arguments)) / 2,
|
||||
a = (+startAngle.apply(this, arguments) + +endAngle.apply(this, arguments)) / 2 - pi / 2;
|
||||
return [cos(a) * r, sin(a) * r];
|
||||
};
|
||||
|
||||
arc.innerRadius = function(_) {
|
||||
return arguments.length ? (innerRadius = typeof _ === "function" ? _ : constant(+_), arc) : innerRadius;
|
||||
};
|
||||
|
||||
arc.outerRadius = function(_) {
|
||||
return arguments.length ? (outerRadius = typeof _ === "function" ? _ : constant(+_), arc) : outerRadius;
|
||||
};
|
||||
|
||||
arc.cornerRadius = function(_) {
|
||||
return arguments.length ? (cornerRadius = typeof _ === "function" ? _ : constant(+_), arc) : cornerRadius;
|
||||
};
|
||||
|
||||
arc.padRadius = function(_) {
|
||||
return arguments.length ? (padRadius = _ == null ? null : typeof _ === "function" ? _ : constant(+_), arc) : padRadius;
|
||||
};
|
||||
|
||||
arc.startAngle = function(_) {
|
||||
return arguments.length ? (startAngle = typeof _ === "function" ? _ : constant(+_), arc) : startAngle;
|
||||
};
|
||||
|
||||
arc.endAngle = function(_) {
|
||||
return arguments.length ? (endAngle = typeof _ === "function" ? _ : constant(+_), arc) : endAngle;
|
||||
};
|
||||
|
||||
arc.padAngle = function(_) {
|
||||
return arguments.length ? (padAngle = typeof _ === "function" ? _ : constant(+_), arc) : padAngle;
|
||||
};
|
||||
|
||||
arc.context = function(_) {
|
||||
return arguments.length ? ((context = _ == null ? null : _), arc) : context;
|
||||
};
|
||||
|
||||
return arc;
|
||||
}
|
||||
+109
@@ -0,0 +1,109 @@
|
||||
import {path} from "d3-path";
|
||||
import constant from "./constant.js";
|
||||
import curveLinear from "./curve/linear.js";
|
||||
import line from "./line.js";
|
||||
import {x as pointX, y as pointY} from "./point.js";
|
||||
|
||||
export default function() {
|
||||
var x0 = pointX,
|
||||
x1 = null,
|
||||
y0 = constant(0),
|
||||
y1 = pointY,
|
||||
defined = constant(true),
|
||||
context = null,
|
||||
curve = curveLinear,
|
||||
output = null;
|
||||
|
||||
function area(data) {
|
||||
var i,
|
||||
j,
|
||||
k,
|
||||
n = data.length,
|
||||
d,
|
||||
defined0 = false,
|
||||
buffer,
|
||||
x0z = new Array(n),
|
||||
y0z = new Array(n);
|
||||
|
||||
if (context == null) output = curve(buffer = path());
|
||||
|
||||
for (i = 0; i <= n; ++i) {
|
||||
if (!(i < n && defined(d = data[i], i, data)) === defined0) {
|
||||
if (defined0 = !defined0) {
|
||||
j = i;
|
||||
output.areaStart();
|
||||
output.lineStart();
|
||||
} else {
|
||||
output.lineEnd();
|
||||
output.lineStart();
|
||||
for (k = i - 1; k >= j; --k) {
|
||||
output.point(x0z[k], y0z[k]);
|
||||
}
|
||||
output.lineEnd();
|
||||
output.areaEnd();
|
||||
}
|
||||
}
|
||||
if (defined0) {
|
||||
x0z[i] = +x0(d, i, data), y0z[i] = +y0(d, i, data);
|
||||
output.point(x1 ? +x1(d, i, data) : x0z[i], y1 ? +y1(d, i, data) : y0z[i]);
|
||||
}
|
||||
}
|
||||
|
||||
if (buffer) return output = null, buffer + "" || null;
|
||||
}
|
||||
|
||||
function arealine() {
|
||||
return line().defined(defined).curve(curve).context(context);
|
||||
}
|
||||
|
||||
area.x = function(_) {
|
||||
return arguments.length ? (x0 = typeof _ === "function" ? _ : constant(+_), x1 = null, area) : x0;
|
||||
};
|
||||
|
||||
area.x0 = function(_) {
|
||||
return arguments.length ? (x0 = typeof _ === "function" ? _ : constant(+_), area) : x0;
|
||||
};
|
||||
|
||||
area.x1 = function(_) {
|
||||
return arguments.length ? (x1 = _ == null ? null : typeof _ === "function" ? _ : constant(+_), area) : x1;
|
||||
};
|
||||
|
||||
area.y = function(_) {
|
||||
return arguments.length ? (y0 = typeof _ === "function" ? _ : constant(+_), y1 = null, area) : y0;
|
||||
};
|
||||
|
||||
area.y0 = function(_) {
|
||||
return arguments.length ? (y0 = typeof _ === "function" ? _ : constant(+_), area) : y0;
|
||||
};
|
||||
|
||||
area.y1 = function(_) {
|
||||
return arguments.length ? (y1 = _ == null ? null : typeof _ === "function" ? _ : constant(+_), area) : y1;
|
||||
};
|
||||
|
||||
area.lineX0 =
|
||||
area.lineY0 = function() {
|
||||
return arealine().x(x0).y(y0);
|
||||
};
|
||||
|
||||
area.lineY1 = function() {
|
||||
return arealine().x(x0).y(y1);
|
||||
};
|
||||
|
||||
area.lineX1 = function() {
|
||||
return arealine().x(x1).y(y0);
|
||||
};
|
||||
|
||||
area.defined = function(_) {
|
||||
return arguments.length ? (defined = typeof _ === "function" ? _ : constant(!!_), area) : defined;
|
||||
};
|
||||
|
||||
area.curve = function(_) {
|
||||
return arguments.length ? (curve = _, context != null && (output = curve(context)), area) : curve;
|
||||
};
|
||||
|
||||
area.context = function(_) {
|
||||
return arguments.length ? (_ == null ? context = output = null : output = curve(context = _), area) : context;
|
||||
};
|
||||
|
||||
return area;
|
||||
}
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
import curveRadial, {curveRadialLinear} from "./curve/radial.js";
|
||||
import area from "./area.js";
|
||||
import {lineRadial} from "./lineRadial.js";
|
||||
|
||||
export default function() {
|
||||
var a = area().curve(curveRadialLinear),
|
||||
c = a.curve,
|
||||
x0 = a.lineX0,
|
||||
x1 = a.lineX1,
|
||||
y0 = a.lineY0,
|
||||
y1 = a.lineY1;
|
||||
|
||||
a.angle = a.x, delete a.x;
|
||||
a.startAngle = a.x0, delete a.x0;
|
||||
a.endAngle = a.x1, delete a.x1;
|
||||
a.radius = a.y, delete a.y;
|
||||
a.innerRadius = a.y0, delete a.y0;
|
||||
a.outerRadius = a.y1, delete a.y1;
|
||||
a.lineStartAngle = function() { return lineRadial(x0()); }, delete a.lineX0;
|
||||
a.lineEndAngle = function() { return lineRadial(x1()); }, delete a.lineX1;
|
||||
a.lineInnerRadius = function() { return lineRadial(y0()); }, delete a.lineY0;
|
||||
a.lineOuterRadius = function() { return lineRadial(y1()); }, delete a.lineY1;
|
||||
|
||||
a.curve = function(_) {
|
||||
return arguments.length ? c(curveRadial(_)) : c()._curve;
|
||||
};
|
||||
|
||||
return a;
|
||||
}
|
||||
+1
@@ -0,0 +1 @@
|
||||
export var slice = Array.prototype.slice;
|
||||
+5
@@ -0,0 +1,5 @@
|
||||
export default function(x) {
|
||||
return function constant() {
|
||||
return x;
|
||||
};
|
||||
}
|
||||
+51
@@ -0,0 +1,51 @@
|
||||
export function point(that, x, y) {
|
||||
that._context.bezierCurveTo(
|
||||
(2 * that._x0 + that._x1) / 3,
|
||||
(2 * that._y0 + that._y1) / 3,
|
||||
(that._x0 + 2 * that._x1) / 3,
|
||||
(that._y0 + 2 * that._y1) / 3,
|
||||
(that._x0 + 4 * that._x1 + x) / 6,
|
||||
(that._y0 + 4 * that._y1 + y) / 6
|
||||
);
|
||||
}
|
||||
|
||||
export function Basis(context) {
|
||||
this._context = context;
|
||||
}
|
||||
|
||||
Basis.prototype = {
|
||||
areaStart: function() {
|
||||
this._line = 0;
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._line = NaN;
|
||||
},
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 =
|
||||
this._y0 = this._y1 = NaN;
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
switch (this._point) {
|
||||
case 3: point(this, this._x1, this._y1); // proceed
|
||||
case 2: this._context.lineTo(this._x1, this._y1); break;
|
||||
}
|
||||
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
||||
this._line = 1 - this._line;
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;
|
||||
case 1: this._point = 2; break;
|
||||
case 2: this._point = 3; this._context.lineTo((5 * this._x0 + this._x1) / 6, (5 * this._y0 + this._y1) / 6); // proceed
|
||||
default: point(this, x, y); break;
|
||||
}
|
||||
this._x0 = this._x1, this._x1 = x;
|
||||
this._y0 = this._y1, this._y1 = y;
|
||||
}
|
||||
};
|
||||
|
||||
export default function(context) {
|
||||
return new Basis(context);
|
||||
}
|
||||
+52
@@ -0,0 +1,52 @@
|
||||
import noop from "../noop.js";
|
||||
import {point} from "./basis.js";
|
||||
|
||||
function BasisClosed(context) {
|
||||
this._context = context;
|
||||
}
|
||||
|
||||
BasisClosed.prototype = {
|
||||
areaStart: noop,
|
||||
areaEnd: noop,
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 =
|
||||
this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = NaN;
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
switch (this._point) {
|
||||
case 1: {
|
||||
this._context.moveTo(this._x2, this._y2);
|
||||
this._context.closePath();
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
this._context.moveTo((this._x2 + 2 * this._x3) / 3, (this._y2 + 2 * this._y3) / 3);
|
||||
this._context.lineTo((this._x3 + 2 * this._x2) / 3, (this._y3 + 2 * this._y2) / 3);
|
||||
this._context.closePath();
|
||||
break;
|
||||
}
|
||||
case 3: {
|
||||
this.point(this._x2, this._y2);
|
||||
this.point(this._x3, this._y3);
|
||||
this.point(this._x4, this._y4);
|
||||
break;
|
||||
}
|
||||
}
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; this._x2 = x, this._y2 = y; break;
|
||||
case 1: this._point = 2; this._x3 = x, this._y3 = y; break;
|
||||
case 2: this._point = 3; this._x4 = x, this._y4 = y; this._context.moveTo((this._x0 + 4 * this._x1 + x) / 6, (this._y0 + 4 * this._y1 + y) / 6); break;
|
||||
default: point(this, x, y); break;
|
||||
}
|
||||
this._x0 = this._x1, this._x1 = x;
|
||||
this._y0 = this._y1, this._y1 = y;
|
||||
}
|
||||
};
|
||||
|
||||
export default function(context) {
|
||||
return new BasisClosed(context);
|
||||
}
|
||||
+39
@@ -0,0 +1,39 @@
|
||||
import {point} from "./basis.js";
|
||||
|
||||
function BasisOpen(context) {
|
||||
this._context = context;
|
||||
}
|
||||
|
||||
BasisOpen.prototype = {
|
||||
areaStart: function() {
|
||||
this._line = 0;
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._line = NaN;
|
||||
},
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 =
|
||||
this._y0 = this._y1 = NaN;
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();
|
||||
this._line = 1 - this._line;
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; break;
|
||||
case 1: this._point = 2; break;
|
||||
case 2: this._point = 3; var x0 = (this._x0 + 4 * this._x1 + x) / 6, y0 = (this._y0 + 4 * this._y1 + y) / 6; this._line ? this._context.lineTo(x0, y0) : this._context.moveTo(x0, y0); break;
|
||||
case 3: this._point = 4; // proceed
|
||||
default: point(this, x, y); break;
|
||||
}
|
||||
this._x0 = this._x1, this._x1 = x;
|
||||
this._y0 = this._y1, this._y1 = y;
|
||||
}
|
||||
};
|
||||
|
||||
export default function(context) {
|
||||
return new BasisOpen(context);
|
||||
}
|
||||
+56
@@ -0,0 +1,56 @@
|
||||
import {Basis} from "./basis.js";
|
||||
|
||||
function Bundle(context, beta) {
|
||||
this._basis = new Basis(context);
|
||||
this._beta = beta;
|
||||
}
|
||||
|
||||
Bundle.prototype = {
|
||||
lineStart: function() {
|
||||
this._x = [];
|
||||
this._y = [];
|
||||
this._basis.lineStart();
|
||||
},
|
||||
lineEnd: function() {
|
||||
var x = this._x,
|
||||
y = this._y,
|
||||
j = x.length - 1;
|
||||
|
||||
if (j > 0) {
|
||||
var x0 = x[0],
|
||||
y0 = y[0],
|
||||
dx = x[j] - x0,
|
||||
dy = y[j] - y0,
|
||||
i = -1,
|
||||
t;
|
||||
|
||||
while (++i <= j) {
|
||||
t = i / j;
|
||||
this._basis.point(
|
||||
this._beta * x[i] + (1 - this._beta) * (x0 + t * dx),
|
||||
this._beta * y[i] + (1 - this._beta) * (y0 + t * dy)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
this._x = this._y = null;
|
||||
this._basis.lineEnd();
|
||||
},
|
||||
point: function(x, y) {
|
||||
this._x.push(+x);
|
||||
this._y.push(+y);
|
||||
}
|
||||
};
|
||||
|
||||
export default (function custom(beta) {
|
||||
|
||||
function bundle(context) {
|
||||
return beta === 1 ? new Basis(context) : new Bundle(context, beta);
|
||||
}
|
||||
|
||||
bundle.beta = function(beta) {
|
||||
return custom(+beta);
|
||||
};
|
||||
|
||||
return bundle;
|
||||
})(0.85);
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
export function point(that, x, y) {
|
||||
that._context.bezierCurveTo(
|
||||
that._x1 + that._k * (that._x2 - that._x0),
|
||||
that._y1 + that._k * (that._y2 - that._y0),
|
||||
that._x2 + that._k * (that._x1 - x),
|
||||
that._y2 + that._k * (that._y1 - y),
|
||||
that._x2,
|
||||
that._y2
|
||||
);
|
||||
}
|
||||
|
||||
export function Cardinal(context, tension) {
|
||||
this._context = context;
|
||||
this._k = (1 - tension) / 6;
|
||||
}
|
||||
|
||||
Cardinal.prototype = {
|
||||
areaStart: function() {
|
||||
this._line = 0;
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._line = NaN;
|
||||
},
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 = this._x2 =
|
||||
this._y0 = this._y1 = this._y2 = NaN;
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
switch (this._point) {
|
||||
case 2: this._context.lineTo(this._x2, this._y2); break;
|
||||
case 3: point(this, this._x1, this._y1); break;
|
||||
}
|
||||
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
||||
this._line = 1 - this._line;
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;
|
||||
case 1: this._point = 2; this._x1 = x, this._y1 = y; break;
|
||||
case 2: this._point = 3; // proceed
|
||||
default: point(this, x, y); break;
|
||||
}
|
||||
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
||||
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
||||
}
|
||||
};
|
||||
|
||||
export default (function custom(tension) {
|
||||
|
||||
function cardinal(context) {
|
||||
return new Cardinal(context, tension);
|
||||
}
|
||||
|
||||
cardinal.tension = function(tension) {
|
||||
return custom(+tension);
|
||||
};
|
||||
|
||||
return cardinal;
|
||||
})(0);
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
import noop from "../noop.js";
|
||||
import {point} from "./cardinal.js";
|
||||
|
||||
export function CardinalClosed(context, tension) {
|
||||
this._context = context;
|
||||
this._k = (1 - tension) / 6;
|
||||
}
|
||||
|
||||
CardinalClosed.prototype = {
|
||||
areaStart: noop,
|
||||
areaEnd: noop,
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =
|
||||
this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
switch (this._point) {
|
||||
case 1: {
|
||||
this._context.moveTo(this._x3, this._y3);
|
||||
this._context.closePath();
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
this._context.lineTo(this._x3, this._y3);
|
||||
this._context.closePath();
|
||||
break;
|
||||
}
|
||||
case 3: {
|
||||
this.point(this._x3, this._y3);
|
||||
this.point(this._x4, this._y4);
|
||||
this.point(this._x5, this._y5);
|
||||
break;
|
||||
}
|
||||
}
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; this._x3 = x, this._y3 = y; break;
|
||||
case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;
|
||||
case 2: this._point = 3; this._x5 = x, this._y5 = y; break;
|
||||
default: point(this, x, y); break;
|
||||
}
|
||||
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
||||
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
||||
}
|
||||
};
|
||||
|
||||
export default (function custom(tension) {
|
||||
|
||||
function cardinal(context) {
|
||||
return new CardinalClosed(context, tension);
|
||||
}
|
||||
|
||||
cardinal.tension = function(tension) {
|
||||
return custom(+tension);
|
||||
};
|
||||
|
||||
return cardinal;
|
||||
})(0);
|
||||
+49
@@ -0,0 +1,49 @@
|
||||
import {point} from "./cardinal.js";
|
||||
|
||||
export function CardinalOpen(context, tension) {
|
||||
this._context = context;
|
||||
this._k = (1 - tension) / 6;
|
||||
}
|
||||
|
||||
CardinalOpen.prototype = {
|
||||
areaStart: function() {
|
||||
this._line = 0;
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._line = NaN;
|
||||
},
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 = this._x2 =
|
||||
this._y0 = this._y1 = this._y2 = NaN;
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();
|
||||
this._line = 1 - this._line;
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; break;
|
||||
case 1: this._point = 2; break;
|
||||
case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;
|
||||
case 3: this._point = 4; // proceed
|
||||
default: point(this, x, y); break;
|
||||
}
|
||||
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
||||
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
||||
}
|
||||
};
|
||||
|
||||
export default (function custom(tension) {
|
||||
|
||||
function cardinal(context) {
|
||||
return new CardinalOpen(context, tension);
|
||||
}
|
||||
|
||||
cardinal.tension = function(tension) {
|
||||
return custom(+tension);
|
||||
};
|
||||
|
||||
return cardinal;
|
||||
})(0);
|
||||
+88
@@ -0,0 +1,88 @@
|
||||
import {epsilon} from "../math.js";
|
||||
import {Cardinal} from "./cardinal.js";
|
||||
|
||||
export function point(that, x, y) {
|
||||
var x1 = that._x1,
|
||||
y1 = that._y1,
|
||||
x2 = that._x2,
|
||||
y2 = that._y2;
|
||||
|
||||
if (that._l01_a > epsilon) {
|
||||
var a = 2 * that._l01_2a + 3 * that._l01_a * that._l12_a + that._l12_2a,
|
||||
n = 3 * that._l01_a * (that._l01_a + that._l12_a);
|
||||
x1 = (x1 * a - that._x0 * that._l12_2a + that._x2 * that._l01_2a) / n;
|
||||
y1 = (y1 * a - that._y0 * that._l12_2a + that._y2 * that._l01_2a) / n;
|
||||
}
|
||||
|
||||
if (that._l23_a > epsilon) {
|
||||
var b = 2 * that._l23_2a + 3 * that._l23_a * that._l12_a + that._l12_2a,
|
||||
m = 3 * that._l23_a * (that._l23_a + that._l12_a);
|
||||
x2 = (x2 * b + that._x1 * that._l23_2a - x * that._l12_2a) / m;
|
||||
y2 = (y2 * b + that._y1 * that._l23_2a - y * that._l12_2a) / m;
|
||||
}
|
||||
|
||||
that._context.bezierCurveTo(x1, y1, x2, y2, that._x2, that._y2);
|
||||
}
|
||||
|
||||
function CatmullRom(context, alpha) {
|
||||
this._context = context;
|
||||
this._alpha = alpha;
|
||||
}
|
||||
|
||||
CatmullRom.prototype = {
|
||||
areaStart: function() {
|
||||
this._line = 0;
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._line = NaN;
|
||||
},
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 = this._x2 =
|
||||
this._y0 = this._y1 = this._y2 = NaN;
|
||||
this._l01_a = this._l12_a = this._l23_a =
|
||||
this._l01_2a = this._l12_2a = this._l23_2a =
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
switch (this._point) {
|
||||
case 2: this._context.lineTo(this._x2, this._y2); break;
|
||||
case 3: this.point(this._x2, this._y2); break;
|
||||
}
|
||||
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
||||
this._line = 1 - this._line;
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
|
||||
if (this._point) {
|
||||
var x23 = this._x2 - x,
|
||||
y23 = this._y2 - y;
|
||||
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
|
||||
}
|
||||
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;
|
||||
case 1: this._point = 2; break;
|
||||
case 2: this._point = 3; // proceed
|
||||
default: point(this, x, y); break;
|
||||
}
|
||||
|
||||
this._l01_a = this._l12_a, this._l12_a = this._l23_a;
|
||||
this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
|
||||
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
||||
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
||||
}
|
||||
};
|
||||
|
||||
export default (function custom(alpha) {
|
||||
|
||||
function catmullRom(context) {
|
||||
return alpha ? new CatmullRom(context, alpha) : new Cardinal(context, 0);
|
||||
}
|
||||
|
||||
catmullRom.alpha = function(alpha) {
|
||||
return custom(+alpha);
|
||||
};
|
||||
|
||||
return catmullRom;
|
||||
})(0.5);
|
||||
Generated
Vendored
+74
@@ -0,0 +1,74 @@
|
||||
import {CardinalClosed} from "./cardinalClosed.js";
|
||||
import noop from "../noop.js";
|
||||
import {point} from "./catmullRom.js";
|
||||
|
||||
function CatmullRomClosed(context, alpha) {
|
||||
this._context = context;
|
||||
this._alpha = alpha;
|
||||
}
|
||||
|
||||
CatmullRomClosed.prototype = {
|
||||
areaStart: noop,
|
||||
areaEnd: noop,
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 = this._x2 = this._x3 = this._x4 = this._x5 =
|
||||
this._y0 = this._y1 = this._y2 = this._y3 = this._y4 = this._y5 = NaN;
|
||||
this._l01_a = this._l12_a = this._l23_a =
|
||||
this._l01_2a = this._l12_2a = this._l23_2a =
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
switch (this._point) {
|
||||
case 1: {
|
||||
this._context.moveTo(this._x3, this._y3);
|
||||
this._context.closePath();
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
this._context.lineTo(this._x3, this._y3);
|
||||
this._context.closePath();
|
||||
break;
|
||||
}
|
||||
case 3: {
|
||||
this.point(this._x3, this._y3);
|
||||
this.point(this._x4, this._y4);
|
||||
this.point(this._x5, this._y5);
|
||||
break;
|
||||
}
|
||||
}
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
|
||||
if (this._point) {
|
||||
var x23 = this._x2 - x,
|
||||
y23 = this._y2 - y;
|
||||
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
|
||||
}
|
||||
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; this._x3 = x, this._y3 = y; break;
|
||||
case 1: this._point = 2; this._context.moveTo(this._x4 = x, this._y4 = y); break;
|
||||
case 2: this._point = 3; this._x5 = x, this._y5 = y; break;
|
||||
default: point(this, x, y); break;
|
||||
}
|
||||
|
||||
this._l01_a = this._l12_a, this._l12_a = this._l23_a;
|
||||
this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
|
||||
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
||||
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
||||
}
|
||||
};
|
||||
|
||||
export default (function custom(alpha) {
|
||||
|
||||
function catmullRom(context) {
|
||||
return alpha ? new CatmullRomClosed(context, alpha) : new CardinalClosed(context, 0);
|
||||
}
|
||||
|
||||
catmullRom.alpha = function(alpha) {
|
||||
return custom(+alpha);
|
||||
};
|
||||
|
||||
return catmullRom;
|
||||
})(0.5);
|
||||
+62
@@ -0,0 +1,62 @@
|
||||
import {CardinalOpen} from "./cardinalOpen.js";
|
||||
import {point} from "./catmullRom.js";
|
||||
|
||||
function CatmullRomOpen(context, alpha) {
|
||||
this._context = context;
|
||||
this._alpha = alpha;
|
||||
}
|
||||
|
||||
CatmullRomOpen.prototype = {
|
||||
areaStart: function() {
|
||||
this._line = 0;
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._line = NaN;
|
||||
},
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 = this._x2 =
|
||||
this._y0 = this._y1 = this._y2 = NaN;
|
||||
this._l01_a = this._l12_a = this._l23_a =
|
||||
this._l01_2a = this._l12_2a = this._l23_2a =
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
if (this._line || (this._line !== 0 && this._point === 3)) this._context.closePath();
|
||||
this._line = 1 - this._line;
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
|
||||
if (this._point) {
|
||||
var x23 = this._x2 - x,
|
||||
y23 = this._y2 - y;
|
||||
this._l23_a = Math.sqrt(this._l23_2a = Math.pow(x23 * x23 + y23 * y23, this._alpha));
|
||||
}
|
||||
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; break;
|
||||
case 1: this._point = 2; break;
|
||||
case 2: this._point = 3; this._line ? this._context.lineTo(this._x2, this._y2) : this._context.moveTo(this._x2, this._y2); break;
|
||||
case 3: this._point = 4; // proceed
|
||||
default: point(this, x, y); break;
|
||||
}
|
||||
|
||||
this._l01_a = this._l12_a, this._l12_a = this._l23_a;
|
||||
this._l01_2a = this._l12_2a, this._l12_2a = this._l23_2a;
|
||||
this._x0 = this._x1, this._x1 = this._x2, this._x2 = x;
|
||||
this._y0 = this._y1, this._y1 = this._y2, this._y2 = y;
|
||||
}
|
||||
};
|
||||
|
||||
export default (function custom(alpha) {
|
||||
|
||||
function catmullRom(context) {
|
||||
return alpha ? new CatmullRomOpen(context, alpha) : new CardinalOpen(context, 0);
|
||||
}
|
||||
|
||||
catmullRom.alpha = function(alpha) {
|
||||
return custom(+alpha);
|
||||
};
|
||||
|
||||
return catmullRom;
|
||||
})(0.5);
|
||||
+31
@@ -0,0 +1,31 @@
|
||||
function Linear(context) {
|
||||
this._context = context;
|
||||
}
|
||||
|
||||
Linear.prototype = {
|
||||
areaStart: function() {
|
||||
this._line = 0;
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._line = NaN;
|
||||
},
|
||||
lineStart: function() {
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
||||
this._line = 1 - this._line;
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;
|
||||
case 1: this._point = 2; // proceed
|
||||
default: this._context.lineTo(x, y); break;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
export default function(context) {
|
||||
return new Linear(context);
|
||||
}
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
import noop from "../noop.js";
|
||||
|
||||
function LinearClosed(context) {
|
||||
this._context = context;
|
||||
}
|
||||
|
||||
LinearClosed.prototype = {
|
||||
areaStart: noop,
|
||||
areaEnd: noop,
|
||||
lineStart: function() {
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
if (this._point) this._context.closePath();
|
||||
},
|
||||
point: function(x, y) {
|
||||
x = +x, y = +y;
|
||||
if (this._point) this._context.lineTo(x, y);
|
||||
else this._point = 1, this._context.moveTo(x, y);
|
||||
}
|
||||
};
|
||||
|
||||
export default function(context) {
|
||||
return new LinearClosed(context);
|
||||
}
|
||||
+104
@@ -0,0 +1,104 @@
|
||||
function sign(x) {
|
||||
return x < 0 ? -1 : 1;
|
||||
}
|
||||
|
||||
// Calculate the slopes of the tangents (Hermite-type interpolation) based on
|
||||
// the following paper: Steffen, M. 1990. A Simple Method for Monotonic
|
||||
// Interpolation in One Dimension. Astronomy and Astrophysics, Vol. 239, NO.
|
||||
// NOV(II), P. 443, 1990.
|
||||
function slope3(that, x2, y2) {
|
||||
var h0 = that._x1 - that._x0,
|
||||
h1 = x2 - that._x1,
|
||||
s0 = (that._y1 - that._y0) / (h0 || h1 < 0 && -0),
|
||||
s1 = (y2 - that._y1) / (h1 || h0 < 0 && -0),
|
||||
p = (s0 * h1 + s1 * h0) / (h0 + h1);
|
||||
return (sign(s0) + sign(s1)) * Math.min(Math.abs(s0), Math.abs(s1), 0.5 * Math.abs(p)) || 0;
|
||||
}
|
||||
|
||||
// Calculate a one-sided slope.
|
||||
function slope2(that, t) {
|
||||
var h = that._x1 - that._x0;
|
||||
return h ? (3 * (that._y1 - that._y0) / h - t) / 2 : t;
|
||||
}
|
||||
|
||||
// According to https://en.wikipedia.org/wiki/Cubic_Hermite_spline#Representations
|
||||
// "you can express cubic Hermite interpolation in terms of cubic Bézier curves
|
||||
// with respect to the four values p0, p0 + m0 / 3, p1 - m1 / 3, p1".
|
||||
function point(that, t0, t1) {
|
||||
var x0 = that._x0,
|
||||
y0 = that._y0,
|
||||
x1 = that._x1,
|
||||
y1 = that._y1,
|
||||
dx = (x1 - x0) / 3;
|
||||
that._context.bezierCurveTo(x0 + dx, y0 + dx * t0, x1 - dx, y1 - dx * t1, x1, y1);
|
||||
}
|
||||
|
||||
function MonotoneX(context) {
|
||||
this._context = context;
|
||||
}
|
||||
|
||||
MonotoneX.prototype = {
|
||||
areaStart: function() {
|
||||
this._line = 0;
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._line = NaN;
|
||||
},
|
||||
lineStart: function() {
|
||||
this._x0 = this._x1 =
|
||||
this._y0 = this._y1 =
|
||||
this._t0 = NaN;
|
||||
this._point = 0;
|
||||
},
|
||||
lineEnd: function() {
|
||||
switch (this._point) {
|
||||
case 2: this._context.lineTo(this._x1, this._y1); break;
|
||||
case 3: point(this, this._t0, slope2(this, this._t0)); break;
|
||||
}
|
||||
if (this._line || (this._line !== 0 && this._point === 1)) this._context.closePath();
|
||||
this._line = 1 - this._line;
|
||||
},
|
||||
point: function(x, y) {
|
||||
var t1 = NaN;
|
||||
|
||||
x = +x, y = +y;
|
||||
if (x === this._x1 && y === this._y1) return; // Ignore coincident points.
|
||||
switch (this._point) {
|
||||
case 0: this._point = 1; this._line ? this._context.lineTo(x, y) : this._context.moveTo(x, y); break;
|
||||
case 1: this._point = 2; break;
|
||||
case 2: this._point = 3; point(this, slope2(this, t1 = slope3(this, x, y)), t1); break;
|
||||
default: point(this, this._t0, t1 = slope3(this, x, y)); break;
|
||||
}
|
||||
|
||||
this._x0 = this._x1, this._x1 = x;
|
||||
this._y0 = this._y1, this._y1 = y;
|
||||
this._t0 = t1;
|
||||
}
|
||||
}
|
||||
|
||||
function MonotoneY(context) {
|
||||
this._context = new ReflectContext(context);
|
||||
}
|
||||
|
||||
(MonotoneY.prototype = Object.create(MonotoneX.prototype)).point = function(x, y) {
|
||||
MonotoneX.prototype.point.call(this, y, x);
|
||||
};
|
||||
|
||||
function ReflectContext(context) {
|
||||
this._context = context;
|
||||
}
|
||||
|
||||
ReflectContext.prototype = {
|
||||
moveTo: function(x, y) { this._context.moveTo(y, x); },
|
||||
closePath: function() { this._context.closePath(); },
|
||||
lineTo: function(x, y) { this._context.lineTo(y, x); },
|
||||
bezierCurveTo: function(x1, y1, x2, y2, x, y) { this._context.bezierCurveTo(y1, x1, y2, x2, y, x); }
|
||||
};
|
||||
|
||||
export function monotoneX(context) {
|
||||
return new MonotoneX(context);
|
||||
}
|
||||
|
||||
export function monotoneY(context) {
|
||||
return new MonotoneY(context);
|
||||
}
|
||||
+65
@@ -0,0 +1,65 @@
|
||||
function Natural(context) {
|
||||
this._context = context;
|
||||
}
|
||||
|
||||
Natural.prototype = {
|
||||
areaStart: function() {
|
||||
this._line = 0;
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._line = NaN;
|
||||
},
|
||||
lineStart: function() {
|
||||
this._x = [];
|
||||
this._y = [];
|
||||
},
|
||||
lineEnd: function() {
|
||||
var x = this._x,
|
||||
y = this._y,
|
||||
n = x.length;
|
||||
|
||||
if (n) {
|
||||
this._line ? this._context.lineTo(x[0], y[0]) : this._context.moveTo(x[0], y[0]);
|
||||
if (n === 2) {
|
||||
this._context.lineTo(x[1], y[1]);
|
||||
} else {
|
||||
var px = controlPoints(x),
|
||||
py = controlPoints(y);
|
||||
for (var i0 = 0, i1 = 1; i1 < n; ++i0, ++i1) {
|
||||
this._context.bezierCurveTo(px[0][i0], py[0][i0], px[1][i0], py[1][i0], x[i1], y[i1]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (this._line || (this._line !== 0 && n === 1)) this._context.closePath();
|
||||
this._line = 1 - this._line;
|
||||
this._x = this._y = null;
|
||||
},
|
||||
point: function(x, y) {
|
||||
this._x.push(+x);
|
||||
this._y.push(+y);
|
||||
}
|
||||
};
|
||||
|
||||
// See https://www.particleincell.com/2012/bezier-splines/ for derivation.
|
||||
function controlPoints(x) {
|
||||
var i,
|
||||
n = x.length - 1,
|
||||
m,
|
||||
a = new Array(n),
|
||||
b = new Array(n),
|
||||
r = new Array(n);
|
||||
a[0] = 0, b[0] = 2, r[0] = x[0] + 2 * x[1];
|
||||
for (i = 1; i < n - 1; ++i) a[i] = 1, b[i] = 4, r[i] = 4 * x[i] + 2 * x[i + 1];
|
||||
a[n - 1] = 2, b[n - 1] = 7, r[n - 1] = 8 * x[n - 1] + x[n];
|
||||
for (i = 1; i < n; ++i) m = a[i] / b[i - 1], b[i] -= m, r[i] -= m * r[i - 1];
|
||||
a[n - 1] = r[n - 1] / b[n - 1];
|
||||
for (i = n - 2; i >= 0; --i) a[i] = (r[i] - a[i + 1]) / b[i];
|
||||
b[n - 1] = (x[n] + a[n - 1]) / 2;
|
||||
for (i = 0; i < n - 1; ++i) b[i] = 2 * x[i + 1] - a[i + 1];
|
||||
return [a, b];
|
||||
}
|
||||
|
||||
export default function(context) {
|
||||
return new Natural(context);
|
||||
}
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
import curveLinear from "./linear.js";
|
||||
|
||||
export var curveRadialLinear = curveRadial(curveLinear);
|
||||
|
||||
function Radial(curve) {
|
||||
this._curve = curve;
|
||||
}
|
||||
|
||||
Radial.prototype = {
|
||||
areaStart: function() {
|
||||
this._curve.areaStart();
|
||||
},
|
||||
areaEnd: function() {
|
||||
this._curve.areaEnd();
|
||||
},
|
||||
lineStart: function() {
|
||||
this._curve.lineStart();
|
||||
},
|
||||
lineEnd: function() {
|
||||
this._curve.lineEnd();
|
||||
},
|
||||
point: function(a, r) {
|
||||
this._curve.point(r * Math.sin(a), r * -Math.cos(a));
|
||||
}
|
||||
};
|
||||
|
||||
export default function curveRadial(curve) {
|
||||
|
||||
function radial(context) {
|
||||
return new Radial(curve(context));
|
||||
}
|
||||
|
||||
radial._curve = curve;
|
||||
|
||||
return radial;
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user