pax_global_header00006660000000000000000000000064125653247260014526gustar00rootroot0000000000000052 comment=ec87d894e4ff9dac54b60c5643ae36b470d589ac science.js-1.9.3/000077500000000000000000000000001256532472600135645ustar00rootroot00000000000000science.js-1.9.3/.gitignore000066400000000000000000000000151256532472600155500ustar00rootroot00000000000000node_modules science.js-1.9.3/LICENSE000066400000000000000000000026251256532472600145760ustar00rootroot00000000000000Copyright (c) 2011, Jason Davies 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. * The name Jason Davies may not 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 JASON DAVIES 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. science.js-1.9.3/Makefile000066400000000000000000000030611256532472600152240ustar00rootroot00000000000000NODE_PATH ?= ./node_modules JS_COMPILER = $(NODE_PATH)/uglify-js/bin/uglifyjs JS_TESTER = $(NODE_PATH)/vows/bin/vows all: \ science.v1.js \ science.v1.min.js \ package.json .INTERMEDIATE science.v1.js: \ science.core.js \ science.lin.js \ science.stats.js \ Makefile science.core.js: \ src/core/core.js \ src/core/ascending.js \ src/core/constants.js \ src/core/expm1.js \ src/core/functor.js \ src/core/hypot.js \ src/core/quadratic.js \ src/core/zeroes.js science.lin.js: \ src/lin/lin.js \ src/lin/decompose.js \ src/lin/cross.js \ src/lin/dot.js \ src/lin/length.js \ src/lin/normalize.js \ src/lin/determinant.js \ src/lin/gaussjordan.js \ src/lin/inverse.js \ src/lin/multiply.js \ src/lin/transpose.js \ src/lin/tridag.js science.stats.js: \ src/stats/stats.js \ src/stats/bandwidth.js \ src/stats/distance.js \ src/stats/erf.js \ src/stats/phi.js \ src/stats/kernel.js \ src/stats/kde.js \ src/stats/kmeans.js \ src/stats/hcluster.js \ src/stats/iqr.js \ src/stats/loess.js \ src/stats/mean.js \ src/stats/median.js \ src/stats/mode.js \ src/stats/quantiles.js \ src/stats/variance.js \ src/stats/distribution.js \ src/stats/distribution/gaussian.js test: all @$(JS_TESTER) %.min.js: %.js Makefile @rm -f $@ $(JS_COMPILER) < $< > $@ %.js: @rm -f $@ @echo '(function(exports){' > $@ cat $(filter %.js,$^) >> $@ @echo '})(this);' >> $@ @chmod a-w $@ install: mkdir -p node_modules npm install package.json: src/package.js @rm -f $@ node src/package.js > $@ @chmod a-w $@ clean: rm -f science*.js package.json science.js-1.9.3/README.md000066400000000000000000000016211256532472600150430ustar00rootroot00000000000000# Science.js Science.js is a JavaScript library for scientific and statistical computing. Currently, there are two modules: * `science.stats`, containing various implementations of statistical methods similar to those provided by [R](http://www.r-project.org/); * `science.lin`, for linear algebra. ## Development To help develop Science.js, you need to have [Node.js](http://www.nodejs.org) and [NPM](http://www.npmjs.org) installed. Once you have done that, run the following from the root directory of this repository to install the development dependencies: make install ## Thanks I originally started this in order to add a reusable statistics module to [D3.js](http://mbostock.github.com/d3/), but now it's grown into a whole new project of its own! The project structure and Makefile is based on that of D3, so a big thank you goes to [Mike Bostock](http://bost.ocks.org/mike/) for this. science.js-1.9.3/examples/000077500000000000000000000000001256532472600154025ustar00rootroot00000000000000science.js-1.9.3/examples/kde/000077500000000000000000000000001256532472600161455ustar00rootroot00000000000000science.js-1.9.3/examples/kde/faithful.json000066400000000000000000000021171256532472600206430ustar00rootroot00000000000000[ 79, 54, 74, 62, 85, 55, 88, 85, 51, 85, 54, 84, 78, 47, 83, 52, 62, 84, 52, 79, 51, 47, 78, 69, 74, 83, 55, 76, 78, 79, 73, 77, 66, 80, 74, 52, 48, 80, 59, 90, 80, 58, 84, 58, 73, 83, 64, 53, 82, 59, 75, 90, 54, 80, 54, 83, 71, 64, 77, 81, 59, 84, 48, 82, 60, 92, 78, 78, 65, 73, 82, 56, 79, 71, 62, 76, 60, 78, 76, 83, 75, 82, 70, 65, 73, 88, 76, 80, 48, 86, 60, 90, 50, 78, 63, 72, 84, 75, 51, 82, 62, 88, 49, 83, 81, 47, 84, 52, 86, 81, 75, 59, 89, 79, 59, 81, 50, 85, 59, 87, 53, 69, 77, 56, 88, 81, 45, 82, 55, 90, 45, 83, 56, 89, 46, 82, 51, 86, 53, 79, 81, 60, 82, 77, 76, 59, 80, 49, 96, 53, 77, 77, 65, 81, 71, 70, 81, 93, 53, 89, 45, 86, 58, 78, 66, 76, 63, 88, 52, 93, 49, 57, 77, 68, 81, 81, 73, 50, 85, 74, 55, 77, 83, 83, 51, 78, 84, 46, 83, 55, 81, 57, 76, 84, 77, 81, 87, 77, 51, 78, 60, 82, 91, 53, 78, 46, 77, 84, 49, 83, 71, 80, 49, 75, 64, 76, 53, 94, 55, 76, 50, 82, 54, 75, 78, 79, 78, 78, 70, 79, 70, 54, 86, 50, 90, 54, 54, 77, 79, 64, 75, 47, 86, 63, 85, 82, 57, 82, 67, 74, 54, 83, 73, 73, 88, 80, 71, 83, 56, 79, 78, 84, 58, 83, 43, 60, 75, 81, 46, 90, 46, 74 ] science.js-1.9.3/examples/kde/kde.css000066400000000000000000000001411256532472600174160ustar00rootroot00000000000000body { font: 10px sans-serif; } path { stroke: #000; stroke-width: 1.5px; fill: none; } science.js-1.9.3/examples/kde/kde.html000066400000000000000000000007021256532472600175750ustar00rootroot00000000000000 Kernel Density Estimation science.js-1.9.3/examples/kde/kde.js000066400000000000000000000023711256532472600172510ustar00rootroot00000000000000// Based on http://bl.ocks.org/900762 by John Firebaugh d3.json("faithful.json", function(faithful) { data = faithful; var w = 800, h = 400, x = d3.scale.linear().domain([30, 110]).range([0, w]); bins = d3.layout.histogram().frequency(false).bins(x.ticks(60))(data), max = d3.max(bins, function(d) { return d.y; }), y = d3.scale.linear().domain([0, .1]).range([0, h]), kde = science.stats.kde().sample(data); var vis = d3.select("body") .append("svg") .attr("width", w) .attr("height", h); var bars = vis.selectAll("g.bar") .data(bins) .enter().append("g") .attr("class", "bar") .attr("transform", function(d, i) { return "translate(" + x(d.x) + "," + (h - y(d.y)) + ")"; }); bars.append("rect") .attr("fill", "steelblue") .attr("width", function(d) { return x(d.dx + 30) - 1; }) .attr("height", function(d) { return y(d.y); }); var line = d3.svg.line() .x(function(d) { return x(d[0]); }) .y(function(d) { return h - y(d[1]); }); vis.selectAll("path") .data(d3.values(science.stats.bandwidth)) .enter().append("path") .attr("d", function(h) { return line(kde.bandwidth(h)(d3.range(30, 110, .1))); }); }); science.js-1.9.3/examples/loess/000077500000000000000000000000001256532472600165275ustar00rootroot00000000000000science.js-1.9.3/examples/loess/loess.html000066400000000000000000000010721256532472600205420ustar00rootroot00000000000000 LOESS
science.js-1.9.3/examples/loess/loess.js000066400000000000000000000024731256532472600202200ustar00rootroot00000000000000var w = 960, h = 500, p = 35.5, n = 100, x = d3.scale.linear().range([0, w]), y = d3.scale.linear().domain([-1.5, 1.5]).range([h, 0]); var xAxis = d3.svg.axis().scale(x), yAxis = d3.svg.axis().scale(y); var vis = d3.select("#vis") .data([{ x: d3.range(n).map(function(i) { return i / n; }), y: d3.range(n).map(function(i) { return Math.sin(4 * i * Math.PI / n) + (Math.random() - .5) / 5; }) }]) .append("svg") .attr("width", w + p + p) .attr("height", h + p + p) .append("g") .attr("transform", "translate(" + p + "," + p + ")"); var loess = science.stats.loess().bandwidth(.2), line = d3.svg.line() .x(function(d) { return x(d[0]); }) .y(function(d) { return y(d[1]); }); vis.selectAll("circle") .data(function(d) { return d3.zip(d.x, d.y); }) .enter().append("circle") .attr("cx", function(d) { return x(d[0]); }) .attr("cy", function(d) { return y(d[1]); }) .attr("r", 3); vis.selectAll("path") .data(function(d) { return [d3.zip(d.x, loess(d.x, d.y))]; }) .enter().append("path") .attr("d", line); vis.append("g") .attr("class", "bottom axis") .attr("transform", "translate(0," + h + ")") .call(xAxis.orient("bottom")); vis.append("g") .attr("class", "left axis") .call(yAxis.orient("left")); science.js-1.9.3/index.js000066400000000000000000000000641256532472600152310ustar00rootroot00000000000000require("./science.v1"); module.exports = science; science.js-1.9.3/lib/000077500000000000000000000000001256532472600143325ustar00rootroot00000000000000science.js-1.9.3/lib/commons-math/000077500000000000000000000000001256532472600167345ustar00rootroot00000000000000science.js-1.9.3/lib/commons-math/LICENSE.txt000066400000000000000000000456331256532472600205720ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright [yyyy] [name of copyright owner] Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. APACHE COMMONS MATH DERIVATIVE WORKS: The Apache commons-math library includes a number of subcomponents whose implementation is derived from original sources written in C or Fortran. License terms of the original sources are reproduced below. =============================================================================== For the lmder, lmpar and qrsolv Fortran routine from minpack and translated in the LevenbergMarquardtOptimizer class in package org.apache.commons.math.optimization.general Original source copyright and license statement: Minpack Copyright Notice (1999) University of Chicago. All rights reserved Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. 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. 3. The end-user documentation included with the redistribution, if any, must include the following acknowledgment: "This product includes software developed by the University of Chicago, as Operator of Argonne National Laboratory. Alternately, this acknowledgment may appear in the software itself, if and wherever such third-party acknowledgments normally appear. 4. WARRANTY DISCLAIMER. THE SOFTWARE IS SUPPLIED "AS IS" WITHOUT WARRANTY OF ANY KIND. THE COPYRIGHT HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, AND THEIR EMPLOYEES: (1) DISCLAIM ANY WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR NON-INFRINGEMENT, (2) DO NOT ASSUME ANY LEGAL LIABILITY OR RESPONSIBILITY FOR THE ACCURACY, COMPLETENESS, OR USEFULNESS OF THE SOFTWARE, (3) DO NOT REPRESENT THAT USE OF THE SOFTWARE WOULD NOT INFRINGE PRIVATELY OWNED RIGHTS, (4) DO NOT WARRANT THAT THE SOFTWARE WILL FUNCTION UNINTERRUPTED, THAT IT IS ERROR-FREE OR THAT ANY ERRORS WILL BE CORRECTED. 5. LIMITATION OF LIABILITY. IN NO EVENT WILL THE COPYRIGHT HOLDER, THE UNITED STATES, THE UNITED STATES DEPARTMENT OF ENERGY, OR THEIR EMPLOYEES: BE LIABLE FOR ANY INDIRECT, INCIDENTAL, CONSEQUENTIAL, SPECIAL OR PUNITIVE DAMAGES OF ANY KIND OR NATURE, INCLUDING BUT NOT LIMITED TO LOSS OF PROFITS OR LOSS OF DATA, FOR ANY REASON WHATSOEVER, WHETHER SUCH LIABILITY IS ASSERTED ON THE BASIS OF CONTRACT, TORT (INCLUDING NEGLIGENCE OR STRICT LIABILITY), OR OTHERWISE, EVEN IF ANY OF SAID PARTIES HAS BEEN WARNED OF THE POSSIBILITY OF SUCH LOSS OR DAMAGES. =============================================================================== Copyright and license statement for the odex Fortran routine developed by E. Hairer and G. Wanner and translated in GraggBulirschStoerIntegrator class in package org.apache.commons.math.ode.nonstiff: Copyright (c) 2004, Ernst Hairer 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. 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 REGENTS 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. =============================================================================== Copyright and license statement for the original lapack fortran routines translated in EigenDecompositionImpl class in package org.apache.commons.math.linear: Copyright (c) 1992-2008 The University of Tennessee. All rights reserved. $COPYRIGHT$ Additional copyrights may follow $HEADER$ 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 listed in this license in the documentation and/or other materials provided with the distribution. - Neither the name of the copyright holders nor the names of its 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. =============================================================================== Copyright and license statement for the original Mersenne twister C routines translated in MersenneTwister class in package org.apache.commons.math.random: Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura, All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. 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. 3. The names of its contributors may not 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. science.js-1.9.3/lib/d3/000077500000000000000000000000001256532472600146405ustar00rootroot00000000000000science.js-1.9.3/lib/d3/.gitignore000066400000000000000000000000051256532472600166230ustar00rootroot00000000000000_sitescience.js-1.9.3/lib/d3/LICENSE000066400000000000000000000026201256532472600156450ustar00rootroot00000000000000Copyright (c) 2010, Michael 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. * The name Michael Bostock may not 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 MICHAEL BOSTOCK 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. science.js-1.9.3/lib/d3/Makefile000066400000000000000000000107041256532472600163020ustar00rootroot00000000000000JS_COMPILER = \ ./lib/uglifyjs/bin/uglifyjs all: \ d3.js \ d3.min.js \ d3.behavior.js \ d3.behavior.min.js \ d3.chart.js \ d3.chart.min.js \ d3.layout.js \ d3.layout.min.js \ d3.csv.js \ d3.csv.min.js \ d3.geo.js \ d3.geo.min.js \ d3.geom.js \ d3.geom.min.js \ d3.time.js \ d3.time.min.js .INTERMEDIATE d3.js: \ src/start.js \ d3.core.js \ d3.scale.js \ d3.svg.js \ src/end.js d3.core.js: \ src/core/core.js \ src/core/date.js \ src/core/object.js \ src/core/array.js \ src/core/functor.js \ src/core/rebind.js \ src/core/ascending.js \ src/core/descending.js \ src/core/min.js \ src/core/max.js \ src/core/sum.js \ src/core/zip.js \ src/core/bisect.js \ src/core/first.js \ src/core/last.js \ src/core/nest.js \ src/core/keys.js \ src/core/values.js \ src/core/entries.js \ src/core/permute.js \ src/core/merge.js \ src/core/split.js \ src/core/collapse.js \ src/core/call.js \ src/core/range.js \ src/core/requote.js \ src/core/round.js \ src/core/xhr.js \ src/core/text.js \ src/core/json.js \ src/core/html.js \ src/core/xml.js \ src/core/ns.js \ src/core/dispatch.js \ src/core/format.js \ src/core/ease.js \ src/core/event.js \ src/core/interpolate.js \ src/core/uninterpolate.js \ src/core/rgb.js \ src/core/hsl.js \ src/core/selection.js \ src/core/transition.js \ src/core/timer.js d3.scale.js: \ src/scale/scale.js \ src/scale/nice.js \ src/scale/linear.js \ src/scale/bilinear.js \ src/scale/polylinear.js \ src/scale/log.js \ src/scale/pow.js \ src/scale/sqrt.js \ src/scale/ordinal.js \ src/scale/category.js \ src/scale/quantile.js \ src/scale/quantize.js d3.svg.js: \ src/svg/svg.js \ src/svg/arc.js \ src/svg/line.js \ src/svg/line-radial.js \ src/svg/area.js \ src/svg/area-radial.js \ src/svg/chord.js \ src/svg/diagonal.js \ src/svg/diagonal-radial.js \ src/svg/mouse.js \ src/svg/touches.js \ src/svg/symbol.js d3.behavior.js: \ src/start.js \ src/behavior/behavior.js \ src/behavior/zoom.js \ src/end.js d3.chart.js: \ src/start.js \ src/chart/chart.js \ src/chart/box.js \ src/chart/bullet.js \ src/chart/horizon.js \ src/chart/qq.js \ src/end.js d3.layout.js: \ src/start.js \ src/layout/layout.js \ src/layout/bundle.js \ src/layout/chord.js \ src/layout/force.js \ src/layout/partition.js \ src/layout/pie.js \ src/layout/stack.js \ src/layout/histogram.js \ src/layout/hierarchy.js \ src/layout/pack.js \ src/layout/cluster.js \ src/layout/tree.js \ src/layout/treemap.js \ src/end.js d3.geo.js: \ src/start.js \ src/geo/geo.js \ src/geo/azimuthal.js \ src/geo/albers.js \ src/geo/mercator.js \ src/geo/path.js \ src/geo/bounds.js \ src/end.js d3.csv.js: \ src/start.js \ src/csv/csv.js \ src/csv/parse.js \ src/csv/format.js \ src/end.js d3.time.js: \ src/start.js \ src/time/time.js \ src/time/format.js \ src/time/format-utc.js \ src/time/format-iso.js \ src/end.js d3.geom.js: \ src/start.js \ src/geom/geom.js \ src/geom/contour.js \ src/geom/hull.js \ src/geom/polygon.js \ src/geom/voronoi.js \ src/geom/delaunay.js \ src/geom/quadtree.js \ src/end.js tests: \ tests/test-append.test \ tests/test-attr.test \ tests/test-classed.test \ tests/test-call.test \ tests/test-csv-parse.test \ tests/test-format.test \ tests/test-insert.test \ tests/test-interpolate.test \ tests/test-keys.test \ tests/test-max.test \ tests/test-min.test \ tests/test-sum.test \ tests/test-nest.test \ tests/test-permute.test \ tests/test-zip.test \ tests/test-remove.test \ tests/test-rgb.test \ tests/test-round.test \ tests/test-hsl.test \ tests/test-time-format.test \ tests/test-time-format-iso.test \ tests/test-time-format-utc.test \ tests/test-time-parse.test \ tests/test-time-parse-iso.test \ tests/test-time-parse-utc.test \ tests/test-transition.test \ tests/test-scale-linear.test \ tests/test-scale-polylinear.test \ tests/test-scale-log.test \ tests/test-scale-sqrt.test \ tests/test-scale-pow.test \ tests/test-scale-quantile.test \ tests/test-bisect.test \ tests/test-svg-arc.test \ tests/test-svg-area.test \ tests/test-svg-line.test \ tests/test-svg-symbol.test %.min.js: %.js Makefile @rm -f $@ $(JS_COMPILER) < $< > $@ d3.js d3%.js: Makefile @rm -f $@ cat $(filter %.js,$^) > $@ @chmod a-w $@ %.test: %.js %.out all @/bin/echo -n "test: $* " @node $< > $*.actual @diff -U 3 $*.out $*.actual && rm -f $*.actual \ && echo '\033[1;32mPASS\033[0m' \ || echo test: $* '\033[1;31mFAIL\033[0m' clean: rm -f d3*.js science.js-1.9.3/lib/d3/d3.chart.js000066400000000000000000000665351256532472600166230ustar00rootroot00000000000000(function(){d3.chart = {}; // Inspired by http://informationandvisualization.de/blog/box-plot d3.chart.box = function() { var width = 1, height = 1, duration = 0, domain = null, value = Number, whiskers = d3_chart_boxWhiskers, quartiles = d3_chart_boxQuartiles, tickFormat = null; // For each small multiple… function box(g) { g.each(function(d, i) { d = d.map(value).sort(d3.ascending); var g = d3.select(this), n = d.length, min = d[0], max = d[n - 1]; // Compute quartiles. Must return exactly 3 elements. var quartileData = d.quartiles = quartiles(d); // Compute whiskers. Must return exactly 2 elements, or null. var whiskerIndices = whiskers && whiskers.call(this, d, i), whiskerData = whiskerIndices && whiskerIndices.map(function(i) { return d[i]; }); // Compute outliers. If no whiskers are specified, all data are "outliers". // We compute the outliers as indices, so that we can join across transitions! var outlierIndices = whiskerIndices ? d3.range(0, whiskerIndices[0]).concat(d3.range(whiskerIndices[1] + 1, n)) : d3.range(n); // Compute the new x-scale. var x1 = d3.scale.linear() .domain(domain && domain.call(this, d, i) || [min, max]) .range([height, 0]); // Retrieve the old x-scale, if this is an update. var x0 = this.__chart__ || d3.scale.linear() .domain([0, Infinity]) .range(x1.range()); // Stash the new scale. this.__chart__ = x1; // Note: the box, median, and box tick elements are fixed in number, // so we only have to handle enter and update. In contrast, the outliers // and other elements are variable, so we need to exit them! Variable // elements also fade in and out. // Update center line: the vertical line spanning the whiskers. var center = g.selectAll("line.center") .data(whiskerData ? [whiskerData] : []); center.enter().insert("svg:line", "rect") .attr("class", "center") .attr("x1", width / 2) .attr("y1", function(d) { return x0(d[0]); }) .attr("x2", width / 2) .attr("y2", function(d) { return x0(d[1]); }) .style("opacity", 1e-6) .transition() .duration(duration) .style("opacity", 1) .attr("y1", function(d) { return x1(d[0]); }) .attr("y2", function(d) { return x1(d[1]); }); center.transition() .duration(duration) .style("opacity", 1) .attr("y1", function(d) { return x1(d[0]); }) .attr("y2", function(d) { return x1(d[1]); }); center.exit().transition() .duration(duration) .style("opacity", 1e-6) .attr("y1", function(d) { return x1(d[0]); }) .attr("y2", function(d) { return x1(d[1]); }) .remove(); // Update innerquartile box. var box = g.selectAll("rect.box") .data([quartileData]); box.enter().append("svg:rect") .attr("class", "box") .attr("x", 0) .attr("y", function(d) { return x0(d[2]); }) .attr("width", width) .attr("height", function(d) { return x0(d[0]) - x0(d[2]); }) .transition() .duration(duration) .attr("y", function(d) { return x1(d[2]); }) .attr("height", function(d) { return x1(d[0]) - x1(d[2]); }); box.transition() .duration(duration) .attr("y", function(d) { return x1(d[2]); }) .attr("height", function(d) { return x1(d[0]) - x1(d[2]); }); // Update median line. var medianLine = g.selectAll("line.median") .data([quartileData[1]]); medianLine.enter().append("svg:line") .attr("class", "median") .attr("x1", 0) .attr("y1", x0) .attr("x2", width) .attr("y2", x0) .transition() .duration(duration) .attr("y1", x1) .attr("y2", x1); medianLine.transition() .duration(duration) .attr("y1", x1) .attr("y2", x1); // Update whiskers. var whisker = g.selectAll("line.whisker") .data(whiskerData || []); whisker.enter().insert("svg:line", "circle, text") .attr("class", "whisker") .attr("x1", 0) .attr("y1", x0) .attr("x2", width) .attr("y2", x0) .style("opacity", 1e-6) .transition() .duration(duration) .attr("y1", x1) .attr("y2", x1) .style("opacity", 1); whisker.transition() .duration(duration) .attr("y1", x1) .attr("y2", x1) .style("opacity", 1); whisker.exit().transition() .duration(duration) .attr("y1", x1) .attr("y2", x1) .style("opacity", 1e-6) .remove(); // Update outliers. var outlier = g.selectAll("circle.outlier") .data(outlierIndices, Number); outlier.enter().insert("svg:circle", "text") .attr("class", "outlier") .attr("r", 5) .attr("cx", width / 2) .attr("cy", function(i) { return x0(d[i]); }) .style("opacity", 1e-6) .transition() .duration(duration) .attr("cy", function(i) { return x1(d[i]); }) .style("opacity", 1); outlier.transition() .duration(duration) .attr("cy", function(i) { return x1(d[i]); }) .style("opacity", 1); outlier.exit().transition() .duration(duration) .attr("cy", function(i) { return x1(d[i]); }) .style("opacity", 1e-6) .remove(); // Compute the tick format. var format = tickFormat || x1.tickFormat(8); // Update box ticks. var boxTick = g.selectAll("text.box") .data(quartileData); boxTick.enter().append("svg:text") .attr("class", "box") .attr("dy", ".3em") .attr("dx", function(d, i) { return i & 1 ? 6 : -6 }) .attr("x", function(d, i) { return i & 1 ? width : 0 }) .attr("y", x0) .attr("text-anchor", function(d, i) { return i & 1 ? "start" : "end"; }) .text(format) .transition() .duration(duration) .attr("y", x1); boxTick.transition() .duration(duration) .text(format) .attr("y", x1); // Update whisker ticks. These are handled separately from the box // ticks because they may or may not exist, and we want don't want // to join box ticks pre-transition with whisker ticks post-. var whiskerTick = g.selectAll("text.whisker") .data(whiskerData || []); whiskerTick.enter().append("svg:text") .attr("class", "whisker") .attr("dy", ".3em") .attr("dx", 6) .attr("x", width) .attr("y", x0) .text(format) .style("opacity", 1e-6) .transition() .duration(duration) .attr("y", x1) .style("opacity", 1); whiskerTick.transition() .duration(duration) .text(format) .attr("y", x1) .style("opacity", 1); whiskerTick.exit().transition() .duration(duration) .attr("y", x1) .style("opacity", 1e-6) .remove(); }); d3.timer.flush(); } box.width = function(x) { if (!arguments.length) return width; width = x; return box; }; box.height = function(x) { if (!arguments.length) return height; height = x; return box; }; box.tickFormat = function(x) { if (!arguments.length) return tickFormat; tickFormat = x; return box; }; box.duration = function(x) { if (!arguments.length) return duration; duration = x; return box; }; box.domain = function(x) { if (!arguments.length) return domain; domain = x == null ? x : d3.functor(x); return box; }; box.value = function(x) { if (!arguments.length) return value; value = x; return box; }; box.whiskers = function(x) { if (!arguments.length) return whiskers; whiskers = x; return box; }; box.quartiles = function(x) { if (!arguments.length) return quartiles; quartiles = x; return box; }; return box; }; function d3_chart_boxWhiskers(d) { return [0, d.length - 1]; } function d3_chart_boxQuartiles(d) { return [ d3.quantile(d, .25), d3.quantile(d, .5), d3.quantile(d, .75) ]; } // Chart design based on the recommendations of Stephen Few. Implementation // based on the work of Clint Ivy, Jamie Love, and Jason Davies. // http://projects.instantcognition.com/protovis/bulletchart/ d3.chart.bullet = function() { var orient = "left", // TODO top & bottom reverse = false, duration = 0, ranges = d3_chart_bulletRanges, markers = d3_chart_bulletMarkers, measures = d3_chart_bulletMeasures, width = 380, height = 30, tickFormat = null; // For each small multiple… function bullet(g) { g.each(function(d, i) { var rangez = ranges.call(this, d, i).slice().sort(d3.descending), markerz = markers.call(this, d, i).slice().sort(d3.descending), measurez = measures.call(this, d, i).slice().sort(d3.descending), g = d3.select(this); // Compute the new x-scale. var x1 = d3.scale.linear() .domain([0, Math.max(rangez[0], markerz[0], measurez[0])]) .range(reverse ? [width, 0] : [0, width]); // Retrieve the old x-scale, if this is an update. var x0 = this.__chart__ || d3.scale.linear() .domain([0, Infinity]) .range(x1.range()); // Stash the new scale. this.__chart__ = x1; // Derive width-scales from the x-scales. var w0 = d3_chart_bulletWidth(x0), w1 = d3_chart_bulletWidth(x1); // Update the range rects. var range = g.selectAll("rect.range") .data(rangez); range.enter().append("svg:rect") .attr("class", function(d, i) { return "range s" + i; }) .attr("width", w0) .attr("height", height) .attr("x", reverse ? x0 : 0) .transition() .duration(duration) .attr("width", w1) .attr("x", reverse ? x1 : 0); range.transition() .duration(duration) .attr("x", reverse ? x1 : 0) .attr("width", w1) .attr("height", height); // Update the measure rects. var measure = g.selectAll("rect.measure") .data(measurez); measure.enter().append("svg:rect") .attr("class", function(d, i) { return "measure s" + i; }) .attr("width", w0) .attr("height", height / 3) .attr("x", reverse ? x0 : 0) .attr("y", height / 3) .transition() .duration(duration) .attr("width", w1) .attr("x", reverse ? x1 : 0); measure.transition() .duration(duration) .attr("width", w1) .attr("height", height / 3) .attr("x", reverse ? x1 : 0) .attr("y", height / 3); // Update the marker lines. var marker = g.selectAll("line.marker") .data(markerz); marker.enter().append("svg:line") .attr("class", "marker") .attr("x1", x0) .attr("x2", x0) .attr("y1", height / 6) .attr("y2", height * 5 / 6) .transition() .duration(duration) .attr("x1", x1) .attr("x2", x1); marker.transition() .duration(duration) .attr("x1", x1) .attr("x2", x1) .attr("y1", height / 6) .attr("y2", height * 5 / 6); // Compute the tick format. var format = tickFormat || x1.tickFormat(8); // Update the tick groups. var tick = g.selectAll("g.tick") .data(x1.ticks(8), function(d) { return this.textContent || format(d); }); // Initialize the ticks with the old scale, x0. var tickEnter = tick.enter().append("svg:g") .attr("class", "tick") .attr("transform", d3_chart_bulletTranslate(x0)) .style("opacity", 1e-6); tickEnter.append("svg:line") .attr("y1", height) .attr("y2", height * 7 / 6); tickEnter.append("svg:text") .attr("text-anchor", "middle") .attr("dy", "1em") .attr("y", height * 7 / 6) .text(format); // Transition the entering ticks to the new scale, x1. tickEnter.transition() .duration(duration) .attr("transform", d3_chart_bulletTranslate(x1)) .style("opacity", 1); // Transition the updating ticks to the new scale, x1. var tickUpdate = tick.transition() .duration(duration) .attr("transform", d3_chart_bulletTranslate(x1)) .style("opacity", 1); tickUpdate.select("line") .attr("y1", height) .attr("y2", height * 7 / 6); tickUpdate.select("text") .attr("y", height * 7 / 6); // Transition the exiting ticks to the new scale, x1. tick.exit().transition() .duration(duration) .attr("transform", d3_chart_bulletTranslate(x1)) .style("opacity", 1e-6) .remove(); }); d3.timer.flush(); } // left, right, top, bottom bullet.orient = function(x) { if (!arguments.length) return orient; orient = x; reverse = orient == "right" || orient == "bottom"; return bullet; }; // ranges (bad, satisfactory, good) bullet.ranges = function(x) { if (!arguments.length) return ranges; ranges = x; return bullet; }; // markers (previous, goal) bullet.markers = function(x) { if (!arguments.length) return markers; markers = x; return bullet; }; // measures (actual, forecast) bullet.measures = function(x) { if (!arguments.length) return measures; measures = x; return bullet; }; bullet.width = function(x) { if (!arguments.length) return width; width = x; return bullet; }; bullet.height = function(x) { if (!arguments.length) return height; height = x; return bullet; }; bullet.tickFormat = function(x) { if (!arguments.length) return tickFormat; tickFormat = x; return bullet; }; bullet.duration = function(x) { if (!arguments.length) return duration; duration = x; return bullet; }; return bullet; }; function d3_chart_bulletRanges(d) { return d.ranges; } function d3_chart_bulletMarkers(d) { return d.markers; } function d3_chart_bulletMeasures(d) { return d.measures; } function d3_chart_bulletTranslate(x) { return function(d) { return "translate(" + x(d) + ",0)"; }; } function d3_chart_bulletWidth(x) { var x0 = x(0); return function(d) { return Math.abs(x(d) - x0); }; } // Implements a horizon layout, which is a variation of a single-series // area chart where the area is folded into multiple bands. Color is used to // encode band, allowing the size of the chart to be reduced significantly // without impeding readability. This layout algorithm is based on the work of // J. Heer, N. Kong and M. Agrawala in "Sizing the Horizon: The Effects of Chart // Size and Layering on the Graphical Perception of Time Series Visualizations", // CHI 2009. http://hci.stanford.edu/publications/2009/heer-horizon-chi09.pdf d3.chart.horizon = function() { var bands = 1, // between 1 and 5, typically mode = "offset", // or mirror interpolate = "linear", // or basis, monotone, step-before, etc. x = d3_chart_horizonX, y = d3_chart_horizonY, w = 960, h = 40, duration = 0; var color = d3.scale.linear() .domain([-1, 0, 1]) .range(["#d62728", "#fff", "#1f77b4"]); // For each small multiple… function horizon(g) { g.each(function(d, i) { var g = d3.select(this), n = 2 * bands + 1, xMin = Infinity, xMax = -Infinity, yMax = -Infinity, x0, // old x-scale y0, // old y-scale id; // unique id for paths // Compute x- and y-values along with extents. var data = d.map(function(d, i) { var xv = x.call(this, d, i), yv = y.call(this, d, i); if (xv < xMin) xMin = xv; if (xv > xMax) xMax = xv; if (-yv > yMax) yMax = -yv; if (yv > yMax) yMax = yv; return [xv, yv]; }); // Compute the new x- and y-scales. var x1 = d3.scale.linear().domain([xMin, xMax]).range([0, w]), y1 = d3.scale.linear().domain([0, yMax]).range([0, h * bands]); // Retrieve the old scales, if this is an update. if (this.__chart__) { x0 = this.__chart__.x; y0 = this.__chart__.y; id = this.__chart__.id; } else { x0 = d3.scale.linear().domain([0, Infinity]).range(x1.range()); y0 = d3.scale.linear().domain([0, Infinity]).range(y1.range()); id = ++d3_chart_horizonId; } // We'll use a defs to store the area path and the clip path. var defs = g.selectAll("defs") .data([data]); var defsEnter = defs.enter().append("svg:defs"); // The clip path is a simple rect. defsEnter.append("svg:clipPath") .attr("id", "d3_chart_horizon_clip" + id) .append("svg:rect") .attr("width", w) .attr("height", h); defs.select("rect").transition() .duration(duration) .attr("width", w) .attr("height", h); // The area path is rendered with our resuable d3.svg.area. defsEnter.append("svg:path") .attr("id", "d3_chart_horizon_path" + id) .attr("d", d3_chart_horizonArea .interpolate(interpolate) .x(function(d) { return x0(d[0]); }) .y0(h * bands) .y1(function(d) { return h * bands - y0(d[1]); })) .transition() .duration(duration) .attr("d", d3_chart_horizonArea .x(function(d) { return x1(d[0]); }) .y1(function(d) { return h * bands - y1(d[1]); })); defs.select("path").transition() .duration(duration) .attr("d", d3_chart_horizonArea); // We'll use a container to clip all horizon layers at once. g.selectAll("g") .data([null]) .enter().append("svg:g") .attr("clip-path", "url(#d3_chart_horizon_clip" + id + ")"); // Define the transform function based on the mode. var transform = mode == "offset" ? function(d) { return "translate(0," + (d + (d < 0) - bands) * h + ")"; } : function(d) { return (d < 0 ? "scale(1,-1)" : "") + "translate(0," + (d - bands) * h + ")"; }; // Instantiate each copy of the path with different transforms. var u = g.select("g").selectAll("use") .data(d3.range(-1, -bands - 1, -1).concat(d3.range(1, bands + 1)), Number); // TODO don't fudge the enter transition u.enter().append("svg:use") .attr("xlink:href", "#d3_chart_horizon_path" + id) .attr("transform", function(d) { return transform(d + (d > 0 ? 1 : -1)); }) .style("fill", color) .transition() .duration(duration) .attr("transform", transform); u.transition() .duration(duration) .attr("transform", transform) .style("fill", color); u.exit().transition() .duration(duration) .attr("transform", transform) .remove(); // Stash the new scales. this.__chart__ = {x: x1, y: y1, id: id}; }); d3.timer.flush(); } horizon.duration = function(x) { if (!arguments.length) return duration; duration = +x; return horizon; }; horizon.bands = function(x) { if (!arguments.length) return bands; bands = +x; color.domain([-bands, 0, bands]); return horizon; }; horizon.mode = function(x) { if (!arguments.length) return mode; mode = x + ""; return horizon; }; horizon.colors = function(x) { if (!arguments.length) return color.range(); color.range(x); return horizon; }; horizon.interpolate = function(x) { if (!arguments.length) return interpolate; interpolate = x + ""; return horizon; }; horizon.x = function(z) { if (!arguments.length) return x; x = z; return horizon; }; horizon.y = function(z) { if (!arguments.length) return y; y = z; return horizon; }; horizon.width = function(x) { if (!arguments.length) return w; w = +x; return horizon; }; horizon.height = function(x) { if (!arguments.length) return h; h = +x; return horizon; }; return horizon; }; var d3_chart_horizonArea = d3.svg.area(), d3_chart_horizonId = 0; function d3_chart_horizonX(d) { return d[0]; } function d3_chart_horizonY(d) { return d[1]; } // Based on http://vis.stanford.edu/protovis/ex/qqplot.html d3.chart.qq = function() { var width = 1, height = 1, duration = 0, domain = null, tickFormat = null, n = 100, x = d3_chart_qqX, y = d3_chart_qqY; // For each small multiple… function qq(g) { g.each(function(d, i) { var g = d3.select(this), qx = d3_chart_qqQuantiles(n, x.call(this, d, i)), qy = d3_chart_qqQuantiles(n, y.call(this, d, i)), xd = domain && domain.call(this, d, i) || [d3.min(qx), d3.max(qx)], // new x-domain yd = domain && domain.call(this, d, i) || [d3.min(qy), d3.max(qy)], // new y-domain x0, // old x-scale y0; // old y-scale // Compute the new x-scale. var x1 = d3.scale.linear() .domain(xd) .range([0, width]); // Compute the new y-scale. var y1 = d3.scale.linear() .domain(yd) .range([height, 0]); // Retrieve the old scales, if this is an update. if (this.__chart__) { x0 = this.__chart__.x; y0 = this.__chart__.y; } else { x0 = d3.scale.linear().domain([0, Infinity]).range(x1.range()); y0 = d3.scale.linear().domain([0, Infinity]).range(y1.range()); } // Stash the new scales. this.__chart__ = {x: x1, y: y1}; // Update diagonal line. var diagonal = g.selectAll("line.diagonal") .data([null]); diagonal.enter().append("svg:line") .attr("class", "diagonal") .attr("x1", x1(yd[0])) .attr("y1", y1(xd[0])) .attr("x2", x1(yd[1])) .attr("y2", y1(xd[1])); diagonal.transition() .duration(duration) .attr("x1", x1(yd[0])) .attr("y1", y1(xd[0])) .attr("x2", x1(yd[1])) .attr("y2", y1(xd[1])); // Update quantile plots. var circle = g.selectAll("circle") .data(d3.range(n).map(function(i) { return {x: qx[i], y: qy[i]}; })); circle.enter().append("svg:circle") .attr("class", "quantile") .attr("r", 4.5) .attr("cx", function(d) { return x0(d.x); }) .attr("cy", function(d) { return y0(d.y); }) .style("opacity", 1e-6) .transition() .duration(duration) .attr("cx", function(d) { return x1(d.x); }) .attr("cy", function(d) { return y1(d.y); }) .style("opacity", 1); circle.transition() .duration(duration) .attr("cx", function(d) { return x1(d.x); }) .attr("cy", function(d) { return y1(d.y); }) .style("opacity", 1); circle.exit().transition() .duration(duration) .attr("cx", function(d) { return x1(d.x); }) .attr("cy", function(d) { return y1(d.y); }) .style("opacity", 1e-6) .remove(); var xformat = tickFormat || x1.tickFormat(4), yformat = tickFormat || y1.tickFormat(4), tx = function(d) { return "translate(" + x1(d) + "," + height + ")"; }, ty = function(d) { return "translate(0," + y1(d) + ")"; }; // Update x-ticks. var xtick = g.selectAll("g.x.tick") .data(x1.ticks(4), function(d) { return this.textContent || xformat(d); }); var xtickEnter = xtick.enter().append("svg:g") .attr("class", "x tick") .attr("transform", function(d) { return "translate(" + x0(d) + "," + height + ")"; }) .style("opacity", 1e-6); xtickEnter.append("svg:line") .attr("y1", 0) .attr("y2", -6); xtickEnter.append("svg:text") .attr("text-anchor", "middle") .attr("dy", "1em") .text(xformat); // Transition the entering ticks to the new scale, x1. xtickEnter.transition() .duration(duration) .attr("transform", tx) .style("opacity", 1); // Transition the updating ticks to the new scale, x1. xtick.transition() .duration(duration) .attr("transform", tx) .style("opacity", 1); // Transition the exiting ticks to the new scale, x1. xtick.exit().transition() .duration(duration) .attr("transform", tx) .style("opacity", 1e-6) .remove(); // Update ticks. var ytick = g.selectAll("g.y.tick") .data(y1.ticks(4), function(d) { return this.textContent || yformat(d); }); var ytickEnter = ytick.enter().append("svg:g") .attr("class", "y tick") .attr("transform", function(d) { return "translate(0," + y0(d) + ")"; }) .style("opacity", 1e-6); ytickEnter.append("svg:line") .attr("x1", 0) .attr("x2", 6); ytickEnter.append("svg:text") .attr("text-anchor", "end") .attr("dx", "-.5em") .attr("dy", ".3em") .text(yformat); // Transition the entering ticks to the new scale, y1. ytickEnter.transition() .duration(duration) .attr("transform", ty) .style("opacity", 1); // Transition the updating ticks to the new scale, y1. ytick.transition() .duration(duration) .attr("transform", ty) .style("opacity", 1); // Transition the exiting ticks to the new scale, y1. ytick.exit().transition() .duration(duration) .attr("transform", ty) .style("opacity", 1e-6) .remove(); }); } qq.width = function(x) { if (!arguments.length) return width; width = x; return qq; }; qq.height = function(x) { if (!arguments.length) return height; height = x; return qq; }; qq.duration = function(x) { if (!arguments.length) return duration; duration = x; return qq; }; qq.domain = function(x) { if (!arguments.length) return domain; domain = x == null ? x : d3.functor(x); return qq; }; qq.count = function(z) { if (!arguments.length) return n; n = z; return qq; }; qq.x = function(z) { if (!arguments.length) return x; x = z; return qq; }; qq.y = function(z) { if (!arguments.length) return y; y = z; return qq; }; qq.tickFormat = function(x) { if (!arguments.length) return tickFormat; tickFormat = x; return qq; }; return qq; }; function d3_chart_qqQuantiles(n, values) { var m = values.length - 1; values = values.slice().sort(d3.ascending); return d3.range(n).map(function(i) { return values[~~(i * m / n)]; }); } function d3_chart_qqX(d) { return d.x; } function d3_chart_qqY(d) { return d.y; } })(); science.js-1.9.3/lib/d3/d3.chart.min.js000066400000000000000000000310621256532472600173700ustar00rootroot00000000000000(function(){function a(a){return[0,a.length-1]}function b(a){return[d3.quantile(a,.25),d3.quantile(a,.5),d3.quantile(a,.75)]}function c(a){return a.ranges}function d(a){return a.markers}function e(a){return a.measures}function f(a){return function(b){return"translate("+a(b)+",0)"}}function g(a){var b=a(0);return function(c){return Math.abs(a(c)-b)}}function j(a){return a[0]}function k(a){return a[1]}function l(a,b){var c=b.length-1;return b=b.slice().sort(d3.ascending),d3.range(a).map(function(d){return b[~~(d*c/a)]})}function m(a){return a.x}function n(a){return a.y}d3.chart={},d3.chart.box=function(){function k(a){a.each(function(a,b){a=a.map(g).sort(d3.ascending);var k=d3.select(this),l=a.length,m=a[0],n=a[l-1],o=a.quartiles=i(a),p=h&&h.call(this,a,b),q=p&&p.map(function(b){return a[b]}),r=p?d3.range(0,p[0]).concat(d3.range(p[1]+1,l)):d3.range(l),s=d3.scale.linear().domain(f&&f.call(this,a,b)||[m,n]).range([d,0]),t=this.__chart__||d3.scale.linear().domain([0,Infinity]).range(s.range());this.__chart__=s;var u=k.selectAll("line.center").data(q?[q]:[]);u.enter().insert("svg:line","rect").attr("class","center").attr("x1",c/2).attr("y1",function(a){return t(a[0])}).attr("x2",c/2).attr("y2",function(a){return t(a[1])}).style("opacity",1e-6).transition().duration(e).style("opacity",1).attr("y1",function(a){return s(a[0])}).attr("y2",function(a){return s(a[1])}),u.transition().duration(e).style("opacity",1).attr("y1",function(a){return s(a[0])}).attr("y2",function(a){return s(a[1])}),u.exit().transition().duration(e).style("opacity",1e-6).attr("y1",function(a){return s(a[0])}).attr("y2",function(a){return s(a[1])}).remove();var v=k.selectAll("rect.box").data([o]);v.enter().append("svg:rect").attr("class","box").attr("x",0).attr("y",function(a){return t(a[2])}).attr("width",c).attr("height",function(a){return t(a[0])-t(a[2])}).transition().duration(e).attr("y",function(a){return s(a[2])}).attr("height",function(a){return s(a[0])-s(a[2])}),v.transition().duration(e).attr("y",function(a){return s(a[2])}).attr("height",function(a){return s(a[0])-s(a[2])});var w=k.selectAll("line.median").data([o[1]]);w.enter().append("svg:line").attr("class","median").attr("x1",0).attr("y1",t).attr("x2",c).attr("y2",t).transition().duration(e).attr("y1",s).attr("y2",s),w.transition().duration(e).attr("y1",s).attr("y2",s);var x=k.selectAll("line.whisker").data(q||[]);x.enter().insert("svg:line","circle, text").attr("class","whisker").attr("x1",0).attr("y1",t).attr("x2",c).attr("y2",t).style("opacity",1e-6).transition().duration(e).attr("y1",s).attr("y2",s).style("opacity",1),x.transition().duration(e).attr("y1",s).attr("y2",s).style("opacity",1),x.exit().transition().duration(e).attr("y1",s).attr("y2",s).style("opacity",1e-6).remove();var y=k.selectAll("circle.outlier").data(r,Number);y.enter().insert("svg:circle","text").attr("class","outlier").attr("r",5).attr("cx",c/2).attr("cy",function(b){return t(a[b])}).style("opacity",1e-6).transition().duration(e).attr("cy",function(b){return s(a[b])}).style("opacity",1),y.transition().duration(e).attr("cy",function(b){return s(a[b])}).style("opacity",1),y.exit().transition().duration(e).attr("cy",function(b){return s(a[b])}).style("opacity",1e-6).remove();var z=j||s.tickFormat(8),A=k.selectAll("text.box").data(o);A.enter().append("svg:text").attr("class","box").attr("dy",".3em").attr("dx",function(a,b){return b&1?6:-6}).attr("x",function(a,b){return b&1?c:0}).attr("y",t).attr("text-anchor",function(a,b){return b&1?"start":"end"}).text(z).transition().duration(e).attr("y",s),A.transition().duration(e).text(z).attr("y",s);var B=k.selectAll("text.whisker").data(q||[]);B.enter().append("svg:text").attr("class","whisker").attr("dy",".3em").attr("dx",6).attr("x",c).attr("y",t).text(z).style("opacity",1e-6).transition().duration(e).attr("y",s).style("opacity",1),B.transition().duration(e).text(z).attr("y",s).style("opacity",1),B.exit().transition().duration(e).attr("y",s).style("opacity",1e-6).remove()}),d3.timer.flush()}var c=1,d=1,e=0,f=null,g=Number,h=a,i=b,j=null;return k.width=function(a){return arguments.length?(c=a,k):c},k.height=function(a){return arguments.length?(d=a,k):d},k.tickFormat=function(a){return arguments.length?(j=a,k):j},k.duration=function(a){return arguments.length?(e=a,k):e},k.domain=function(a){return arguments.length?(f=a==null?a:d3.functor(a),k):f},k.value=function(a){return arguments.length?(g=a,k):g},k.whiskers=function(a){return arguments.length?(h=a,k):h},k.quartiles=function(a){return arguments.length?(i=a,k):i},k},d3.chart.bullet=function(){function o(a){a.each(function(a,c){var d=i.call(this,a,c).slice().sort(d3.descending),e=j.call(this,a,c).slice().sort(d3.descending),o=k.call(this,a,c).slice().sort(d3.descending),p=d3.select(this),q=d3.scale.linear().domain([0,Math.max(d[0],e[0],o[0])]).range(b?[l,0]:[0,l]),r=this.__chart__||d3.scale.linear().domain([0,Infinity]).range(q.range());this.__chart__=q;var s=g(r),t=g(q),u=p.selectAll("rect.range").data(d);u.enter().append("svg:rect").attr("class",function(a,b){return"range s"+b}).attr("width",s).attr("height",m).attr("x",b?r:0).transition().duration(h).attr("width",t).attr("x",b?q:0),u.transition().duration(h).attr("x",b?q:0).attr("width",t).attr("height",m);var v=p.selectAll("rect.measure").data(o);v.enter().append("svg:rect").attr("class",function(a,b){return"measure s"+b}).attr("width",s).attr("height",m/3).attr("x",b?r:0).attr("y",m/3).transition().duration(h).attr("width",t).attr("x",b?q:0),v.transition().duration(h).attr("width",t).attr("height",m/3).attr("x",b?q:0).attr("y",m/3);var w=p.selectAll("line.marker").data(e);w.enter().append("svg:line").attr("class","marker").attr("x1",r).attr("x2",r).attr("y1",m/6).attr("y2",m*5/6).transition().duration(h).attr("x1",q).attr("x2",q),w.transition().duration(h).attr("x1",q).attr("x2",q).attr("y1",m/6).attr("y2",m*5/6);var x=n||q.tickFormat(8),y=p.selectAll("g.tick").data(q.ticks(8),function(a){return this.textContent||x(a)}),z=y.enter().append("svg:g").attr("class","tick").attr("transform",f(r)).style("opacity",1e-6);z.append("svg:line").attr("y1",m).attr("y2",m*7/6),z.append("svg:text").attr("text-anchor","middle").attr("dy","1em").attr("y",m*7/6).text(x),z.transition().duration(h).attr("transform",f(q)).style("opacity",1);var A=y.transition().duration(h).attr("transform",f(q)).style("opacity",1);A.select("line").attr("y1",m).attr("y2",m*7/6),A.select("text").attr("y",m*7/6),y.exit().transition().duration(h).attr("transform",f(q)).style("opacity",1e-6).remove()}),d3.timer.flush()}var a="left",b=!1,h=0,i=c,j=d,k=e,l=380,m=30,n=null;return o.orient=function(c){return arguments.length?(a=c,b=a=="right"||a=="bottom",o):a},o.ranges=function(a){return arguments.length?(i=a,o):i},o.markers=function(a){return arguments.length?(j=a,o):j},o.measures=function(a){return arguments.length?(k=a,o):k},o.width=function(a){return arguments.length?(l=a,o):l},o.height=function(a){return arguments.length?(m=a,o):m},o.tickFormat=function(a){return arguments.length?(n=a,o):n},o.duration=function(a){return arguments.length?(h=a,o):h},o},d3.chart.horizon=function(){function n(j){j.each(function(j,k){var n=d3.select(this),o=2*a+1,p=Infinity,q=-Infinity,r=-Infinity,s,t,u,v=j.map(function(a,b){var c=d.call(this,a,b),f=e.call(this,a,b);return cq&&(q=c),-f>r&&(r=-f),f>r&&(r=f),[c,f]}),z=d3.scale.linear().domain([p,q]).range([0,f]),A=d3.scale.linear().domain([0,r]).range([0,g*a]);this.__chart__?(s=this.__chart__.x,t=this.__chart__.y,u=this.__chart__.id):(s=d3.scale.linear().domain([0,Infinity]).range(z.range()),t=d3.scale.linear().domain([0,Infinity]).range(A.range()),u=++i);var B=n.selectAll("defs").data([v]),C=B.enter().append("svg:defs");C.append("svg:clipPath").attr("id","d3_chart_horizon_clip"+u).append("svg:rect").attr("width",f).attr("height",g),B.select("rect").transition().duration(l).attr("width",f).attr("height",g),C.append("svg:path").attr("id","d3_chart_horizon_path"+u).attr("d",h.interpolate(c).x(function(a){return s(a[0])}).y0(g*a).y1(function(b){return g*a-t(b[1])})).transition().duration(l).attr("d",h.x(function(a){return z(a[0])}).y1(function(b){return g*a-A(b[1])})),B.select("path").transition().duration(l).attr("d",h),n.selectAll("g").data([null]).enter().append("svg:g").attr("clip-path","url(#d3_chart_horizon_clip"+u+")");var D=b=="offset"?function(b){return"translate(0,"+(b+(b<0)-a)*g+")"}:function(b){return(b<0?"scale(1,-1)":"")+"translate(0,"+(b-a)*g+")"},E=n.select("g").selectAll("use").data(d3.range(-1,-a-1,-1).concat(d3.range(1,a+1)),Number);E.enter().append("svg:use").attr("xlink:href","#d3_chart_horizon_path"+u).attr("transform",function(a){return D(a+(a>0?1:-1))}).style("fill",m).transition().duration(l).attr("transform",D),E.transition().duration(l).attr("transform",D).style("fill",m),E.exit().transition().duration(l).attr("transform",D).remove(),this.__chart__={x:z,y:A,id:u}}),d3.timer.flush()}var a=1,b="offset",c="linear",d=j,e=k,f=960,g=40,l=0,m=d3.scale.linear().domain([-1,0,1]).range(["#d62728","#fff","#1f77b4"]);return n.duration=function(a){return arguments.length?(l=+a,n):l},n.bands=function(b){return arguments.length?(a=+b,m.domain([-a,0,a]),n):a},n.mode=function(a){return arguments.length?(b=a+"",n):b},n.colors=function(a){return arguments.length?(m.range(a),n):m.range()},n.interpolate=function(a){return arguments.length?(c=a+"",n):c},n.x=function(a){return arguments.length?(d=a,n):d},n.y=function(a){return arguments.length?(e=a,n):e},n.width=function(a){return arguments.length?(f=+a,n):f},n.height=function(a){return arguments.length?(g=+a,n):g},n};var h=d3.svg.area(),i=0;d3.chart.qq=function(){function i(i){i.each(function(i,j){var k=d3.select(this),m=l(f,g.call(this,i,j)),n=l(f,h.call(this,i,j)),o=d&&d.call(this,i,j)||[d3.min(m),d3.max(m)],p=d&&d.call(this,i,j)||[d3.min(n),d3.max(n)],q,r,s=d3.scale.linear().domain(o).range([0,a]),t=d3.scale.linear().domain(p).range([b,0]);this.__chart__?(q=this.__chart__.x,r=this.__chart__.y):(q=d3.scale.linear().domain([0,Infinity]).range(s.range()),r=d3.scale.linear().domain([0,Infinity]).range(t.range())),this.__chart__={x:s,y:t};var u=k.selectAll("line.diagonal").data([null]);u.enter().append("svg:line").attr("class","diagonal").attr("x1",s(p[0])).attr("y1",t(o[0])).attr("x2",s(p[1])).attr("y2",t(o[1])),u.transition().duration(c).attr("x1",s(p[0])).attr("y1",t(o[0])).attr("x2",s(p[1])).attr("y2",t(o[1]));var v=k.selectAll("circle").data(d3.range(f).map(function(a){return{x:m[a],y:n[a]}}));v.enter().append("svg:circle").attr("class","quantile").attr("r",4.5).attr("cx",function(a){return q(a.x)}).attr("cy",function(a){return r(a.y)}).style("opacity",1e-6).transition().duration(c).attr("cx",function(a){return s(a.x)}).attr("cy",function(a){return t(a.y)}).style("opacity",1),v.transition().duration(c).attr("cx",function(a){return s(a.x)}).attr("cy",function(a){return t(a.y)}).style("opacity",1),v.exit().transition().duration(c).attr("cx",function(a){return s(a.x)}).attr("cy",function(a){return t(a.y)}).style("opacity",1e-6).remove();var w=e||s.tickFormat(4),z=e||t.tickFormat(4),A=function(a){return"translate("+s(a)+","+b+")"},B=function(a){return"translate(0,"+t(a)+")"},C=k.selectAll("g.x.tick").data(s.ticks(4),function(a){return this.textContent||w(a)}),D=C.enter().append("svg:g").attr("class","x tick").attr("transform",function(a){return"translate("+q(a)+","+b+")"}).style("opacity",1e-6);D.append("svg:line").attr("y1",0).attr("y2",-6),D.append("svg:text").attr("text-anchor","middle").attr("dy","1em").text(w),D.transition().duration(c).attr("transform",A).style("opacity",1),C.transition().duration(c).attr("transform",A).style("opacity",1),C.exit().transition().duration(c).attr("transform",A).style("opacity",1e-6).remove();var E=k.selectAll("g.y.tick").data(t.ticks(4),function(a){return this.textContent||z(a)}),F=E.enter().append("svg:g").attr("class","y tick").attr("transform",function(a){return"translate(0,"+r(a)+")"}).style("opacity",1e-6);F.append("svg:line").attr("x1",0).attr("x2",6),F.append("svg:text").attr("text-anchor","end").attr("dx","-.5em").attr("dy",".3em").text(z),F.transition().duration(c).attr("transform",B).style("opacity",1),E.transition().duration(c).attr("transform",B).style("opacity",1),E.exit().transition().duration(c).attr("transform",B).style("opacity",1e-6).remove()})}var a=1,b=1,c=0,d=null,e=null,f=100,g=m,h=n;return i.width=function(b){return arguments.length?(a=b,i):a},i.height=function(a){return arguments.length?(b=a,i):b},i.duration=function(a){return arguments.length?(c=a,i):c},i.domain=function(a){return arguments.length?(d=a==null?a:d3.functor(a),i):d},i.count=function(a){return arguments.length?(f=a,i):f},i.x=function(a){return arguments.length?(g=a,i):g},i.y=function(a){return arguments.length?(h=a,i):h},i.tickFormat=function(a){return arguments.length?(e=a,i):e},i}})();science.js-1.9.3/lib/d3/d3.csv.js000066400000000000000000000044301256532472600162770ustar00rootroot00000000000000(function(){d3.csv = function(url, callback) { d3.text(url, "text/csv", function(text) { callback(text && d3.csv.parse(text)); }); }; d3.csv.parse = function(text) { var header; return d3.csv.parseRows(text, function(row, i) { if (i) { var o = {}, j = -1, m = header.length; while (++j < m) o[header[j]] = row[j]; return o; } else { header = row; return null; } }); }; d3.csv.parseRows = function(text, f) { var EOL = {}, // sentinel value for end-of-line EOF = {}, // sentinel value for end-of-file rows = [], // output rows re = /\r\n|[,\r\n]/g, // field separator regex n = 0, // the current line number t, // the current token eol; // is the current token followed by EOL? re.lastIndex = 0; // work-around bug in FF 3.6 /** @private Returns the next token. */ function token() { if (re.lastIndex >= text.length) return EOF; // special case: end of file if (eol) { eol = false; return EOL; } // special case: end of line // special case: quotes var j = re.lastIndex; if (text.charCodeAt(j) === 34) { var i = j; while (i++ < text.length) { if (text.charCodeAt(i) === 34) { if (text.charCodeAt(i + 1) !== 34) break; i++; } } re.lastIndex = i + 2; var c = text.charCodeAt(i + 1); if (c === 13) { eol = true; if (text.charCodeAt(i + 2) === 10) re.lastIndex++; } else if (c === 10) { eol = true; } return text.substring(j + 1, i).replace(/""/g, "\""); } // common case var m = re.exec(text); if (m) { eol = m[0].charCodeAt(0) !== 44; return text.substring(j, m.index); } re.lastIndex = text.length; return text.substring(j); } while ((t = token()) !== EOF) { var a = []; while ((t !== EOL) && (t !== EOF)) { a.push(t); t = token(); } if (f && !(a = f(a, n++))) continue; rows.push(a); } return rows; }; d3.csv.format = function(rows) { return rows.map(d3_csv_formatRow).join("\n"); }; function d3_csv_formatRow(row) { return row.map(d3_csv_formatValue).join(","); } function d3_csv_formatValue(text) { return /[",\n]/.test(text) ? "\"" + text.replace(/\"/g, "\"\"") + "\"" : text; } })(); science.js-1.9.3/lib/d3/d3.csv.min.js000066400000000000000000000020661256532472600170640ustar00rootroot00000000000000(function(){function a(a){return a.map(b).join(",")}function b(a){return/[",\n]/.test(a)?'"'+a.replace(/\"/g,'""')+'"':a}d3.csv=function(a,b){d3.text(a,"text/csv",function(a){b(a&&d3.csv.parse(a))})},d3.csv.parse=function(a){var b;return d3.csv.parseRows(a,function(a,c){if(c){var d={},e=-1,f=b.length;while(++e=a.length)return d;if(i)return i=!1,c;var b=f.lastIndex;if(a.charCodeAt(b)===34){var e=b;while(e++ 50 ? alaska : lon < -140 ? hawaii : lat < 21 ? puertoRico : lower48)(coordinates); } albersUsa.scale = function(x) { if (!arguments.length) return lower48.scale(); lower48.scale(x); alaska.scale(x * .6); hawaii.scale(x); puertoRico.scale(x * 1.5); return albersUsa.translate(lower48.translate()); }; albersUsa.translate = function(x) { if (!arguments.length) return lower48.translate(); var dz = lower48.scale() / 1000, dx = x[0], dy = x[1]; lower48.translate(x); alaska.translate([dx - 400 * dz, dy + 170 * dz]); hawaii.translate([dx - 190 * dz, dy + 200 * dz]); puertoRico.translate([dx + 580 * dz, dy + 430 * dz]); return albersUsa; }; return albersUsa.scale(lower48.scale()); }; d3.geo.bonne = function() { var scale = 200, translate = [480, 250], x0, // origin longitude in radians y0, // origin latitude in radians y1, // parallel latitude in radians c1; // cot(y1) function bonne(coordinates) { var x = coordinates[0] * d3_geo_radians - x0, y = coordinates[1] * d3_geo_radians - y0; if (y1) { var p = c1 + y1 - y, E = x * Math.cos(y) / p; x = p * Math.sin(E); y = p * Math.cos(E) - c1; } else { x *= Math.cos(y); y *= -1; } return [ scale * x + translate[0], scale * y + translate[1] ]; } bonne.invert = function(coordinates) { var x = (coordinates[0] - translate[0]) / scale, y = (coordinates[1] - translate[1]) / scale; if (y1) { var c = c1 + y, p = Math.sqrt(x * x + c * c); y = c1 + y1 - p; x = x0 + p * Math.atan2(x, c) / Math.cos(y); } else { y *= -1; x /= Math.cos(y); } return [ x / d3_geo_radians, y / d3_geo_radians ]; }; // 90° for Werner, 0° for Sinusoidal bonne.parallel = function(x) { if (!arguments.length) return y1 / d3_geo_radians; c1 = 1 / Math.tan(y1 = x * d3_geo_radians); return bonne; }; bonne.origin = function(x) { if (!arguments.length) return [x0 / d3_geo_radians, y0 / d3_geo_radians]; x0 = x[0] * d3_geo_radians; y0 = x[1] * d3_geo_radians; return bonne; }; bonne.scale = function(x) { if (!arguments.length) return scale; scale = +x; return bonne; }; bonne.translate = function(x) { if (!arguments.length) return translate; translate = [+x[0], +x[1]]; return bonne; }; return bonne.origin([0, 0]).parallel(45); }; d3.geo.equirectangular = function() { var scale = 500, translate = [480, 250]; function equirectangular(coordinates) { var x = coordinates[0] / 360, y = -coordinates[1] / 360; return [ scale * x + translate[0], scale * y + translate[1] ]; } equirectangular.invert = function(coordinates) { var x = (coordinates[0] - translate[0]) / scale, y = (coordinates[1] - translate[1]) / scale; return [ 360 * x, -360 * y ]; }; equirectangular.scale = function(x) { if (!arguments.length) return scale; scale = +x; return equirectangular; }; equirectangular.translate = function(x) { if (!arguments.length) return translate; translate = [+x[0], +x[1]]; return equirectangular; }; return equirectangular; }; d3.geo.mercator = function() { var scale = 500, translate = [480, 250]; function mercator(coordinates) { var x = coordinates[0] / 360, y = -(Math.log(Math.tan(Math.PI / 4 + coordinates[1] * d3_geo_radians / 2)) / d3_geo_radians) / 360; return [ scale * x + translate[0], scale * Math.max(-.5, Math.min(.5, y)) + translate[1] ]; } mercator.invert = function(coordinates) { var x = (coordinates[0] - translate[0]) / scale, y = (coordinates[1] - translate[1]) / scale; return [ 360 * x, 2 * Math.atan(Math.exp(-360 * y * d3_geo_radians)) / d3_geo_radians - 90 ]; }; mercator.scale = function(x) { if (!arguments.length) return scale; scale = +x; return mercator; }; mercator.translate = function(x) { if (!arguments.length) return translate; translate = [+x[0], +x[1]]; return mercator; }; return mercator; }; function d3_geo_type(types, defaultValue) { return function(object) { return object && object.type in types ? types[object.type](object) : defaultValue; }; } /** * Returns a function that, given a GeoJSON object (e.g., a feature), returns * the corresponding SVG path. The function can be customized by overriding the * projection. Point features are mapped to circles with a default radius of * 4.5px; the radius can be specified either as a constant or a function that * is evaluated per object. */ d3.geo.path = function() { var pointRadius = 4.5, pointCircle = d3_path_circle(pointRadius), projection = d3.geo.albersUsa(); function path(d, i) { if (typeof pointRadius === "function") { pointCircle = d3_path_circle(pointRadius.apply(this, arguments)); } return pathType(d) || null; } function project(coordinates) { return projection(coordinates).join(","); } var pathType = d3_geo_type({ FeatureCollection: function(o) { var path = [], features = o.features, i = -1, // features.index n = features.length; while (++i < n) path.push(pathType(features[i].geometry)); return path.join(""); }, Feature: function(o) { return pathType(o.geometry); }, Point: function(o) { return "M" + project(o.coordinates) + pointCircle; }, MultiPoint: function(o) { var path = [], coordinates = o.coordinates, i = -1, // coordinates.index n = coordinates.length; while (++i < n) path.push("M", project(coordinates[i]), pointCircle); return path.join(""); }, LineString: function(o) { var path = ["M"], coordinates = o.coordinates, i = -1, // coordinates.index n = coordinates.length; while (++i < n) path.push(project(coordinates[i]), "L"); path.pop(); return path.join(""); }, MultiLineString: function(o) { var path = [], coordinates = o.coordinates, i = -1, // coordinates.index n = coordinates.length, subcoordinates, // coordinates[i] j, // subcoordinates.index m; // subcoordinates.length while (++i < n) { subcoordinates = coordinates[i]; j = -1; m = subcoordinates.length; path.push("M"); while (++j < m) path.push(project(subcoordinates[j]), "L"); path.pop(); } return path.join(""); }, Polygon: function(o) { var path = [], coordinates = o.coordinates, i = -1, // coordinates.index n = coordinates.length, subcoordinates, // coordinates[i] j, // subcoordinates.index m; // subcoordinates.length while (++i < n) { subcoordinates = coordinates[i]; j = -1; if ((m = subcoordinates.length - 1) > 0) { path.push("M"); while (++j < m) path.push(project(subcoordinates[j]), "L"); path[path.length - 1] = "Z"; } } return path.join(""); }, MultiPolygon: function(o) { var path = [], coordinates = o.coordinates, i = -1, // coordinates index n = coordinates.length, subcoordinates, // coordinates[i] j, // subcoordinates index m, // subcoordinates.length subsubcoordinates, // subcoordinates[j] k, // subsubcoordinates index p; // subsubcoordinates.length while (++i < n) { subcoordinates = coordinates[i]; j = -1; m = subcoordinates.length; while (++j < m) { subsubcoordinates = subcoordinates[j]; k = -1; if ((p = subsubcoordinates.length - 1) > 0) { path.push("M"); while (++k < p) path.push(project(subsubcoordinates[k]), "L"); path[path.length - 1] = "Z"; } } } return path.join(""); }, GeometryCollection: function(o) { var path = [], geometries = o.geometries, i = -1, // geometries index n = geometries.length; while (++i < n) path.push(pathType(geometries[i])); return path.join(""); } }); var areaType = path.area = d3_geo_type({ FeatureCollection: function(o) { var area = 0, features = o.features, i = -1, // features.index n = features.length; while (++i < n) area += areaType(features[i]); return area; }, Feature: function(o) { return areaType(o.geometry); }, Polygon: function(o) { return polygonArea(o.coordinates); }, MultiPolygon: function(o) { var sum = 0, coordinates = o.coordinates, i = -1, // coordinates index n = coordinates.length; while (++i < n) sum += polygonArea(coordinates[i]); return sum; }, GeometryCollection: function(o) { var sum = 0, geometries = o.geometries, i = -1, // geometries index n = geometries.length; while (++i < n) sum += areaType(geometries[i]); return sum; } }, 0); function polygonArea(coordinates) { var sum = area(coordinates[0]), // exterior ring i = 0, // coordinates.index n = coordinates.length; while (++i < n) sum -= area(coordinates[i]); // holes return sum; } function polygonCentroid(coordinates) { var polygon = d3.geom.polygon(coordinates[0].map(projection)), // exterior ring area = polygon.area(), centroid = polygon.centroid(area < 0 ? (area *= -1, 1) : -1), x = centroid[0], y = centroid[1], z = area, i = 0, // coordinates index n = coordinates.length; while (++i < n) { polygon = d3.geom.polygon(coordinates[i].map(projection)); // holes area = polygon.area(); centroid = polygon.centroid(area < 0 ? (area *= -1, 1) : -1); x -= centroid[0]; y -= centroid[1]; z -= area; } return [x, y, 6 * z]; // weighted centroid } var centroidType = path.centroid = d3_geo_type({ // TODO FeatureCollection // TODO Point // TODO MultiPoint // TODO LineString // TODO MultiLineString // TODO GeometryCollection Feature: function(o) { return centroidType(o.geometry); }, Polygon: function(o) { var centroid = polygonCentroid(o.coordinates); return [centroid[0] / centroid[2], centroid[1] / centroid[2]]; }, MultiPolygon: function(o) { var area = 0, coordinates = o.coordinates, centroid, x = 0, y = 0, z = 0, i = -1, // coordinates index n = coordinates.length; while (++i < n) { centroid = polygonCentroid(coordinates[i]); x += centroid[0]; y += centroid[1]; z += centroid[2]; } return [x / z, y / z]; } }); function area(coordinates) { return Math.abs(d3.geom.polygon(coordinates.map(projection)).area()); } path.projection = function(x) { projection = x; return path; }; path.pointRadius = function(x) { if (typeof x === "function") pointRadius = x; else { pointRadius = +x; pointCircle = d3_path_circle(pointRadius); } return path; }; return path; }; function d3_path_circle(radius) { return "m0," + radius + "a" + radius + "," + radius + " 0 1,1 0," + (-2 * radius) + "a" + radius + "," + radius + " 0 1,1 0," + (+2 * radius) + "z"; } /** * Given a GeoJSON object, returns the corresponding bounding box. The bounding * box is represented by a two-dimensional array: [[left, bottom], [right, * top]], where left is the minimum longitude, bottom is the minimum latitude, * right is maximum longitude, and top is the maximum latitude. */ d3.geo.bounds = function(feature) { var left = Infinity, bottom = Infinity, right = -Infinity, top = -Infinity; d3_geo_bounds(feature, function(x, y) { if (x < left) left = x; if (x > right) right = x; if (y < bottom) bottom = y; if (y > top) top = y; }); return [[left, bottom], [right, top]]; }; function d3_geo_bounds(o, f) { if (o.type in d3_geo_boundsTypes) d3_geo_boundsTypes[o.type](o, f); } var d3_geo_boundsTypes = { Feature: d3_geo_boundsFeature, FeatureCollection: d3_geo_boundsFeatureCollection, GeometryCollection: d3_geo_boundsGeometryCollection, LineString: d3_geo_boundsLineString, MultiLineString: d3_geo_boundsMultiLineString, MultiPoint: d3_geo_boundsLineString, MultiPolygon: d3_geo_boundsMultiPolygon, Point: d3_geo_boundsPoint, Polygon: d3_geo_boundsPolygon }; function d3_geo_boundsFeature(o, f) { d3_geo_bounds(o.geometry, f); } function d3_geo_boundsFeatureCollection(o, f) { for (var a = o.features, i = 0, n = a.length; i < n; i++) { d3_geo_bounds(a[i].geometry, f); } } function d3_geo_boundsGeometryCollection(o, f) { for (var a = o.geometries, i = 0, n = a.length; i < n; i++) { d3_geo_bounds(a[i], f); } } function d3_geo_boundsLineString(o, f) { for (var a = o.coordinates, i = 0, n = a.length; i < n; i++) { f.apply(null, a[i]); } } function d3_geo_boundsMultiLineString(o, f) { for (var a = o.coordinates, i = 0, n = a.length; i < n; i++) { for (var b = a[i], j = 0, m = b.length; j < m; j++) { f.apply(null, b[j]); } } } function d3_geo_boundsMultiPolygon(o, f) { for (var a = o.coordinates, i = 0, n = a.length; i < n; i++) { for (var b = a[i][0], j = 0, m = b.length; j < m; j++) { f.apply(null, b[j]); } } } function d3_geo_boundsPoint(o, f) { f.apply(null, o.coordinates); } function d3_geo_boundsPolygon(o, f) { for (var a = o.coordinates[0], i = 0, n = a.length; i < n; i++) { f.apply(null, a[i]); } } // TODO breakAtDateLine? d3.geo.circle = function() { var origin = [0, 0], degrees = 90 - 1e-2, radians = degrees * d3_geo_radians, arc = d3.geo.greatArc().target(Object); function circle() { // TODO render a circle as a Polygon } function visible(point) { return arc.distance(point) < radians; } circle.clip = function(d) { arc.source(typeof origin === "function" ? origin.apply(this, arguments) : origin); return clipType(d); }; var clipType = d3_geo_type({ FeatureCollection: function(o) { var features = o.features.map(clipType).filter(Object); return features && (o = Object.create(o), o.features = features, o); }, Feature: function(o) { var geometry = clipType(o.geometry); return geometry && (o = Object.create(o), o.geometry = geometry, o); }, Point: function(o) { return visible(o.coordinates) && o; }, MultiPoint: function(o) { var coordinates = o.coordinates.filter(visible); return coordinates.length && { type: o.type, coordinates: coordinates }; }, LineString: function(o) { var coordinates = clip(o.coordinates); return coordinates.length && (o = Object.create(o), o.coordinates = coordinates, o); }, MultiLineString: function(o) { var coordinates = o.coordinates.map(clip).filter(function(d) { return d.length; }); return coordinates.length && (o = Object.create(o), o.coordinates = coordinates, o); }, Polygon: function(o) { var coordinates = o.coordinates.map(clip); return coordinates[0].length && (o = Object.create(o), o.coordinates = coordinates, o); }, MultiPolygon: function(o) { var coordinates = o.coordinates.map(function(d) { return d.map(clip); }).filter(function(d) { return d[0].length; }); return coordinates.length && (o = Object.create(o), o.coordinates = coordinates, o); }, GeometryCollection: function(o) { var geometries = o.geometries.map(clipType).filter(Object); return geometries.length && (o = Object.create(o), o.geometries = geometries, o); } }); function clip(coordinates) { var i = -1, n = coordinates.length, clipped = [], p0, p1, p2, d0, d1; while (++i < n) { d1 = arc.distance(p2 = coordinates[i]); if (d1 < radians) { if (p1) clipped.push(d3_geo_greatArcInterpolate(p1, p2)((d0 - radians) / (d0 - d1))); clipped.push(p2); p0 = p1 = null; } else { p1 = p2; if (!p0 && clipped.length) { clipped.push(d3_geo_greatArcInterpolate(clipped[clipped.length - 1], p1)((radians - d0) / (d1 - d0))); p0 = p1; } } d0 = d1; } if (p1 && clipped.length) { d1 = arc.distance(p2 = clipped[0]); clipped.push(d3_geo_greatArcInterpolate(p1, p2)((d0 - radians) / (d0 - d1))); } return resample(clipped); } // Resample coordinates, creating great arcs between each. function resample(coordinates) { var i = 0, n = coordinates.length, j, m, resampled = n ? [coordinates[0]] : coordinates, resamples, origin = arc.source(); while (++i < n) { resamples = arc.source(coordinates[i - 1])(coordinates[i]).coordinates; for (j = 0, m = resamples.length; ++j < m;) resampled.push(resamples[j]); } arc.source(origin); return resampled; } circle.origin = function(x) { if (!arguments.length) return origin; origin = x; return circle; }; circle.angle = function(x) { if (!arguments.length) return degrees; radians = (degrees = +x) * d3_geo_radians; return circle; }; // Precision is specified in degrees. circle.precision = function(x) { if (!arguments.length) return arc.precision(); arc.precision(x); return circle; }; return circle; } d3.geo.greatArc = function() { var source = d3_geo_greatArcSource, target = d3_geo_greatArcTarget, precision = 6 * d3_geo_radians; function greatArc() { var a = typeof source === "function" ? source.apply(this, arguments) : source, b = typeof target === "function" ? target.apply(this, arguments) : target, i = d3_geo_greatArcInterpolate(a, b), dt = precision / i.d, t = 0, coordinates = [a]; while ((t += dt) < 1) coordinates.push(i(t)); coordinates.push(b); return { type: "LineString", coordinates: coordinates }; } // Length returned in radians; multiply by radius for distance. greatArc.distance = function() { var a = typeof source === "function" ? source.apply(this, arguments) : source, b = typeof target === "function" ? target.apply(this, arguments) : target; return d3_geo_greatArcInterpolate(a, b).d; }; greatArc.source = function(x) { if (!arguments.length) return source; source = x; return greatArc; }; greatArc.target = function(x) { if (!arguments.length) return target; target = x; return greatArc; }; // Precision is specified in degrees. greatArc.precision = function(x) { if (!arguments.length) return precision / d3_geo_radians; precision = x * d3_geo_radians; return greatArc; }; return greatArc; }; function d3_geo_greatArcSource(d) { return d.source; } function d3_geo_greatArcTarget(d) { return d.target; } function d3_geo_greatArcInterpolate(a, b) { var x0 = a[0] * d3_geo_radians, cx0 = Math.cos(x0), sx0 = Math.sin(x0), y0 = a[1] * d3_geo_radians, cy0 = Math.cos(y0), sy0 = Math.sin(y0), x1 = b[0] * d3_geo_radians, cx1 = Math.cos(x1), sx1 = Math.sin(x1), y1 = b[1] * d3_geo_radians, cy1 = Math.cos(y1), sy1 = Math.sin(y1), d = interpolate.d = Math.acos(Math.max(-1, Math.min(1, sy0 * sy1 + cy0 * cy1 * Math.cos(x1 - x0)))), sd = Math.sin(d); // From http://williams.best.vwh.net/avform.htm#Intermediate function interpolate(t) { var A = Math.sin(d - (t *= d)) / sd, B = Math.sin(t) / sd, x = A * cy0 * cx0 + B * cy1 * cx1, y = A * cy0 * sx0 + B * cy1 * sx1, z = A * sy0 + B * sy1; return [ Math.atan2(y, x) / d3_geo_radians, Math.atan2(z, Math.sqrt(x * x + y * y)) / d3_geo_radians ]; } return interpolate; } d3.geo.greatCircle = d3.geo.circle; })(); science.js-1.9.3/lib/d3/d3.geo.min.js000066400000000000000000000247471256532472600170550ustar00rootroot00000000000000(function(){function b(a,b){return function(c){return c&&c.type in a?a[c.type](c):b}}function c(a){return"m0,"+a+"a"+a+","+a+" 0 1,1 0,"+ -2*a+"a"+a+","+a+" 0 1,1 0,"+2*a+"z"}function d(a,b){a.type in e&&e[a.type](a,b)}function f(a,b){d(a.geometry,b)}function g(a,b){for(var c=a.features,e=0,f=c.length;e50?b:f<-140?c:g<21?d:a)(e)}var a=d3.geo.albers(),b=d3.geo.albers().origin([-160,60]).parallels([55,65]),c=d3.geo.albers().origin([-160,20]).parallels([8,18]),d=d3.geo.albers().origin([-60,10]).parallels([8,18]);return e.scale=function(f){return arguments.length?(a.scale(f),b.scale(f*.6),c.scale(f),d.scale(f*1.5),e.translate(a.translate())):a.scale()},e.translate=function(f){if(!arguments.length)return a.translate();var g=a.scale()/1e3,h=f[0],i=f[1];return a.translate(f),b.translate([h-400*g,i+170*g]),c.translate([h-190*g,i+200*g]),d.translate([h+580*g,i+430*g]),e},e.scale(a.scale())},d3.geo.bonne=function(){function h(h){var i=h[0]*a-d,j=h[1]*a-e;if(f){var k=g+f-j,l=i*Math.cos(j)/k;i=k*Math.sin(l),j=k*Math.cos(l)-g}else i*=Math.cos(j),j*=-1;return[b*i+c[0],b*j+c[1]]}var b=200,c=[480,250],d,e,f,g;return h.invert=function(e){var h=(e[0]-c[0])/b,i=(e[1]-c[1])/b;if(f){var j=g+i,k=Math.sqrt(h*h+j*j);i=g+f-k,h=d+k*Math.atan2(h,j)/Math.cos(i)}else i*=-1,h/=Math.cos(i);return[h/a,i/a]},h.parallel=function(b){return arguments.length?(g=1/Math.tan(f=b*a),h):f/a},h.origin=function(b){return arguments.length?(d=b[0]*a,e=b[1]*a,h):[d/a,e/a]},h.scale=function(a){return arguments.length?(b=+a,h):b},h.translate=function(a){return arguments.length?(c=[+a[0],+a[1]],h):c},h.origin([0,0]).parallel(45)},d3.geo.equirectangular=function(){function c(c){var d=c[0]/360,e=-c[1]/360;return[a*d+b[0],a*e+b[1]]}var a=500,b=[480,250];return c.invert=function(c){var d=(c[0]-b[0])/a,e=(c[1]-b[1])/a;return[360*d,-360*e]},c.scale=function(b){return arguments.length?(a=+b,c):a},c.translate=function(a){return arguments.length?(b=[+a[0],+a[1]],c):b},c},d3.geo.mercator=function(){function d(d){var e=d[0]/360,f=-(Math.log(Math.tan(Math.PI/4+d[1]*a/2))/a)/360;return[b*e+c[0],b*Math.max(-0.5,Math.min(.5,f))+c[1]]}var b=500,c=[480,250];return d.invert=function(d){var e=(d[0]-c[0])/b,f=(d[1]-c[1])/b;return[360*e,2*Math.atan(Math.exp(-360*f*a))/a-90]},d.scale=function(a){return arguments.length?(b=+a,d):b},d.translate=function(a){return arguments.length?(c=[+a[0],+a[1]],d):c},d},d3.geo.path=function(){function f(b,e){return typeof a=="function"&&(d=c(a.apply(this,arguments))),h(b)||null}function g(a){return e(a).join(",")}function j(a){var b=m(a[0]),c=0,d=a.length;while(++c0){b.push("M");while(++h0){b.push("M");while(++ke&&(e=a),df&&(f=d)}),[[b,c],[e,f]]};var e={Feature:f,FeatureCollection:g,GeometryCollection:h,LineString:i,MultiLineString:j,MultiPoint:i,MultiPolygon:k,Point:l,Polygon:m};d3.geo.circle=function(){function g(){}function h(a){return f.distance(a)marching * squares algorithm. Returns the contour polygon as an array of points. * * @param grid a two-input function(x, y) that returns true for values * inside the contour and false for values outside the contour. * @param start an optional starting point [x, y] on the grid. * @returns polygon [[x1, y1], [x2, y2], …] */ d3.geom.contour = function(grid, start) { var s = start || d3_geom_contourStart(grid), // starting point c = [], // contour polygon x = s[0], // current x position y = s[1], // current y position dx = 0, // next x direction dy = 0, // next y direction pdx = NaN, // previous x direction pdy = NaN, // previous y direction i = 0; do { // determine marching squares index i = 0; if (grid(x-1, y-1)) i += 1; if (grid(x, y-1)) i += 2; if (grid(x-1, y )) i += 4; if (grid(x, y )) i += 8; // determine next direction if (i === 6) { dx = pdy === -1 ? -1 : 1; dy = 0; } else if (i === 9) { dx = 0; dy = pdx === 1 ? -1 : 1; } else { dx = d3_geom_contourDx[i]; dy = d3_geom_contourDy[i]; } // update contour polygon if (dx != pdx && dy != pdy) { c.push([x, y]); pdx = dx; pdy = dy; } x += dx; y += dy; } while (s[0] != x || s[1] != y); return c; }; // lookup tables for marching directions var d3_geom_contourDx = [1, 0, 1, 1,-1, 0,-1, 1,0, 0,0,0,-1, 0,-1,NaN], d3_geom_contourDy = [0,-1, 0, 0, 0,-1, 0, 0,1,-1,1,1, 0,-1, 0,NaN]; function d3_geom_contourStart(grid) { var x = 0, y = 0; // search for a starting point; begin at origin // and proceed along outward-expanding diagonals while (true) { if (grid(x,y)) { return [x,y]; } if (x === 0) { x = y + 1; y = 0; } else { x = x - 1; y = y + 1; } } } /** * Computes the 2D convex hull of a set of points using Graham's scanning * algorithm. The algorithm has been implemented as described in Cormen, * Leiserson, and Rivest's Introduction to Algorithms. The running time of * this algorithm is O(n log n), where n is the number of input points. * * @param vertices [[x1, y1], [x2, y2], …] * @returns polygon [[x1, y1], [x2, y2], …] */ d3.geom.hull = function(vertices) { if (vertices.length < 3) return []; var len = vertices.length, plen = len - 1, points = [], stack = [], i, j, h = 0, x1, y1, x2, y2, u, v, a, sp; // find the starting ref point: leftmost point with the minimum y coord for (i=1; i= (x2*x2 + y2*y2)) { points[i].index = -1; } else { points[u].index = -1; a = points[i].angle; u = i; v = j; } } else { a = points[i].angle; u = i; v = j; } } // initialize the stack stack.push(h); for (i=0, j=0; i<2; ++j) { if (points[j].index !== -1) { stack.push(points[j].index); i++; } } sp = stack.length; // do graham's scan for (; j 0; } // Note: requires coordinates to be counterclockwise and convex! d3.geom.polygon = function(coordinates) { coordinates.area = function() { var i = 0, n = coordinates.length, a = coordinates[n - 1][0] * coordinates[0][1], b = coordinates[n - 1][1] * coordinates[0][0]; while (++i < n) { a += coordinates[i - 1][0] * coordinates[i][1]; b += coordinates[i - 1][1] * coordinates[i][0]; } return (b - a) * .5; }; coordinates.centroid = function(k) { var i = -1, n = coordinates.length - 1, x = 0, y = 0, a, b, c; if (!arguments.length) k = -1 / (6 * coordinates.area()); while (++i < n) { a = coordinates[i]; b = coordinates[i + 1]; c = a[0] * b[1] - b[0] * a[1]; x += (a[0] + b[0]) * c; y += (a[1] + b[1]) * c; } return [x * k, y * k]; }; // The Sutherland-Hodgman clipping algorithm. coordinates.clip = function(subject) { var input, i = -1, n = coordinates.length, j, m, a = coordinates[n - 1], b, c, d; while (++i < n) { input = subject.slice(); subject.length = 0; b = coordinates[i]; c = input[(m = input.length) - 1]; j = -1; while (++j < m) { d = input[j]; if (d3_geom_polygonInside(d, a, b)) { if (!d3_geom_polygonInside(c, a, b)) { subject.push(d3_geom_polygonIntersect(c, d, a, b)); } subject.push(d); } else if (d3_geom_polygonInside(c, a, b)) { subject.push(d3_geom_polygonIntersect(c, d, a, b)); } c = d; } a = b; } return subject; }; return coordinates; }; function d3_geom_polygonInside(p, a, b) { return (b[0] - a[0]) * (p[1] - a[1]) < (b[1] - a[1]) * (p[0] - a[0]); } // Intersect two infinite lines cd and ab. function d3_geom_polygonIntersect(c, d, a, b) { var x1 = c[0], x2 = d[0], x3 = a[0], x4 = b[0], y1 = c[1], y2 = d[1], y3 = a[1], y4 = b[1], x13 = x1 - x3, x21 = x2 - x1, x43 = x4 - x3, y13 = y1 - y3, y21 = y2 - y1, y43 = y4 - y3, ua = (x43 * y13 - y43 * x13) / (y43 * x21 - x43 * y21); return [x1 + ua * x21, y1 + ua * y21]; } // Adapted from Nicolas Garcia Belmonte's JIT implementation: // http://blog.thejit.org/2010/02/12/voronoi-tessellation/ // http://blog.thejit.org/assets/voronoijs/voronoi.js // See lib/jit/LICENSE for details. // Notes: // // This implementation does not clip the returned polygons, so if you want to // clip them to a particular shape you will need to do that either in SVG or by // post-processing with d3.geom.polygon's clip method. // // If any vertices are coincident or have NaN positions, the behavior of this // method is undefined. Most likely invalid polygons will be returned. You // should filter invalid points, and consolidate coincident points, before // computing the tessellation. /** * @param vertices [[x1, y1], [x2, y2], …] * @returns polygons [[[x1, y1], [x2, y2], …], …] */ d3.geom.voronoi = function(vertices) { var polygons = vertices.map(function() { return []; }); d3_voronoi_tessellate(vertices, function(e) { var s1, s2, x1, x2, y1, y2; if (e.a === 1 && e.b >= 0) { s1 = e.ep.r; s2 = e.ep.l; } else { s1 = e.ep.l; s2 = e.ep.r; } if (e.a === 1) { y1 = s1 ? s1.y : -1e6; x1 = e.c - e.b * y1; y2 = s2 ? s2.y : 1e6; x2 = e.c - e.b * y2; } else { x1 = s1 ? s1.x : -1e6; y1 = e.c - e.a * x1; x2 = s2 ? s2.x : 1e6; y2 = e.c - e.a * x2; } var v1 = [x1, y1], v2 = [x2, y2]; polygons[e.region.l.index].push(v1, v2); polygons[e.region.r.index].push(v1, v2); }); // Reconnect the polygon segments into counterclockwise loops. return polygons.map(function(polygon, i) { var cx = vertices[i][0], cy = vertices[i][1]; polygon.forEach(function(v) { v.angle = Math.atan2(v[0] - cx, v[1] - cy); }); return polygon.sort(function(a, b) { return a.angle - b.angle; }).filter(function(d, i) { return !i || (d.angle - polygon[i - 1].angle > 1e-10); }); }); }; var d3_voronoi_opposite = {"l": "r", "r": "l"}; function d3_voronoi_tessellate(vertices, callback) { var Sites = { list: vertices .map(function(v, i) { return { index: i, x: v[0], y: v[1] }; }) .sort(function(a, b) { return a.y < b.y ? -1 : a.y > b.y ? 1 : a.x < b.x ? -1 : a.x > b.x ? 1 : 0; }), bottomSite: null }; var EdgeList = { list: [], leftEnd: null, rightEnd: null, init: function() { EdgeList.leftEnd = EdgeList.createHalfEdge(null, "l"); EdgeList.rightEnd = EdgeList.createHalfEdge(null, "l"); EdgeList.leftEnd.r = EdgeList.rightEnd; EdgeList.rightEnd.l = EdgeList.leftEnd; EdgeList.list.unshift(EdgeList.leftEnd, EdgeList.rightEnd); }, createHalfEdge: function(edge, side) { return { edge: edge, side: side, vertex: null, "l": null, "r": null }; }, insert: function(lb, he) { he.l = lb; he.r = lb.r; lb.r.l = he; lb.r = he; }, leftBound: function(p) { var he = EdgeList.leftEnd; do { he = he.r; } while (he != EdgeList.rightEnd && Geom.rightOf(he, p)); he = he.l; return he; }, del: function(he) { he.l.r = he.r; he.r.l = he.l; he.edge = null; }, right: function(he) { return he.r; }, left: function(he) { return he.l; }, leftRegion: function(he) { return he.edge == null ? Sites.bottomSite : he.edge.region[he.side]; }, rightRegion: function(he) { return he.edge == null ? Sites.bottomSite : he.edge.region[d3_voronoi_opposite[he.side]]; } }; var Geom = { bisect: function(s1, s2) { var newEdge = { region: {"l": s1, "r": s2}, ep: {"l": null, "r": null} }; var dx = s2.x - s1.x, dy = s2.y - s1.y, adx = dx > 0 ? dx : -dx, ady = dy > 0 ? dy : -dy; newEdge.c = s1.x * dx + s1.y * dy + (dx * dx + dy * dy) * .5; if (adx > ady) { newEdge.a = 1; newEdge.b = dy / dx; newEdge.c /= dx; } else { newEdge.b = 1; newEdge.a = dx / dy; newEdge.c /= dy; } return newEdge; }, intersect: function(el1, el2) { var e1 = el1.edge, e2 = el2.edge; if (!e1 || !e2 || (e1.region.r == e2.region.r)) { return null; } var d = (e1.a * e2.b) - (e1.b * e2.a); if (Math.abs(d) < 1e-10) { return null; } var xint = (e1.c * e2.b - e2.c * e1.b) / d, yint = (e2.c * e1.a - e1.c * e2.a) / d, e1r = e1.region.r, e2r = e2.region.r, el, e; if ((e1r.y < e2r.y) || (e1r.y == e2r.y && e1r.x < e2r.x)) { el = el1; e = e1; } else { el = el2; e = e2; } var rightOfSite = (xint >= e.region.r.x); if ((rightOfSite && (el.side === "l")) || (!rightOfSite && (el.side === "r"))) { return null; } return { x: xint, y: yint }; }, rightOf: function(he, p) { var e = he.edge, topsite = e.region.r, rightOfSite = (p.x > topsite.x); if (rightOfSite && (he.side === "l")) { return 1; } if (!rightOfSite && (he.side === "r")) { return 0; } if (e.a === 1) { var dyp = p.y - topsite.y, dxp = p.x - topsite.x, fast = 0, above = 0; if ((!rightOfSite && (e.b < 0)) || (rightOfSite && (e.b >= 0))) { above = fast = (dyp >= e.b * dxp); } else { above = ((p.x + p.y * e.b) > e.c); if (e.b < 0) { above = !above; } if (!above) { fast = 1; } } if (!fast) { var dxs = topsite.x - e.region.l.x; above = (e.b * (dxp * dxp - dyp * dyp)) < (dxs * dyp * (1 + 2 * dxp / dxs + e.b * e.b)); if (e.b < 0) { above = !above; } } } else /* e.b == 1 */ { var yl = e.c - e.a * p.x, t1 = p.y - yl, t2 = p.x - topsite.x, t3 = yl - topsite.y; above = (t1 * t1) > (t2 * t2 + t3 * t3); } return he.side === "l" ? above : !above; }, endPoint: function(edge, side, site) { edge.ep[side] = site; if (!edge.ep[d3_voronoi_opposite[side]]) return; callback(edge); }, distance: function(s, t) { var dx = s.x - t.x, dy = s.y - t.y; return Math.sqrt(dx * dx + dy * dy); } }; var EventQueue = { list: [], insert: function(he, site, offset) { he.vertex = site; he.ystar = site.y + offset; for (var i=0, list=EventQueue.list, l=list.length; i next.ystar || (he.ystar == next.ystar && site.x > next.vertex.x)) { continue; } else { break; } } list.splice(i, 0, he); }, del: function(he) { for (var i=0, ls=EventQueue.list, l=ls.length; i top.y) { temp = bot; bot = top; top = temp; pm = "r"; } e = Geom.bisect(bot, top); bisector = EdgeList.createHalfEdge(e, pm); EdgeList.insert(llbnd, bisector); Geom.endPoint(e, d3_voronoi_opposite[pm], v); p = Geom.intersect(llbnd, bisector); if (p) { EventQueue.del(llbnd); EventQueue.insert(llbnd, p, Geom.distance(p, bot)); } p = Geom.intersect(bisector, rrbnd); if (p) { EventQueue.insert(bisector, p, Geom.distance(p, bot)); } } else { break; } }//end while for (lbnd = EdgeList.right(EdgeList.leftEnd); lbnd != EdgeList.rightEnd; lbnd = EdgeList.right(lbnd)) { callback(lbnd.edge); } } /** * @param vertices [[x1, y1], [x2, y2], …] * @returns triangles [[[x1, y1], [x2, y2], [x3, y3]], …] */ d3.geom.delaunay = function(vertices) { var edges = vertices.map(function() { return []; }), triangles = []; // Use the Voronoi tessellation to determine Delaunay edges. d3_voronoi_tessellate(vertices, function(e) { edges[e.region.l.index].push(vertices[e.region.r.index]); }); // Reconnect the edges into counterclockwise triangles. edges.forEach(function(edge, i) { var v = vertices[i], cx = v[0], cy = v[1]; edge.forEach(function(v) { v.angle = Math.atan2(v[0] - cx, v[1] - cy); }); edge.sort(function(a, b) { return a.angle - b.angle; }); for (var j = 0, m = edge.length - 1; j < m; j++) { triangles.push([v, edge[j], edge[j + 1]]); } }); return triangles; }; // Constructs a new quadtree for the specified array of points. A quadtree is a // two-dimensional recursive spatial subdivision. This implementation uses // square partitions, dividing each square into four equally-sized squares. Each // point exists in a unique node; if multiple points are in the same position, // some points may be stored on internal nodes rather than leaf nodes. Quadtrees // can be used to accelerate various spatial operations, such as the Barnes-Hut // approximation for computing n-body forces, or collision detection. d3.geom.quadtree = function(points, x1, y1, x2, y2) { var p, i = -1, n = points.length; // Type conversion for deprecated API. if (n && isNaN(points[0].x)) points = points.map(d3_geom_quadtreePoint); // Allow bounds to be specified explicitly. if (arguments.length < 5) { if (arguments.length === 3) { y2 = x2 = y1; y1 = x1; } else { x1 = y1 = Infinity; x2 = y2 = -Infinity; // Compute bounds. while (++i < n) { p = points[i]; if (p.x < x1) x1 = p.x; if (p.y < y1) y1 = p.y; if (p.x > x2) x2 = p.x; if (p.y > y2) y2 = p.y; } // Squarify the bounds. var dx = x2 - x1, dy = y2 - y1; if (dx > dy) y2 = y1 + dx; else x2 = x1 + dy; } } // Recursively inserts the specified point p at the node n or one of its // descendants. The bounds are defined by [x1, x2] and [y1, y2]. function insert(n, p, x1, y1, x2, y2) { if (isNaN(p.x) || isNaN(p.y)) return; // ignore invalid points if (n.leaf) { var v = n.point; if (v) { // If the point at this leaf node is at the same position as the new // point we are adding, we leave the point associated with the // internal node while adding the new point to a child node. This // avoids infinite recursion. if ((Math.abs(v.x - p.x) + Math.abs(v.y - p.y)) < .01) { insertChild(n, p, x1, y1, x2, y2); } else { n.point = null; insertChild(n, v, x1, y1, x2, y2); insertChild(n, p, x1, y1, x2, y2); } } else { n.point = p; } } else { insertChild(n, p, x1, y1, x2, y2); } } // Recursively inserts the specified point p into a descendant of node n. The // bounds are defined by [x1, x2] and [y1, y2]. function insertChild(n, p, x1, y1, x2, y2) { // Compute the split point, and the quadrant in which to insert p. var sx = (x1 + x2) * .5, sy = (y1 + y2) * .5, right = p.x >= sx, bottom = p.y >= sy, i = (bottom << 1) + right; // Recursively insert into the child node. n.leaf = false; n = n.nodes[i] || (n.nodes[i] = d3_geom_quadtreeNode()); // Update the bounds as we recurse. if (right) x1 = sx; else x2 = sx; if (bottom) y1 = sy; else y2 = sy; insert(n, p, x1, y1, x2, y2); } // Create the root node. var root = d3_geom_quadtreeNode(); root.add = function(p) { insert(root, p, x1, y1, x2, y2); }; root.visit = function(f) { d3_geom_quadtreeVisit(f, root, x1, y1, x2, y2); }; // Insert all points. points.forEach(root.add); return root; }; function d3_geom_quadtreeNode() { return { leaf: true, nodes: [], point: null }; } function d3_geom_quadtreeVisit(f, node, x1, y1, x2, y2) { if (!f(node, x1, y1, x2, y2)) { var sx = (x1 + x2) * .5, sy = (y1 + y2) * .5, children = node.nodes; if (children[0]) d3_geom_quadtreeVisit(f, children[0], x1, y1, sx, sy); if (children[1]) d3_geom_quadtreeVisit(f, children[1], sx, y1, x2, sy); if (children[2]) d3_geom_quadtreeVisit(f, children[2], x1, sy, sx, y2); if (children[3]) d3_geom_quadtreeVisit(f, children[3], sx, sy, x2, y2); } } function d3_geom_quadtreePoint(p) { return { x: p[0], y: p[1] }; } })(); science.js-1.9.3/lib/d3/d3.geom.min.js000066400000000000000000000170621256532472600172220ustar00rootroot00000000000000(function(){function c(a){var b=0,c=0;for(;;){if(a(b,c))return[b,c];b===0?(b=c+1,c=0):(b-=1,c+=1)}}function d(a,b,c,d){var e,f,g,h,i,j,k;return e=d[a],f=e[0],g=e[1],e=d[b],h=e[0],i=e[1],e=d[c],j=e[0],k=e[1],(k-g)*(h-f)-(i-g)*(j-f)>0}function e(a,b,c){return(c[0]-b[0])*(a[1]-b[1])<(c[1]-b[1])*(a[0]-b[0])}function f(a,b,c,d){var e=a[0],f=b[0],g=c[0],h=d[0],i=a[1],j=b[1],k=c[1],l=d[1],m=e-g,n=f-e,o=h-g,p=i-k,q=j-i,r=l-k,s=(o*p-r*m)/(r*n-o*q);return[e+s*n,i+s*q]}function h(a,b){var c={list:a.map(function(a,b){return{index:b,x:a[0],y:a[1]}}).sort(function(a,b){return a.yb.y?1:a.xb.x?1:0}),bottomSite:null},d={list:[],leftEnd:null,rightEnd:null,init:function(){d.leftEnd=d.createHalfEdge(null,"l"),d.rightEnd=d.createHalfEdge(null,"l"),d.leftEnd.r=d.rightEnd,d.rightEnd.l=d.leftEnd,d.list.unshift(d.leftEnd,d.rightEnd)},createHalfEdge:function(a,b){return{edge:a,side:b,vertex:null,l:null,r:null}},insert:function(a,b){b.l=a,b.r=a.r,a.r.l=b,a.r=b},leftBound:function(a){var b=d.leftEnd;do b=b.r;while(b!=d.rightEnd&&e.rightOf(b,a));return b=b.l,b},del:function(a){a.l.r=a.r,a.r.l=a.l,a.edge=null},right:function(a){return a.r},left:function(a){return a.l},leftRegion:function(a){return a.edge==null?c.bottomSite:a.edge.region[a.side]},rightRegion:function(a){return a.edge==null?c.bottomSite:a.edge.region[g[a.side]]}},e={bisect:function(a,b){var c={region:{l:a,r:b},ep:{l:null,r:null}},d=b.x-a.x,e=b.y-a.y,f=d>0?d:-d,g=e>0?e:-e;return c.c=a.x*d+a.y*e+(d*d+e*e)*.5,f>g?(c.a=1,c.b=e/d,c.c/=d):(c.b=1,c.a=d/e,c.c/=e),c},intersect:function(a,b){var c=a.edge,d=b.edge;if(!c||!d||c.region.r==d.region.r)return null;var e=c.a*d.b-c.b*d.a;if(Math.abs(e)<1e-10)return null;var f=(c.c*d.b-d.c*c.b)/e,g=(d.c*c.a-c.c*d.a)/e,h=c.region.r,i=d.region.r,j,k;h.y=k.region.r.x;return l&&j.side==="l"||!l&&j.side==="r"?null:{x:f,y:g}},rightOf:function(a,b){var c=a.edge,d=c.region.r,e=b.x>d.x;if(e&&a.side==="l")return 1;if(!e&&a.side==="r")return 0;if(c.a===1){var f=b.y-d.y,g=b.x-d.x,h=0,i=0;!e&&c.b<0||e&&c.b>=0?i=h=f>=c.b*g:(i=b.x+b.y*c.b>c.c,c.b<0&&(i=!i),i||(h=1));if(!h){var j=d.x-c.region.l.x;i=c.b*(g*g-f*f)m*m+n*n}return a.side==="l"?i:!i},endPoint:function(a,c,d){a.ep[c]=d;if(!a.ep[g[c]])return;b(a)},distance:function(a,b){var c=a.x-b.x,d=a.y-b.y;return Math.sqrt(c*c+d*d)}},f={list:[],insert:function(a,b,c){a.vertex=b,a.ystar=b.y+c;for(var d=0,e=f.list,g=e.length;dh.ystar||a.ystar==h.ystar&&b.x>h.vertex.x)continue;break}e.splice(d,0,a)},del:function(a){for(var b=0,c=f.list,d=c.length;bp.y&&(q=o,o=p,p=q,u="r"),t=e.bisect(o,p),n=d.createHalfEdge(t,u),d.insert(l,n),e.endPoint(t,g[u],s),r=e.intersect(l,n),r&&(f.del(l),f.insert(l,r,e.distance(r,o))),r=e.intersect(n,m),r&&f.insert(n,r,e.distance(r,o));else break}for(j=d.right(d.leftEnd);j!=d.rightEnd;j=d.right(j))b(j.edge)}function i(){return{leaf:!0,nodes:[],point:null}}function j(a,b,c,d,e,f){if(!a(b,c,d,e,f)){var g=(c+e)*.5,h=(d+f)*.5,i=b.nodes;i[0]&&j(a,i[0],c,d,g,h),i[1]&&j(a,i[1],g,d,e,h),i[2]&&j(a,i[2],c,h,g,f),i[3]&&j(a,i[3],g,h,e,f)}}function k(a){return{x:a[0],y:a[1]}}d3.geom={},d3.geom.contour=function(d,e){var f=e||c(d),g=[],h=f[0],i=f[1],j=0,k=0,l=NaN,m=NaN,n=0;do n=0,d(h-1,i-1)&&(n+=1),d(h,i-1)&&(n+=2),d(h-1,i)&&(n+=4),d(h,i)&&(n+=8),n===6?(j=m===-1?-1:1,k=0):n===9?(j=0,k=l===1?-1:1):(j=a[n],k=b[n]),j!=l&&k!=m&&(g.push([h,i]),l=j,m=k),h+=j,i+=k;while(f[0]!=h||f[1]!=i);return g};var a=[1,0,1,1,-1,0,-1,1,0,0,0,0,-1,0,-1,NaN],b=[0,-1,0,0,0,-1,0,0,1,-1,1,1,0,-1,0,NaN];d3.geom.hull=function(a){if(a.length<3)return[];var b=a.length,c=b-1,e=[],f=[],g,h,i=0,j,k,l,m,n,o,p,q;for(g=1;g=l*l+m*m?e[g].index=-1:(e[n].index=-1,p=e[g].angle,n=g,o=h)):(p=e[g].angle,n=g,o=h);f.push(i);for(g=0,h=0;g<2;++h)e[h].index!==-1&&(f.push(e[h].index),g++);q=f.length;for(;h=0?(c=a.ep.r,d=a.ep.l):(c=a.ep.l,d=a.ep.r),a.a===1?(g=c?c.y:-1e6,e=a.c-a.b*g,h=d?d.y:1e6,f=a.c-a.b*h):(e=c?c.x:-1e6,g=a.c-a.a*e,f=d?d.x:1e6,h=a.c-a.a*f);var i=[e,g],j=[f,h];b[a.region.l.index].push(i,j),b[a.region.r.index].push(i,j)}),b.map(function(b,c){var d=a[c][0],e=a[c][1];return b.forEach(function(a){a.angle=Math.atan2(a[0]-d,a[1]-e)}),b.sort(function(a,b){return a.angle-b.angle}).filter(function(a,c){return!c||a.angle-b[c-1].angle>1e-10})})};var g={l:"r",r:"l"};d3.geom.delaunay=function(a){var b=a.map(function(){return[]}),c=[];return h(a,function(c){b[c.region.l.index].push(a[c.region.r.index])}),b.forEach(function(b,d){var e=a[d],f=e[0],g=e[1];b.forEach(function(a){a.angle=Math.atan2(a[0]-f,a[1]-g)}),b.sort(function(a,b){return a.angle-b.angle});for(var h=0,i=b.length-1;h=g,k=b.y>=h,l=(k<<1)+j;a.leaf=!1,a=a.nodes[l]||(a.nodes[l]=i()),j?c=g:e=g,k?d=h:f=h,n(a,b,c,d,e,f)}var f,g=-1,h=a.length;h&&isNaN(a[0].x)&&(a=a.map(k));if(arguments.length<5)if(arguments.length===3)e=d=c,c=b;else{b=c=Infinity,d=e=-Infinity;while(++gd&&(d=f.x),f.y>e&&(e=f.y);var l=d-b,m=e-c;l>m?e=c+l:d=b+m}var p=i();return p.add=function(a){n(p,a,b,c,d,e)},p.visit=function(a){j(a,p,b,c,d,e)},a.forEach(p.add),p}})();science.js-1.9.3/lib/d3/d3.js000066400000000000000000003740571256532472600155240ustar00rootroot00000000000000(function(){if (!Date.now) Date.now = function() { return +new Date; }; try { document.createElement("div").style.setProperty("opacity", 0, ""); } catch (error) { var d3_style_prototype = CSSStyleDeclaration.prototype, d3_style_setProperty = d3_style_prototype.setProperty; d3_style_prototype.setProperty = function(name, value, priority) { d3_style_setProperty.call(this, name, value + "", priority); }; } d3 = {version: "2.7.1"}; // semver var d3_array = d3_arraySlice; // conversion for NodeLists function d3_arrayCopy(pseudoarray) { var i = -1, n = pseudoarray.length, array = []; while (++i < n) array.push(pseudoarray[i]); return array; } function d3_arraySlice(pseudoarray) { return Array.prototype.slice.call(pseudoarray); } try { d3_array(document.documentElement.childNodes)[0].nodeType; } catch(e) { d3_array = d3_arrayCopy; } var d3_arraySubclass = [].__proto__? // Until ECMAScript supports array subclassing, prototype injection works well. function(array, prototype) { array.__proto__ = prototype; }: // And if your browser doesn't support __proto__, we'll use direct extension. function(array, prototype) { for (var property in prototype) array[property] = prototype[property]; }; function d3_this() { return this; } d3.functor = function(v) { return typeof v === "function" ? v : function() { return v; }; }; // Copies a variable number of methods from source to target. d3.rebind = function(target, source) { var i = 1, n = arguments.length, method; while (++i < n) target[method = arguments[i]] = d3_rebind(target, source, source[method]); return target; }; // Method is assumed to be a standard D3 getter-setter: // If passed with no arguments, gets the value. // If passed with arguments, sets the value and returns the target. function d3_rebind(target, source, method) { return function() { var value = method.apply(source, arguments); return arguments.length ? target : value; }; } d3.ascending = function(a, b) { return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN; }; d3.descending = function(a, b) { return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN; }; d3.mean = function(array, f) { var n = array.length, a, m = 0, i = -1, j = 0; if (arguments.length === 1) { while (++i < n) if (d3_number(a = array[i])) m += (a - m) / ++j; } else { while (++i < n) if (d3_number(a = f.call(array, array[i], i))) m += (a - m) / ++j; } return j ? m : undefined; }; d3.median = function(array, f) { if (arguments.length > 1) array = array.map(f); array = array.filter(d3_number); return array.length ? d3.quantile(array.sort(d3.ascending), .5) : undefined; }; d3.min = function(array, f) { var i = -1, n = array.length, a, b; if (arguments.length === 1) { while (++i < n && ((a = array[i]) == null || a != a)) a = undefined; while (++i < n) if ((b = array[i]) != null && a > b) a = b; } else { while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined; while (++i < n) if ((b = f.call(array, array[i], i)) != null && a > b) a = b; } return a; }; d3.max = function(array, f) { var i = -1, n = array.length, a, b; if (arguments.length === 1) { while (++i < n && ((a = array[i]) == null || a != a)) a = undefined; while (++i < n) if ((b = array[i]) != null && b > a) a = b; } else { while (++i < n && ((a = f.call(array, array[i], i)) == null || a != a)) a = undefined; while (++i < n) if ((b = f.call(array, array[i], i)) != null && b > a) a = b; } return a; }; d3.extent = function(array, f) { var i = -1, n = array.length, a, b, c; if (arguments.length === 1) { while (++i < n && ((a = c = array[i]) == null || a != a)) a = c = undefined; while (++i < n) if ((b = array[i]) != null) { if (a > b) a = b; if (c < b) c = b; } } else { while (++i < n && ((a = c = f.call(array, array[i], i)) == null || a != a)) a = undefined; while (++i < n) if ((b = f.call(array, array[i], i)) != null) { if (a > b) a = b; if (c < b) c = b; } } return [a, c]; }; d3.random = { normal: function(mean, deviation) { if (arguments.length < 2) deviation = 1; if (arguments.length < 1) mean = 0; return function() { var x, y, r; do { x = Math.random() * 2 - 1; y = Math.random() * 2 - 1; r = x * x + y * y; } while (!r || r > 1); return mean + deviation * x * Math.sqrt(-2 * Math.log(r) / r); }; } }; function d3_number(x) { return x != null && !isNaN(x); } d3.sum = function(array, f) { var s = 0, n = array.length, a, i = -1; if (arguments.length === 1) { while (++i < n) if (!isNaN(a = +array[i])) s += a; } else { while (++i < n) if (!isNaN(a = +f.call(array, array[i], i))) s += a; } return s; }; // R-7 per d3.quantile = function(values, p) { var H = (values.length - 1) * p + 1, h = Math.floor(H), v = values[h - 1], e = H - h; return e ? v + e * (values[h] - v) : v; }; d3.transpose = function(matrix) { return d3.zip.apply(d3, matrix); }; d3.zip = function() { if (!(n = arguments.length)) return []; for (var i = -1, m = d3.min(arguments, d3_zipLength), zips = new Array(m); ++i < m;) { for (var j = -1, n, zip = zips[i] = new Array(n); ++j < n;) { zip[j] = arguments[j][i]; } } return zips; }; function d3_zipLength(d) { return d.length; } // Locate the insertion point for x in a 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 a, 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 // `array.splice` assuming that a is already sorted. // // The returned insertion point i partitions the array a into two halves so that // all v < x for v in a[lo:i] for the left side and all v >= x for v in a[i:hi] // for the right side. d3.bisectLeft = function(a, x, lo, hi) { if (arguments.length < 3) lo = 0; if (arguments.length < 4) hi = a.length; while (lo < hi) { var mid = (lo + hi) >> 1; if (a[mid] < x) lo = mid + 1; else hi = mid; } return lo; }; // Similar to bisectLeft, but returns an insertion point which comes after (to // the right of) any existing entries of x in a. // // The returned insertion point i partitions the array into two halves so that // all v <= x for v in a[lo:i] for the left side and all v > x for v in a[i:hi] // for the right side. d3.bisect = d3.bisectRight = function(a, x, lo, hi) { if (arguments.length < 3) lo = 0; if (arguments.length < 4) hi = a.length; while (lo < hi) { var mid = (lo + hi) >> 1; if (x < a[mid]) hi = mid; else lo = mid + 1; } return lo; }; d3.first = function(array, f) { var i = 0, n = array.length, a = array[0], b; if (arguments.length === 1) f = d3.ascending; while (++i < n) { if (f.call(array, a, b = array[i]) > 0) { a = b; } } return a; }; d3.last = function(array, f) { var i = 0, n = array.length, a = array[0], b; if (arguments.length === 1) f = d3.ascending; while (++i < n) { if (f.call(array, a, b = array[i]) <= 0) { a = b; } } return a; }; d3.nest = function() { var nest = {}, keys = [], sortKeys = [], sortValues, rollup; function map(array, depth) { if (depth >= keys.length) return rollup ? rollup.call(nest, array) : (sortValues ? array.sort(sortValues) : array); var i = -1, n = array.length, key = keys[depth++], keyValue, object, o = {}; while (++i < n) { if ((keyValue = key(object = array[i])) in o) { o[keyValue].push(object); } else { o[keyValue] = [object]; } } for (keyValue in o) { o[keyValue] = map(o[keyValue], depth); } return o; } function entries(map, depth) { if (depth >= keys.length) return map; var a = [], sortKey = sortKeys[depth++], key; for (key in map) { a.push({key: key, values: entries(map[key], depth)}); } if (sortKey) a.sort(function(a, b) { return sortKey(a.key, b.key); }); return a; } nest.map = function(array) { return map(array, 0); }; nest.entries = function(array) { return entries(map(array, 0), 0); }; nest.key = function(d) { keys.push(d); return nest; }; // Specifies the order for the most-recently specified key. // Note: only applies to entries. Map keys are unordered! nest.sortKeys = function(order) { sortKeys[keys.length - 1] = order; return nest; }; // Specifies the order for leaf values. // Applies to both maps and entries array. nest.sortValues = function(order) { sortValues = order; return nest; }; nest.rollup = function(f) { rollup = f; return nest; }; return nest; }; d3.keys = function(map) { var keys = []; for (var key in map) keys.push(key); return keys; }; d3.values = function(map) { var values = []; for (var key in map) values.push(map[key]); return values; }; d3.entries = function(map) { var entries = []; for (var key in map) entries.push({key: key, value: map[key]}); return entries; }; d3.permute = function(array, indexes) { var permutes = [], i = -1, n = indexes.length; while (++i < n) permutes[i] = array[indexes[i]]; return permutes; }; d3.merge = function(arrays) { return Array.prototype.concat.apply([], arrays); }; d3.split = function(array, f) { var arrays = [], values = [], value, i = -1, n = array.length; if (arguments.length < 2) f = d3_splitter; while (++i < n) { if (f.call(values, value = array[i], i)) { values = []; } else { if (!values.length) arrays.push(values); values.push(value); } } return arrays; }; function d3_splitter(d) { return d == null; } function d3_collapse(s) { return s.replace(/(^\s+)|(\s+$)/g, "").replace(/\s+/g, " "); } /** * @param {number} start * @param {number=} stop * @param {number=} step */ d3.range = function(start, stop, step) { if (arguments.length < 3) { step = 1; if (arguments.length < 2) { stop = start; start = 0; } } if ((stop - start) / step == Infinity) throw new Error("infinite range"); var range = [], i = -1, j; if (step < 0) while ((j = start + step * ++i) > stop) range.push(j); else while ((j = start + step * ++i) < stop) range.push(j); return range; }; d3.requote = function(s) { return s.replace(d3_requote_re, "\\$&"); }; var d3_requote_re = /[\\\^\$\*\+\?\|\[\]\(\)\.\{\}]/g; d3.round = function(x, n) { return n ? Math.round(x * Math.pow(10, n)) * Math.pow(10, -n) : Math.round(x); }; d3.xhr = function(url, mime, callback) { var req = new XMLHttpRequest; if (arguments.length < 3) callback = mime, mime = null; else if (mime && req.overrideMimeType) req.overrideMimeType(mime); req.open("GET", url, true); if (mime) req.setRequestHeader("Accept", mime); req.onreadystatechange = function() { if (req.readyState === 4) callback(req.status < 300 ? req : null); }; req.send(null); }; d3.text = function(url, mime, callback) { function ready(req) { callback(req && req.responseText); } if (arguments.length < 3) { callback = mime; mime = null; } d3.xhr(url, mime, ready); }; d3.json = function(url, callback) { d3.text(url, "application/json", function(text) { callback(text ? JSON.parse(text) : null); }); }; d3.html = function(url, callback) { d3.text(url, "text/html", function(text) { if (text != null) { // Treat empty string as valid HTML. var range = document.createRange(); range.selectNode(document.body); text = range.createContextualFragment(text); } callback(text); }); }; d3.xml = function(url, mime, callback) { function ready(req) { callback(req && req.responseXML); } if (arguments.length < 3) { callback = mime; mime = null; } d3.xhr(url, mime, ready); }; var d3_nsPrefix = { svg: "http://www.w3.org/2000/svg", xhtml: "http://www.w3.org/1999/xhtml", xlink: "http://www.w3.org/1999/xlink", xml: "http://www.w3.org/XML/1998/namespace", xmlns: "http://www.w3.org/2000/xmlns/" }; d3.ns = { prefix: d3_nsPrefix, qualify: function(name) { var i = name.indexOf(":"); return i < 0 ? (name in d3_nsPrefix ? {space: d3_nsPrefix[name], local: name} : name) : {space: d3_nsPrefix[name.substring(0, i)], local: name.substring(i + 1)}; } }; d3.dispatch = function() { var dispatch = new d3_dispatch(), i = -1, n = arguments.length; while (++i < n) dispatch[arguments[i]] = d3_dispatch_event(); return dispatch; }; function d3_dispatch() {} d3_dispatch.prototype.on = function(type, listener) { var i = type.indexOf("."), name = ""; // Extract optional namespace, e.g., "click.foo" if (i > 0) { name = type.substring(i + 1); type = type.substring(0, i); } return arguments.length < 2 ? this[type].on(name) : (this[type].on(name, listener), this); }; function d3_dispatch_event() { var listeners = [], listenerByName = {}; function dispatch() { var z = listeners, // defensive reference i = -1, n = z.length, l; while (++i < n) if (l = z[i].on) l.apply(this, arguments); } dispatch.on = function(name, listener) { var l, i; // return the current listener, if any if (arguments.length < 2) return (l = listenerByName[name]) && l.on; // remove the old listener, if any (with copy-on-write) if (l = listenerByName[name]) { l.on = null; listeners = listeners.slice(0, i = listeners.indexOf(l)).concat(listeners.slice(i + 1)); delete listenerByName[name]; } // add the new listener, if any if (listener) { listeners.push(listenerByName[name] = {on: listener}); } return dispatch; }; return dispatch; }; // TODO align d3.format = function(specifier) { var match = d3_format_re.exec(specifier), fill = match[1] || " ", sign = match[3] || "", zfill = match[5], width = +match[6], comma = match[7], precision = match[8], type = match[9], scale = 1, suffix = "", integer = false; if (precision) precision = +precision.substring(1); if (zfill) { fill = "0"; // TODO align = "="; if (comma) width -= Math.floor((width - 1) / 4); } switch (type) { case "n": comma = true; type = "g"; break; case "%": scale = 100; suffix = "%"; type = "f"; break; case "p": scale = 100; suffix = "%"; type = "r"; break; case "d": integer = true; precision = 0; break; case "s": scale = -1; type = "r"; break; } // If no precision is specified for r, fallback to general notation. if (type == "r" && !precision) type = "g"; type = d3_format_types[type] || d3_format_typeDefault; return function(value) { // Return the empty string for floats formatted as ints. if (integer && (value % 1)) return ""; // Convert negative to positive, and record the sign prefix. var negative = (value < 0) && (value = -value) ? "\u2212" : sign; // Apply the scale, computing it from the value's exponent for si format. if (scale < 0) { var prefix = d3.formatPrefix(value, precision); value *= prefix.scale; suffix = prefix.symbol; } else { value *= scale; } // Convert to the desired precision. value = type(value, precision); // If the fill character is 0, the sign and group is applied after the fill. if (zfill) { var length = value.length + negative.length; if (length < width) value = new Array(width - length + 1).join(fill) + value; if (comma) value = d3_format_group(value); value = negative + value; } // Otherwise (e.g., space-filling), the sign and group is applied before. else { if (comma) value = d3_format_group(value); value = negative + value; var length = value.length; if (length < width) value = new Array(width - length + 1).join(fill) + value; } return value + suffix; }; }; // [[fill]align][sign][#][0][width][,][.precision][type] var d3_format_re = /(?:([^{])?([<>=^]))?([+\- ])?(#)?(0)?([0-9]+)?(,)?(\.[0-9]+)?([a-zA-Z%])?/; var d3_format_types = { g: function(x, p) { return x.toPrecision(p); }, e: function(x, p) { return x.toExponential(p); }, f: function(x, p) { return x.toFixed(p); }, r: function(x, p) { return d3.round(x, p = d3_format_precision(x, p)).toFixed(Math.max(0, Math.min(20, p))); } }; function d3_format_precision(x, p) { return p - (x ? 1 + Math.floor(Math.log(x + Math.pow(10, 1 + Math.floor(Math.log(x) / Math.LN10) - p)) / Math.LN10) : 1); } function d3_format_typeDefault(x) { return x + ""; } // Apply comma grouping for thousands. function d3_format_group(value) { var i = value.lastIndexOf("."), f = i >= 0 ? value.substring(i) : (i = value.length, ""), t = []; while (i > 0) t.push(value.substring(i -= 3, i + 3)); return t.reverse().join(",") + f; } var d3_formatPrefixes = ["y","z","a","f","p","n","μ","m","","k","M","G","T","P","E","Z","Y"].map(d3_formatPrefix); d3.formatPrefix = function(value, precision) { var i = 0; if (value) { if (value < 0) value *= -1; if (precision) value = d3.round(value, d3_format_precision(value, precision)); i = 1 + Math.floor(1e-12 + Math.log(value) / Math.LN10); i = Math.max(-24, Math.min(24, Math.floor((i <= 0 ? i + 1 : i - 1) / 3) * 3)); } return d3_formatPrefixes[8 + i / 3]; }; function d3_formatPrefix(d, i) { return { scale: Math.pow(10, (8 - i) * 3), symbol: d }; } /* * TERMS OF USE - EASING EQUATIONS * * Open source under the BSD License. * * Copyright 2001 Robert Penner * 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. */ var d3_ease_quad = d3_ease_poly(2), d3_ease_cubic = d3_ease_poly(3); var d3_ease = { linear: function() { return d3_ease_linear; }, poly: d3_ease_poly, quad: function() { return d3_ease_quad; }, cubic: function() { return d3_ease_cubic; }, sin: function() { return d3_ease_sin; }, exp: function() { return d3_ease_exp; }, circle: function() { return d3_ease_circle; }, elastic: d3_ease_elastic, back: d3_ease_back, bounce: function() { return d3_ease_bounce; } }; var d3_ease_mode = { "in": function(f) { return f; }, "out": d3_ease_reverse, "in-out": d3_ease_reflect, "out-in": function(f) { return d3_ease_reflect(d3_ease_reverse(f)); } }; d3.ease = function(name) { var i = name.indexOf("-"), t = i >= 0 ? name.substring(0, i) : name, m = i >= 0 ? name.substring(i + 1) : "in"; return d3_ease_clamp(d3_ease_mode[m](d3_ease[t].apply(null, Array.prototype.slice.call(arguments, 1)))); }; function d3_ease_clamp(f) { return function(t) { return t <= 0 ? 0 : t >= 1 ? 1 : f(t); }; } function d3_ease_reverse(f) { return function(t) { return 1 - f(1 - t); }; } function d3_ease_reflect(f) { return function(t) { return .5 * (t < .5 ? f(2 * t) : (2 - f(2 - 2 * t))); }; } function d3_ease_linear(t) { return t; } function d3_ease_poly(e) { return function(t) { return Math.pow(t, e); } } function d3_ease_sin(t) { return 1 - Math.cos(t * Math.PI / 2); } function d3_ease_exp(t) { return Math.pow(2, 10 * (t - 1)); } function d3_ease_circle(t) { return 1 - Math.sqrt(1 - t * t); } function d3_ease_elastic(a, p) { var s; if (arguments.length < 2) p = 0.45; if (arguments.length < 1) { a = 1; s = p / 4; } else s = p / (2 * Math.PI) * Math.asin(1 / a); return function(t) { return 1 + a * Math.pow(2, 10 * -t) * Math.sin((t - s) * 2 * Math.PI / p); }; } function d3_ease_back(s) { if (!s) s = 1.70158; return function(t) { return t * t * ((s + 1) * t - s); }; } function d3_ease_bounce(t) { return t < 1 / 2.75 ? 7.5625 * t * t : t < 2 / 2.75 ? 7.5625 * (t -= 1.5 / 2.75) * t + .75 : t < 2.5 / 2.75 ? 7.5625 * (t -= 2.25 / 2.75) * t + .9375 : 7.5625 * (t -= 2.625 / 2.75) * t + .984375; } d3.event = null; function d3_eventCancel() { d3.event.stopPropagation(); d3.event.preventDefault(); } d3.interpolate = function(a, b) { var i = d3.interpolators.length, f; while (--i >= 0 && !(f = d3.interpolators[i](a, b))); return f; }; d3.interpolateNumber = function(a, b) { b -= a; return function(t) { return a + b * t; }; }; d3.interpolateRound = function(a, b) { b -= a; return function(t) { return Math.round(a + b * t); }; }; d3.interpolateString = function(a, b) { var m, // current match i, // current index j, // current index (for coallescing) s0 = 0, // start index of current string prefix s1 = 0, // end index of current string prefix s = [], // string constants and placeholders q = [], // number interpolators n, // q.length o; // Reset our regular expression! d3_interpolate_number.lastIndex = 0; // Find all numbers in b. for (i = 0; m = d3_interpolate_number.exec(b); ++i) { if (m.index) s.push(b.substring(s0, s1 = m.index)); q.push({i: s.length, x: m[0]}); s.push(null); s0 = d3_interpolate_number.lastIndex; } if (s0 < b.length) s.push(b.substring(s0)); // Find all numbers in a. for (i = 0, n = q.length; (m = d3_interpolate_number.exec(a)) && i < n; ++i) { o = q[i]; if (o.x == m[0]) { // The numbers match, so coallesce. if (o.i) { if (s[o.i + 1] == null) { // This match is followed by another number. s[o.i - 1] += o.x; s.splice(o.i, 1); for (j = i + 1; j < n; ++j) q[j].i--; } else { // This match is followed by a string, so coallesce twice. s[o.i - 1] += o.x + s[o.i + 1]; s.splice(o.i, 2); for (j = i + 1; j < n; ++j) q[j].i -= 2; } } else { if (s[o.i + 1] == null) { // This match is followed by another number. s[o.i] = o.x; } else { // This match is followed by a string, so coallesce twice. s[o.i] = o.x + s[o.i + 1]; s.splice(o.i + 1, 1); for (j = i + 1; j < n; ++j) q[j].i--; } } q.splice(i, 1); n--; i--; } else { o.x = d3.interpolateNumber(parseFloat(m[0]), parseFloat(o.x)); } } // Remove any numbers in b not found in a. while (i < n) { o = q.pop(); if (s[o.i + 1] == null) { // This match is followed by another number. s[o.i] = o.x; } else { // This match is followed by a string, so coallesce twice. s[o.i] = o.x + s[o.i + 1]; s.splice(o.i + 1, 1); } n--; } // Special optimization for only a single match. if (s.length === 1) { return s[0] == null ? q[0].x : function() { return b; }; } // Otherwise, interpolate each of the numbers and rejoin the string. return function(t) { for (i = 0; i < n; ++i) s[(o = q[i]).i] = o.x(t); return s.join(""); }; }; d3.interpolateTransform = function(a, b) { return d3.interpolateString(d3.transform(a) + "", d3.transform(b) + ""); }; d3.interpolateRgb = function(a, b) { a = d3.rgb(a); b = d3.rgb(b); var ar = a.r, ag = a.g, ab = a.b, br = b.r - ar, bg = b.g - ag, bb = b.b - ab; return function(t) { return "#" + d3_rgb_hex(Math.round(ar + br * t)) + d3_rgb_hex(Math.round(ag + bg * t)) + d3_rgb_hex(Math.round(ab + bb * t)); }; }; // interpolates HSL space, but outputs RGB string (for compatibility) d3.interpolateHsl = function(a, b) { a = d3.hsl(a); b = d3.hsl(b); var h0 = a.h, s0 = a.s, l0 = a.l, h1 = b.h - h0, s1 = b.s - s0, l1 = b.l - l0; return function(t) { return d3_hsl_rgb(h0 + h1 * t, s0 + s1 * t, l0 + l1 * t).toString(); }; }; d3.interpolateArray = function(a, b) { var x = [], c = [], na = a.length, nb = b.length, n0 = Math.min(a.length, b.length), i; for (i = 0; i < n0; ++i) x.push(d3.interpolate(a[i], b[i])); for (; i < na; ++i) c[i] = a[i]; for (; i < nb; ++i) c[i] = b[i]; return function(t) { for (i = 0; i < n0; ++i) c[i] = x[i](t); return c; }; }; d3.interpolateObject = function(a, b) { var i = {}, c = {}, k; for (k in a) { if (k in b) { i[k] = d3_interpolateByName(k)(a[k], b[k]); } else { c[k] = a[k]; } } for (k in b) { if (!(k in a)) { c[k] = b[k]; } } return function(t) { for (k in i) c[k] = i[k](t); return c; }; } var d3_interpolate_number = /[-+]?(?:\d*\.?\d+)(?:[eE][-+]?\d+)?/g; function d3_interpolateByName(n) { return n == "transform" ? d3.interpolateTransform : d3.interpolate; } d3.interpolators = [ d3.interpolateObject, function(a, b) { return (b instanceof Array) && d3.interpolateArray(a, b); }, function(a, b) { return (typeof a === "string" || typeof b === "string") && d3.interpolateString(a + "", b + ""); }, function(a, b) { return (typeof b === "string" ? b in d3_rgb_names || /^(#|rgb\(|hsl\()/.test(b) : b instanceof d3_Rgb || b instanceof d3_Hsl) && d3.interpolateRgb(a, b); }, function(a, b) { return !isNaN(a = +a) && !isNaN(b = +b) && d3.interpolateNumber(a, b); } ]; function d3_uninterpolateNumber(a, b) { b = b - (a = +a) ? 1 / (b - a) : 0; return function(x) { return (x - a) * b; }; } function d3_uninterpolateClamp(a, b) { b = b - (a = +a) ? 1 / (b - a) : 0; return function(x) { return Math.max(0, Math.min(1, (x - a) * b)); }; } d3.rgb = function(r, g, b) { return arguments.length === 1 ? (r instanceof d3_Rgb ? d3_rgb(r.r, r.g, r.b) : d3_rgb_parse("" + r, d3_rgb, d3_hsl_rgb)) : d3_rgb(~~r, ~~g, ~~b); }; function d3_rgb(r, g, b) { return new d3_Rgb(r, g, b); } function d3_Rgb(r, g, b) { this.r = r; this.g = g; this.b = b; } d3_Rgb.prototype.brighter = function(k) { k = Math.pow(0.7, arguments.length ? k : 1); var r = this.r, g = this.g, b = this.b, i = 30; if (!r && !g && !b) return d3_rgb(i, i, i); if (r && r < i) r = i; if (g && g < i) g = i; if (b && b < i) b = i; return d3_rgb( Math.min(255, Math.floor(r / k)), Math.min(255, Math.floor(g / k)), Math.min(255, Math.floor(b / k))); }; d3_Rgb.prototype.darker = function(k) { k = Math.pow(0.7, arguments.length ? k : 1); return d3_rgb( Math.floor(k * this.r), Math.floor(k * this.g), Math.floor(k * this.b)); }; d3_Rgb.prototype.hsl = function() { return d3_rgb_hsl(this.r, this.g, this.b); }; d3_Rgb.prototype.toString = function() { return "#" + d3_rgb_hex(this.r) + d3_rgb_hex(this.g) + d3_rgb_hex(this.b); }; function d3_rgb_hex(v) { return v < 0x10 ? "0" + Math.max(0, v).toString(16) : Math.min(255, v).toString(16); } function d3_rgb_parse(format, rgb, hsl) { var r = 0, // red channel; int in [0, 255] g = 0, // green channel; int in [0, 255] b = 0, // blue channel; int in [0, 255] m1, // CSS color specification match m2, // CSS color specification type (e.g., rgb) name; /* Handle hsl, rgb. */ m1 = /([a-z]+)\((.*)\)/i.exec(format); if (m1) { m2 = m1[2].split(","); switch (m1[1]) { case "hsl": { return hsl( parseFloat(m2[0]), // degrees parseFloat(m2[1]) / 100, // percentage parseFloat(m2[2]) / 100 // percentage ); } case "rgb": { return rgb( d3_rgb_parseNumber(m2[0]), d3_rgb_parseNumber(m2[1]), d3_rgb_parseNumber(m2[2]) ); } } } /* Named colors. */ if (name = d3_rgb_names[format]) return rgb(name.r, name.g, name.b); /* Hexadecimal colors: #rgb and #rrggbb. */ if (format != null && format.charAt(0) === "#") { if (format.length === 4) { r = format.charAt(1); r += r; g = format.charAt(2); g += g; b = format.charAt(3); b += b; } else if (format.length === 7) { r = format.substring(1, 3); g = format.substring(3, 5); b = format.substring(5, 7); } r = parseInt(r, 16); g = parseInt(g, 16); b = parseInt(b, 16); } return rgb(r, g, b); } function d3_rgb_hsl(r, g, b) { var min = Math.min(r /= 255, g /= 255, b /= 255), max = Math.max(r, g, b), d = max - min, h, s, l = (max + min) / 2; if (d) { s = l < .5 ? d / (max + min) : d / (2 - max - min); if (r == max) h = (g - b) / d + (g < b ? 6 : 0); else if (g == max) h = (b - r) / d + 2; else h = (r - g) / d + 4; h *= 60; } else { s = h = 0; } return d3_hsl(h, s, l); } function d3_rgb_parseNumber(c) { // either integer or percentage var f = parseFloat(c); return c.charAt(c.length - 1) === "%" ? Math.round(f * 2.55) : f; } var d3_rgb_names = { aliceblue: "#f0f8ff", antiquewhite: "#faebd7", aqua: "#00ffff", aquamarine: "#7fffd4", azure: "#f0ffff", beige: "#f5f5dc", bisque: "#ffe4c4", black: "#000000", blanchedalmond: "#ffebcd", blue: "#0000ff", blueviolet: "#8a2be2", brown: "#a52a2a", burlywood: "#deb887", cadetblue: "#5f9ea0", chartreuse: "#7fff00", chocolate: "#d2691e", coral: "#ff7f50", cornflowerblue: "#6495ed", cornsilk: "#fff8dc", crimson: "#dc143c", cyan: "#00ffff", darkblue: "#00008b", darkcyan: "#008b8b", darkgoldenrod: "#b8860b", darkgray: "#a9a9a9", darkgreen: "#006400", darkgrey: "#a9a9a9", darkkhaki: "#bdb76b", darkmagenta: "#8b008b", darkolivegreen: "#556b2f", darkorange: "#ff8c00", darkorchid: "#9932cc", darkred: "#8b0000", darksalmon: "#e9967a", darkseagreen: "#8fbc8f", darkslateblue: "#483d8b", darkslategray: "#2f4f4f", darkslategrey: "#2f4f4f", darkturquoise: "#00ced1", darkviolet: "#9400d3", deeppink: "#ff1493", deepskyblue: "#00bfff", dimgray: "#696969", dimgrey: "#696969", dodgerblue: "#1e90ff", firebrick: "#b22222", floralwhite: "#fffaf0", forestgreen: "#228b22", fuchsia: "#ff00ff", gainsboro: "#dcdcdc", ghostwhite: "#f8f8ff", gold: "#ffd700", goldenrod: "#daa520", gray: "#808080", green: "#008000", greenyellow: "#adff2f", grey: "#808080", honeydew: "#f0fff0", hotpink: "#ff69b4", indianred: "#cd5c5c", indigo: "#4b0082", ivory: "#fffff0", khaki: "#f0e68c", lavender: "#e6e6fa", lavenderblush: "#fff0f5", lawngreen: "#7cfc00", lemonchiffon: "#fffacd", lightblue: "#add8e6", lightcoral: "#f08080", lightcyan: "#e0ffff", lightgoldenrodyellow: "#fafad2", lightgray: "#d3d3d3", lightgreen: "#90ee90", lightgrey: "#d3d3d3", lightpink: "#ffb6c1", lightsalmon: "#ffa07a", lightseagreen: "#20b2aa", lightskyblue: "#87cefa", lightslategray: "#778899", lightslategrey: "#778899", lightsteelblue: "#b0c4de", lightyellow: "#ffffe0", lime: "#00ff00", limegreen: "#32cd32", linen: "#faf0e6", magenta: "#ff00ff", maroon: "#800000", mediumaquamarine: "#66cdaa", mediumblue: "#0000cd", mediumorchid: "#ba55d3", mediumpurple: "#9370db", mediumseagreen: "#3cb371", mediumslateblue: "#7b68ee", mediumspringgreen: "#00fa9a", mediumturquoise: "#48d1cc", mediumvioletred: "#c71585", midnightblue: "#191970", mintcream: "#f5fffa", mistyrose: "#ffe4e1", moccasin: "#ffe4b5", navajowhite: "#ffdead", navy: "#000080", oldlace: "#fdf5e6", olive: "#808000", olivedrab: "#6b8e23", orange: "#ffa500", orangered: "#ff4500", orchid: "#da70d6", palegoldenrod: "#eee8aa", palegreen: "#98fb98", paleturquoise: "#afeeee", palevioletred: "#db7093", papayawhip: "#ffefd5", peachpuff: "#ffdab9", peru: "#cd853f", pink: "#ffc0cb", plum: "#dda0dd", powderblue: "#b0e0e6", purple: "#800080", red: "#ff0000", rosybrown: "#bc8f8f", royalblue: "#4169e1", saddlebrown: "#8b4513", salmon: "#fa8072", sandybrown: "#f4a460", seagreen: "#2e8b57", seashell: "#fff5ee", sienna: "#a0522d", silver: "#c0c0c0", skyblue: "#87ceeb", slateblue: "#6a5acd", slategray: "#708090", slategrey: "#708090", snow: "#fffafa", springgreen: "#00ff7f", steelblue: "#4682b4", tan: "#d2b48c", teal: "#008080", thistle: "#d8bfd8", tomato: "#ff6347", turquoise: "#40e0d0", violet: "#ee82ee", wheat: "#f5deb3", white: "#ffffff", whitesmoke: "#f5f5f5", yellow: "#ffff00", yellowgreen: "#9acd32" }; for (var d3_rgb_name in d3_rgb_names) { d3_rgb_names[d3_rgb_name] = d3_rgb_parse( d3_rgb_names[d3_rgb_name], d3_rgb, d3_hsl_rgb); } d3.hsl = function(h, s, l) { return arguments.length === 1 ? (h instanceof d3_Hsl ? d3_hsl(h.h, h.s, h.l) : d3_rgb_parse("" + h, d3_rgb_hsl, d3_hsl)) : d3_hsl(+h, +s, +l); }; function d3_hsl(h, s, l) { return new d3_Hsl(h, s, l); } function d3_Hsl(h, s, l) { this.h = h; this.s = s; this.l = l; } d3_Hsl.prototype.brighter = function(k) { k = Math.pow(0.7, arguments.length ? k : 1); return d3_hsl(this.h, this.s, this.l / k); }; d3_Hsl.prototype.darker = function(k) { k = Math.pow(0.7, arguments.length ? k : 1); return d3_hsl(this.h, this.s, k * this.l); }; d3_Hsl.prototype.rgb = function() { return d3_hsl_rgb(this.h, this.s, this.l); }; d3_Hsl.prototype.toString = function() { return this.rgb().toString(); }; function d3_hsl_rgb(h, s, l) { var m1, m2; /* Some simple corrections for h, s and l. */ h = h % 360; if (h < 0) h += 360; s = s < 0 ? 0 : s > 1 ? 1 : s; l = l < 0 ? 0 : l > 1 ? 1 : l; /* From FvD 13.37, CSS Color Module Level 3 */ m2 = l <= .5 ? l * (1 + s) : l + s - l * s; m1 = 2 * l - m2; function v(h) { if (h > 360) h -= 360; else if (h < 0) h += 360; if (h < 60) return m1 + (m2 - m1) * h / 60; if (h < 180) return m2; if (h < 240) return m1 + (m2 - m1) * (240 - h) / 60; return m1; } function vv(h) { return Math.round(v(h) * 255); } return d3_rgb(vv(h + 120), vv(h), vv(h - 120)); } function d3_selection(groups) { d3_arraySubclass(groups, d3_selectionPrototype); return groups; } var d3_select = function(s, n) { return n.querySelector(s); }, d3_selectAll = function(s, n) { return n.querySelectorAll(s); }, d3_selectRoot = document.documentElement, d3_selectMatcher = d3_selectRoot.matchesSelector || d3_selectRoot.webkitMatchesSelector || d3_selectRoot.mozMatchesSelector || d3_selectRoot.msMatchesSelector || d3_selectRoot.oMatchesSelector, d3_selectMatches = function(n, s) { return d3_selectMatcher.call(n, s); }; // Prefer Sizzle, if available. if (typeof Sizzle === "function") { d3_select = function(s, n) { return Sizzle(s, n)[0]; }; d3_selectAll = function(s, n) { return Sizzle.uniqueSort(Sizzle(s, n)); }; d3_selectMatches = Sizzle.matchesSelector; } var d3_selectionPrototype = []; d3.selection = function() { return d3_selectionRoot; }; d3.selection.prototype = d3_selectionPrototype; d3_selectionPrototype.select = function(selector) { var subgroups = [], subgroup, subnode, group, node; if (typeof selector !== "function") selector = d3_selection_selector(selector); for (var j = -1, m = this.length; ++j < m;) { subgroups.push(subgroup = []); subgroup.parentNode = (group = this[j]).parentNode; for (var i = -1, n = group.length; ++i < n;) { if (node = group[i]) { subgroup.push(subnode = selector.call(node, node.__data__, i)); if (subnode && "__data__" in node) subnode.__data__ = node.__data__; } else { subgroup.push(null); } } } return d3_selection(subgroups); }; function d3_selection_selector(selector) { return function() { return d3_select(selector, this); }; } d3_selectionPrototype.selectAll = function(selector) { var subgroups = [], subgroup, node; if (typeof selector !== "function") selector = d3_selection_selectorAll(selector); for (var j = -1, m = this.length; ++j < m;) { for (var group = this[j], i = -1, n = group.length; ++i < n;) { if (node = group[i]) { subgroups.push(subgroup = d3_array(selector.call(node, node.__data__, i))); subgroup.parentNode = node; } } } return d3_selection(subgroups); }; function d3_selection_selectorAll(selector) { return function() { return d3_selectAll(selector, this); }; } d3_selectionPrototype.attr = function(name, value) { name = d3.ns.qualify(name); // If no value is specified, return the first value. if (arguments.length < 2) { var node = this.node(); return name.local ? node.getAttributeNS(name.space, name.local) : node.getAttribute(name); } function attrNull() { this.removeAttribute(name); } function attrNullNS() { this.removeAttributeNS(name.space, name.local); } function attrConstant() { this.setAttribute(name, value); } function attrConstantNS() { this.setAttributeNS(name.space, name.local, value); } function attrFunction() { var x = value.apply(this, arguments); if (x == null) this.removeAttribute(name); else this.setAttribute(name, x); } function attrFunctionNS() { var x = value.apply(this, arguments); if (x == null) this.removeAttributeNS(name.space, name.local); else this.setAttributeNS(name.space, name.local, x); } return this.each(value == null ? (name.local ? attrNullNS : attrNull) : (typeof value === "function" ? (name.local ? attrFunctionNS : attrFunction) : (name.local ? attrConstantNS : attrConstant))); }; d3_selectionPrototype.classed = function(name, value) { var names = name.split(d3_selection_classedWhitespace), n = names.length, i = -1; if (arguments.length > 1) { while (++i < n) d3_selection_classed.call(this, names[i], value); return this; } else { while (++i < n) if (!d3_selection_classed.call(this, names[i])) return false; return true; } }; var d3_selection_classedWhitespace = /\s+/g; function d3_selection_classed(name, value) { var re = new RegExp("(^|\\s+)" + d3.requote(name) + "(\\s+|$)", "g"); // If no value is specified, return the first value. if (arguments.length < 2) { var node = this.node(); if (c = node.classList) return c.contains(name); var c = node.className; re.lastIndex = 0; return re.test(c.baseVal != null ? c.baseVal : c); } function classedAdd() { if (c = this.classList) return c.add(name); var c = this.className, cb = c.baseVal != null, cv = cb ? c.baseVal : c; re.lastIndex = 0; if (!re.test(cv)) { cv = d3_collapse(cv + " " + name); if (cb) c.baseVal = cv; else this.className = cv; } } function classedRemove() { if (c = this.classList) return c.remove(name); var c = this.className, cb = c.baseVal != null, cv = cb ? c.baseVal : c; cv = d3_collapse(cv.replace(re, " ")); if (cb) c.baseVal = cv; else this.className = cv; } function classedFunction() { (value.apply(this, arguments) ? classedAdd : classedRemove).call(this); } return this.each(typeof value === "function" ? classedFunction : value ? classedAdd : classedRemove); } d3_selectionPrototype.style = function(name, value, priority) { if (arguments.length < 3) priority = ""; // If no value is specified, return the first value. if (arguments.length < 2) return window .getComputedStyle(this.node(), null) .getPropertyValue(name); function styleNull() { this.style.removeProperty(name); } function styleConstant() { this.style.setProperty(name, value, priority); } function styleFunction() { var x = value.apply(this, arguments); if (x == null) this.style.removeProperty(name); else this.style.setProperty(name, x, priority); } return this.each(value == null ? styleNull : (typeof value === "function" ? styleFunction : styleConstant)); }; d3_selectionPrototype.property = function(name, value) { // If no value is specified, return the first value. if (arguments.length < 2) return this.node()[name]; function propertyNull() { delete this[name]; } function propertyConstant() { this[name] = value; } function propertyFunction() { var x = value.apply(this, arguments); if (x == null) delete this[name]; else this[name] = x; } return this.each(value == null ? propertyNull : (typeof value === "function" ? propertyFunction : propertyConstant)); }; d3_selectionPrototype.text = function(value) { return arguments.length < 1 ? this.node().textContent : this.each(typeof value === "function" ? function() { var v = value.apply(this, arguments); this.textContent = v == null ? "" : v; } : value == null ? function() { this.textContent = ""; } : function() { this.textContent = value; }); }; d3_selectionPrototype.html = function(value) { return arguments.length < 1 ? this.node().innerHTML : this.each(typeof value === "function" ? function() { var v = value.apply(this, arguments); this.innerHTML = v == null ? "" : v; } : value == null ? function() { this.innerHTML = ""; } : function() { this.innerHTML = value; }); }; // TODO append(node)? // TODO append(function)? d3_selectionPrototype.append = function(name) { name = d3.ns.qualify(name); function append() { return this.appendChild(document.createElementNS(this.namespaceURI, name)); } function appendNS() { return this.appendChild(document.createElementNS(name.space, name.local)); } return this.select(name.local ? appendNS : append); }; // TODO insert(node, function)? // TODO insert(function, string)? // TODO insert(function, function)? d3_selectionPrototype.insert = function(name, before) { name = d3.ns.qualify(name); function insert() { return this.insertBefore( document.createElementNS(this.namespaceURI, name), d3_select(before, this)); } function insertNS() { return this.insertBefore( document.createElementNS(name.space, name.local), d3_select(before, this)); } return this.select(name.local ? insertNS : insert); }; // TODO remove(selector)? // TODO remove(node)? // TODO remove(function)? d3_selectionPrototype.remove = function() { return this.each(function() { var parent = this.parentNode; if (parent) parent.removeChild(this); }); }; // TODO data(null) for clearing data? d3_selectionPrototype.data = function(data, join) { var enter = [], update = [], exit = []; function bind(group, groupData) { var i, n = group.length, m = groupData.length, n0 = Math.min(n, m), n1 = Math.max(n, m), updateNodes = [], enterNodes = [], exitNodes = [], node, nodeData; if (join) { var nodeByKey = {}, keys = [], key, j = groupData.length; for (i = -1; ++i < n;) { key = join.call(node = group[i], node.__data__, i); if (key in nodeByKey) { exitNodes[j++] = node; // duplicate key } else { nodeByKey[key] = node; } keys.push(key); } for (i = -1; ++i < m;) { node = nodeByKey[key = join.call(groupData, nodeData = groupData[i], i)]; if (node) { node.__data__ = nodeData; updateNodes[i] = node; enterNodes[i] = exitNodes[i] = null; } else { enterNodes[i] = d3_selection_dataNode(nodeData); updateNodes[i] = exitNodes[i] = null; } delete nodeByKey[key]; } for (i = -1; ++i < n;) { if (keys[i] in nodeByKey) { exitNodes[i] = group[i]; } } } else { for (i = -1; ++i < n0;) { node = group[i]; nodeData = groupData[i]; if (node) { node.__data__ = nodeData; updateNodes[i] = node; enterNodes[i] = exitNodes[i] = null; } else { enterNodes[i] = d3_selection_dataNode(nodeData); updateNodes[i] = exitNodes[i] = null; } } for (; i < m; ++i) { enterNodes[i] = d3_selection_dataNode(groupData[i]); updateNodes[i] = exitNodes[i] = null; } for (; i < n1; ++i) { exitNodes[i] = group[i]; enterNodes[i] = updateNodes[i] = null; } } enterNodes.update = updateNodes; enterNodes.parentNode = updateNodes.parentNode = exitNodes.parentNode = group.parentNode; enter.push(enterNodes); update.push(updateNodes); exit.push(exitNodes); } var i = -1, n = this.length, group; if (typeof data === "function") { while (++i < n) { bind(group = this[i], data.call(group, group.parentNode.__data__, i)); } } else { while (++i < n) { bind(group = this[i], data); } } var selection = d3_selection(update); selection.enter = function() { return d3_selection_enter(enter); }; selection.exit = function() { return d3_selection(exit); }; return selection; }; function d3_selection_dataNode(data) { return {__data__: data}; } d3_selectionPrototype.filter = function(filter) { var subgroups = [], subgroup, group, node; if (typeof filter !== "function") filter = d3_selection_filter(filter); for (var j = 0, m = this.length; j < m; j++) { subgroups.push(subgroup = []); subgroup.parentNode = (group = this[j]).parentNode; for (var i = 0, n = group.length; i < n; i++) { if ((node = group[i]) && filter.call(node, node.__data__, i)) { subgroup.push(node); } } } return d3_selection(subgroups); }; function d3_selection_filter(selector) { return function() { return d3_selectMatches(this, selector); }; } d3_selectionPrototype.map = function(map) { return this.each(function() { this.__data__ = map.apply(this, arguments); }); }; d3_selectionPrototype.order = function() { for (var j = -1, m = this.length; ++j < m;) { for (var group = this[j], i = group.length - 1, next = group[i], node; --i >= 0;) { if (node = group[i]) { if (next) next.parentNode.insertBefore(node, next); next = node; } } } return this; }; d3_selectionPrototype.sort = function(comparator) { comparator = d3_selection_sortComparator.apply(this, arguments); for (var j = -1, m = this.length; ++j < m;) this[j].sort(comparator); return this.order(); }; function d3_selection_sortComparator(comparator) { if (!arguments.length) comparator = d3.ascending; return function(a, b) { return comparator(a && a.__data__, b && b.__data__); }; } // type can be namespaced, e.g., "click.foo" // listener can be null for removal d3_selectionPrototype.on = function(type, listener, capture) { if (arguments.length < 3) capture = false; // parse the type specifier var name = "__on" + type, i = type.indexOf("."); if (i > 0) type = type.substring(0, i); // if called with only one argument, return the current listener if (arguments.length < 2) return (i = this.node()[name]) && i._; // remove the old event listener, and add the new event listener return this.each(function(d, i) { var node = this; if (node[name]) node.removeEventListener(type, node[name], capture); if (listener) node.addEventListener(type, node[name] = l, capture); // wrapped event listener that preserves i function l(e) { var o = d3.event; // Events can be reentrant (e.g., focus). d3.event = e; try { listener.call(node, node.__data__, i); } finally { d3.event = o; } } // stash the unwrapped listener for retrieval l._ = listener; }); }; d3_selectionPrototype.each = function(callback) { for (var j = -1, m = this.length; ++j < m;) { for (var group = this[j], i = -1, n = group.length; ++i < n;) { var node = group[i]; if (node) callback.call(node, node.__data__, i, j); } } return this; }; // // Note: assigning to the arguments array simultaneously changes the value of // the corresponding argument! // // TODO The `this` argument probably shouldn't be the first argument to the // callback, anyway, since it's redundant. However, that will require a major // version bump due to backwards compatibility, so I'm not changing it right // away. // d3_selectionPrototype.call = function(callback) { callback.apply(this, (arguments[0] = this, arguments)); return this; }; d3_selectionPrototype.empty = function() { return !this.node(); }; d3_selectionPrototype.node = function(callback) { for (var j = 0, m = this.length; j < m; j++) { for (var group = this[j], i = 0, n = group.length; i < n; i++) { var node = group[i]; if (node) return node; } } return null; }; d3_selectionPrototype.transition = function() { var subgroups = [], subgroup, node; for (var j = -1, m = this.length; ++j < m;) { subgroups.push(subgroup = []); for (var group = this[j], i = -1, n = group.length; ++i < n;) { subgroup.push((node = group[i]) ? {node: node, delay: 0, duration: 250} : null); } } return d3_transition(subgroups, d3_transitionInheritId || ++d3_transitionId, Date.now()); }; var d3_selectionRoot = d3_selection([[document]]); d3_selectionRoot[0].parentNode = d3_selectRoot; // TODO fast singleton implementation! // TODO select(function) d3.select = function(selector) { return typeof selector === "string" ? d3_selectionRoot.select(selector) : d3_selection([[selector]]); // assume node }; // TODO selectAll(function) d3.selectAll = function(selector) { return typeof selector === "string" ? d3_selectionRoot.selectAll(selector) : d3_selection([d3_array(selector)]); // assume node[] }; function d3_selection_enter(selection) { d3_arraySubclass(selection, d3_selection_enterPrototype); return selection; } var d3_selection_enterPrototype = []; d3_selection_enterPrototype.append = d3_selectionPrototype.append; d3_selection_enterPrototype.insert = d3_selectionPrototype.insert; d3_selection_enterPrototype.empty = d3_selectionPrototype.empty; d3_selection_enterPrototype.node = d3_selectionPrototype.node; d3_selection_enterPrototype.select = function(selector) { var subgroups = [], subgroup, subnode, upgroup, group, node; for (var j = -1, m = this.length; ++j < m;) { upgroup = (group = this[j]).update; subgroups.push(subgroup = []); subgroup.parentNode = group.parentNode; for (var i = -1, n = group.length; ++i < n;) { if (node = group[i]) { subgroup.push(upgroup[i] = subnode = selector.call(group.parentNode, node.__data__, i)); subnode.__data__ = node.__data__; } else { subgroup.push(null); } } } return d3_selection(subgroups); }; function d3_transition(groups, id, time) { d3_arraySubclass(groups, d3_transitionPrototype); var tweens = {}, event = d3.dispatch("start", "end"), ease = d3_transitionEase; groups.id = id; groups.time = time; groups.tween = function(name, tween) { if (arguments.length < 2) return tweens[name]; if (tween == null) delete tweens[name]; else tweens[name] = tween; return groups; }; groups.ease = function(value) { if (!arguments.length) return ease; ease = typeof value === "function" ? value : d3.ease.apply(d3, arguments); return groups; }; groups.each = function(type, listener) { if (arguments.length < 2) return d3_transition_each.call(groups, type); event.on(type, listener); return groups; }; d3.timer(function(elapsed) { groups.each(function(d, i, j) { var tweened = [], node = this, delay = groups[j][i].delay, duration = groups[j][i].duration, lock = node.__transition__ || (node.__transition__ = {active: 0, count: 0}); ++lock.count; delay <= elapsed ? start(elapsed) : d3.timer(start, delay, time); function start(elapsed) { if (lock.active > id) return stop(); lock.active = id; for (var tween in tweens) { if (tween = tweens[tween].call(node, d, i)) { tweened.push(tween); } } event.start.call(node, d, i); if (!tick(elapsed)) d3.timer(tick, 0, time); return 1; } function tick(elapsed) { if (lock.active !== id) return stop(); var t = (elapsed - delay) / duration, e = ease(t), n = tweened.length; while (n > 0) { tweened[--n].call(node, e); } if (t >= 1) { stop(); d3_transitionInheritId = id; event.end.call(node, d, i); d3_transitionInheritId = 0; return 1; } } function stop() { if (!--lock.count) delete node.__transition__; return 1; } }); return 1; }, 0, time); return groups; } var d3_transitionRemove = {}; function d3_transitionNull(d, i, a) { return a != "" && d3_transitionRemove; } function d3_transitionTween(name, b) { var interpolate = d3_interpolateByName(name); function transitionFunction(d, i, a) { var v = b.call(this, d, i); return v == null ? a != "" && d3_transitionRemove : a != v && interpolate(a, v); } function transitionString(d, i, a) { return a != b && interpolate(a, b); } return typeof b === "function" ? transitionFunction : b == null ? d3_transitionNull : (b += "", transitionString); } var d3_transitionPrototype = [], d3_transitionId = 0, d3_transitionInheritId = 0, d3_transitionEase = d3.ease("cubic-in-out"); d3_transitionPrototype.call = d3_selectionPrototype.call; d3.transition = function() { return d3_selectionRoot.transition(); }; d3.transition.prototype = d3_transitionPrototype; d3_transitionPrototype.select = function(selector) { var subgroups = [], subgroup, subnode, node; if (typeof selector !== "function") selector = d3_selection_selector(selector); for (var j = -1, m = this.length; ++j < m;) { subgroups.push(subgroup = []); for (var group = this[j], i = -1, n = group.length; ++i < n;) { if ((node = group[i]) && (subnode = selector.call(node.node, node.node.__data__, i))) { if ("__data__" in node.node) subnode.__data__ = node.node.__data__; subgroup.push({node: subnode, delay: node.delay, duration: node.duration}); } else { subgroup.push(null); } } } return d3_transition(subgroups, this.id, this.time).ease(this.ease()); }; d3_transitionPrototype.selectAll = function(selector) { var subgroups = [], subgroup, subnodes, node; if (typeof selector !== "function") selector = d3_selection_selectorAll(selector); for (var j = -1, m = this.length; ++j < m;) { for (var group = this[j], i = -1, n = group.length; ++i < n;) { if (node = group[i]) { subnodes = selector.call(node.node, node.node.__data__, i); subgroups.push(subgroup = []); for (var k = -1, o = subnodes.length; ++k < o;) { subgroup.push({node: subnodes[k], delay: node.delay, duration: node.duration}); } } } } return d3_transition(subgroups, this.id, this.time).ease(this.ease()); }; d3_transitionPrototype.attr = function(name, value) { return this.attrTween(name, d3_transitionTween(name, value)); }; d3_transitionPrototype.attrTween = function(nameNS, tween) { var name = d3.ns.qualify(nameNS); function attrTween(d, i) { var f = tween.call(this, d, i, this.getAttribute(name)); return f === d3_transitionRemove ? (this.removeAttribute(name), null) : f && function(t) { this.setAttribute(name, f(t)); }; } function attrTweenNS(d, i) { var f = tween.call(this, d, i, this.getAttributeNS(name.space, name.local)); return f === d3_transitionRemove ? (this.removeAttributeNS(name.space, name.local), null) : f && function(t) { this.setAttributeNS(name.space, name.local, f(t)); }; } return this.tween("attr." + nameNS, name.local ? attrTweenNS : attrTween); }; d3_transitionPrototype.style = function(name, value, priority) { if (arguments.length < 3) priority = ""; return this.styleTween(name, d3_transitionTween(name, value), priority); }; d3_transitionPrototype.styleTween = function(name, tween, priority) { if (arguments.length < 3) priority = ""; return this.tween("style." + name, function(d, i) { var f = tween.call(this, d, i, window.getComputedStyle(this, null).getPropertyValue(name)); return f === d3_transitionRemove ? (this.style.removeProperty(name), null) : f && function(t) { this.style.setProperty(name, f(t), priority); }; }); }; d3_transitionPrototype.text = function(value) { return this.tween("text", function(d, i) { this.textContent = typeof value === "function" ? value.call(this, d, i) : value; }); }; d3_transitionPrototype.remove = function() { return this.each("end", function() { var p; if (!this.__transition__ && (p = this.parentNode)) p.removeChild(this); }); }; d3_transitionPrototype.delay = function(value) { var groups = this; return groups.each(typeof value === "function" ? function(d, i, j) { groups[j][i].delay = +value.apply(this, arguments); } : (value = +value, function(d, i, j) { groups[j][i].delay = value; })); }; d3_transitionPrototype.duration = function(value) { var groups = this; return groups.each(typeof value === "function" ? function(d, i, j) { groups[j][i].duration = +value.apply(this, arguments); } : (value = +value, function(d, i, j) { groups[j][i].duration = value; })); }; function d3_transition_each(callback) { for (var j = 0, m = this.length; j < m; j++) { for (var group = this[j], i = 0, n = group.length; i < n; i++) { var node = group[i]; if (node) callback.call(node = node.node, node.__data__, i, j); } } return this; } d3_transitionPrototype.transition = function() { return this.select(d3_this); }; var d3_timer_queue = null, d3_timer_interval, // is an interval (or frame) active? d3_timer_timeout; // is a timeout active? // The timer will continue to fire until callback returns true. d3.timer = function(callback, delay, then) { var found = false, t0, t1 = d3_timer_queue; if (arguments.length < 3) { if (arguments.length < 2) delay = 0; else if (!isFinite(delay)) return; then = Date.now(); } // See if the callback's already in the queue. while (t1) { if (t1.callback === callback) { t1.then = then; t1.delay = delay; found = true; break; } t0 = t1; t1 = t1.next; } // Otherwise, add the callback to the queue. if (!found) d3_timer_queue = { callback: callback, then: then, delay: delay, next: d3_timer_queue }; // Start animatin'! if (!d3_timer_interval) { d3_timer_timeout = clearTimeout(d3_timer_timeout); d3_timer_interval = 1; d3_timer_frame(d3_timer_step); } } function d3_timer_step() { var elapsed, now = Date.now(), t1 = d3_timer_queue; while (t1) { elapsed = now - t1.then; if (elapsed >= t1.delay) t1.flush = t1.callback(elapsed); t1 = t1.next; } var delay = d3_timer_flush() - now; if (delay > 24) { if (isFinite(delay)) { clearTimeout(d3_timer_timeout); d3_timer_timeout = setTimeout(d3_timer_step, delay); } d3_timer_interval = 0; } else { d3_timer_interval = 1; d3_timer_frame(d3_timer_step); } } d3.timer.flush = function() { var elapsed, now = Date.now(), t1 = d3_timer_queue; while (t1) { elapsed = now - t1.then; if (!t1.delay) t1.flush = t1.callback(elapsed); t1 = t1.next; } d3_timer_flush(); }; // Flush after callbacks, to avoid concurrent queue modification. function d3_timer_flush() { var t0 = null, t1 = d3_timer_queue, then = Infinity; while (t1) { if (t1.flush) { t1 = t0 ? t0.next = t1.next : d3_timer_queue = t1.next; } else { then = Math.min(then, t1.then + t1.delay); t1 = (t0 = t1).next; } } return then; } var d3_timer_frame = window.requestAnimationFrame || window.webkitRequestAnimationFrame || window.mozRequestAnimationFrame || window.oRequestAnimationFrame || window.msRequestAnimationFrame || function(callback) { setTimeout(callback, 17); }; d3.transform = function(string) { var g = document.createElementNS(d3.ns.prefix.svg, "g"), identity = {a: 1, b: 0, c: 0, d: 1, e: 0, f: 0}; return (d3.transform = function(string) { g.setAttribute("transform", string); var t = g.transform.baseVal.consolidate(); return new d3_transform(t ? t.matrix : identity); })(string); }; // Compute x-scale and normalize the first row. // Compute shear and make second row orthogonal to first. // Compute y-scale and normalize the second row. // Finally, compute the rotation. function d3_transform(m) { var r0 = [m.a, m.b], r1 = [m.c, m.d], kx = d3_transformNormalize(r0), kz = d3_transformDot(r0, r1), ky = d3_transformNormalize(d3_transformCombine(r1, r0, -kz)) || 0; if (r0[0] * r1[1] < r1[0] * r0[1]) { r0[0] *= -1; r0[1] *= -1; kx *= -1; kz *= -1; } this.rotate = (kx ? Math.atan2(r0[1], r0[0]) : Math.atan2(-r1[0], r1[1])) * d3_transformDegrees; this.translate = [m.e, m.f]; this.scale = [kx, ky]; this.skew = ky ? Math.atan2(kz, ky) * d3_transformDegrees : 0; }; d3_transform.prototype.toString = function() { return "translate(" + this.translate + ")rotate(" + this.rotate + ")skewX(" + this.skew + ")scale(" + this.scale + ")"; }; function d3_transformDot(a, b) { return a[0] * b[0] + a[1] * b[1]; } function d3_transformNormalize(a) { var k = Math.sqrt(d3_transformDot(a, a)); if (k) { a[0] /= k; a[1] /= k; } return k; } function d3_transformCombine(a, b, k) { a[0] += k * b[0]; a[1] += k * b[1]; return a; } var d3_transformDegrees = 180 / Math.PI; function d3_noop() {} d3.scale = {}; function d3_scaleExtent(domain) { var start = domain[0], stop = domain[domain.length - 1]; return start < stop ? [start, stop] : [stop, start]; } function d3_scaleRange(scale) { return scale.rangeExtent ? scale.rangeExtent() : d3_scaleExtent(scale.range()); } function d3_scale_nice(domain, nice) { var i0 = 0, i1 = domain.length - 1, x0 = domain[i0], x1 = domain[i1], dx; if (x1 < x0) { dx = i0; i0 = i1; i1 = dx; dx = x0; x0 = x1; x1 = dx; } if (dx = x1 - x0) { nice = nice(dx); domain[i0] = nice.floor(x0); domain[i1] = nice.ceil(x1); } return domain; } function d3_scale_niceDefault() { return Math; } d3.scale.linear = function() { return d3_scale_linear([0, 1], [0, 1], d3.interpolate, false); }; function d3_scale_linear(domain, range, interpolate, clamp) { var output, input; function rescale() { var linear = domain.length == 2 ? d3_scale_bilinear : d3_scale_polylinear, uninterpolate = clamp ? d3_uninterpolateClamp : d3_uninterpolateNumber; output = linear(domain, range, uninterpolate, interpolate); input = linear(range, domain, uninterpolate, d3.interpolate); return scale; } function scale(x) { return output(x); } // Note: requires range is coercible to number! scale.invert = function(y) { return input(y); }; scale.domain = function(x) { if (!arguments.length) return domain; domain = x.map(Number); return rescale(); }; scale.range = function(x) { if (!arguments.length) return range; range = x; return rescale(); }; scale.rangeRound = function(x) { return scale.range(x).interpolate(d3.interpolateRound); }; scale.clamp = function(x) { if (!arguments.length) return clamp; clamp = x; return rescale(); }; scale.interpolate = function(x) { if (!arguments.length) return interpolate; interpolate = x; return rescale(); }; scale.ticks = function(m) { return d3_scale_linearTicks(domain, m); }; scale.tickFormat = function(m) { return d3_scale_linearTickFormat(domain, m); }; scale.nice = function() { d3_scale_nice(domain, d3_scale_linearNice); return rescale(); }; scale.copy = function() { return d3_scale_linear(domain, range, interpolate, clamp); }; return rescale(); }; function d3_scale_linearRebind(scale, linear) { return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp"); } function d3_scale_linearNice(dx) { dx = Math.pow(10, Math.round(Math.log(dx) / Math.LN10) - 1); return { floor: function(x) { return Math.floor(x / dx) * dx; }, ceil: function(x) { return Math.ceil(x / dx) * dx; } }; } // TODO Dates? Ugh. function d3_scale_linearTickRange(domain, m) { var extent = d3_scaleExtent(domain), span = extent[1] - extent[0], step = Math.pow(10, Math.floor(Math.log(span / m) / Math.LN10)), err = m / span * step; // Filter ticks to get closer to the desired count. if (err <= .15) step *= 10; else if (err <= .35) step *= 5; else if (err <= .75) step *= 2; // Round start and stop values to step interval. extent[0] = Math.ceil(extent[0] / step) * step; extent[1] = Math.floor(extent[1] / step) * step + step * .5; // inclusive extent[2] = step; return extent; } function d3_scale_linearTicks(domain, m) { return d3.range.apply(d3, d3_scale_linearTickRange(domain, m)); } function d3_scale_linearTickFormat(domain, m) { return d3.format(",." + Math.max(0, -Math.floor(Math.log(d3_scale_linearTickRange(domain, m)[2]) / Math.LN10 + .01)) + "f"); } function d3_scale_bilinear(domain, range, uninterpolate, interpolate) { var u = uninterpolate(domain[0], domain[1]), i = interpolate(range[0], range[1]); return function(x) { return i(u(x)); }; } function d3_scale_polylinear(domain, range, uninterpolate, interpolate) { var u = [], i = [], j = 0, n = domain.length; while (++j < n) { u.push(uninterpolate(domain[j - 1], domain[j])); i.push(interpolate(range[j - 1], range[j])); } return function(x) { var j = d3.bisect(domain, x, 1, domain.length - 1) - 1; return i[j](u[j](x)); }; } d3.scale.log = function() { return d3_scale_log(d3.scale.linear(), d3_scale_logp); }; function d3_scale_log(linear, log) { var pow = log.pow; function scale(x) { return linear(log(x)); } scale.invert = function(x) { return pow(linear.invert(x)); }; scale.domain = function(x) { if (!arguments.length) return linear.domain().map(pow); log = x[0] < 0 ? d3_scale_logn : d3_scale_logp; pow = log.pow; linear.domain(x.map(log)); return scale; }; scale.nice = function() { linear.domain(d3_scale_nice(linear.domain(), d3_scale_niceDefault)); return scale; }; scale.ticks = function() { var extent = d3_scaleExtent(linear.domain()), ticks = []; if (extent.every(isFinite)) { var i = Math.floor(extent[0]), j = Math.ceil(extent[1]), u = pow(extent[0]), v = pow(extent[1]); if (log === d3_scale_logn) { ticks.push(pow(i)); for (; i++ < j;) for (var k = 9; k > 0; k--) ticks.push(pow(i) * k); } else { for (; i < j; i++) for (var k = 1; k < 10; k++) ticks.push(pow(i) * k); ticks.push(pow(i)); } for (i = 0; ticks[i] < u; i++) {} // strip small values for (j = ticks.length; ticks[j - 1] > v; j--) {} // strip big values ticks = ticks.slice(i, j); } return ticks; }; scale.tickFormat = function(n, format) { if (arguments.length < 2) format = d3_scale_logFormat; if (arguments.length < 1) return format; var k = n / scale.ticks().length, f = log === d3_scale_logn ? (e = -1e-12, Math.floor) : (e = 1e-12, Math.ceil), e; return function(d) { return d / pow(f(log(d) + e)) < k ? format(d) : ""; }; }; scale.copy = function() { return d3_scale_log(linear.copy(), log); }; return d3_scale_linearRebind(scale, linear); }; var d3_scale_logFormat = d3.format(".0e"); function d3_scale_logp(x) { return Math.log(x) / Math.LN10; } function d3_scale_logn(x) { return -Math.log(-x) / Math.LN10; } d3_scale_logp.pow = function(x) { return Math.pow(10, x); }; d3_scale_logn.pow = function(x) { return -Math.pow(10, -x); }; d3.scale.pow = function() { return d3_scale_pow(d3.scale.linear(), 1); }; function d3_scale_pow(linear, exponent) { var powp = d3_scale_powPow(exponent), powb = d3_scale_powPow(1 / exponent); function scale(x) { return linear(powp(x)); } scale.invert = function(x) { return powb(linear.invert(x)); }; scale.domain = function(x) { if (!arguments.length) return linear.domain().map(powb); linear.domain(x.map(powp)); return scale; }; scale.ticks = function(m) { return d3_scale_linearTicks(scale.domain(), m); }; scale.tickFormat = function(m) { return d3_scale_linearTickFormat(scale.domain(), m); }; scale.nice = function() { return scale.domain(d3_scale_nice(scale.domain(), d3_scale_linearNice)); }; scale.exponent = function(x) { if (!arguments.length) return exponent; var domain = scale.domain(); powp = d3_scale_powPow(exponent = x); powb = d3_scale_powPow(1 / exponent); return scale.domain(domain); }; scale.copy = function() { return d3_scale_pow(linear.copy(), exponent); }; return d3_scale_linearRebind(scale, linear); }; function d3_scale_powPow(e) { return function(x) { return x < 0 ? -Math.pow(-x, e) : Math.pow(x, e); }; } d3.scale.sqrt = function() { return d3.scale.pow().exponent(.5); }; d3.scale.ordinal = function() { return d3_scale_ordinal([], {t: "range", x: []}); }; function d3_scale_ordinal(domain, ranger) { var index, range, rangeBand; function scale(x) { return range[((index[x] || (index[x] = domain.push(x))) - 1) % range.length]; } function steps(start, step) { return d3.range(domain.length).map(function(i) { return start + step * i; }); } scale.domain = function(x) { if (!arguments.length) return domain; domain = []; index = {}; var i = -1, n = x.length, xi; while (++i < n) if (!index[xi = x[i]]) index[xi] = domain.push(xi); return scale[ranger.t](ranger.x, ranger.p); }; scale.range = function(x) { if (!arguments.length) return range; range = x; rangeBand = 0; ranger = {t: "range", x: x}; return scale; }; scale.rangePoints = function(x, padding) { if (arguments.length < 2) padding = 0; var start = x[0], stop = x[1], step = (stop - start) / (domain.length - 1 + padding); range = steps(domain.length < 2 ? (start + stop) / 2 : start + step * padding / 2, step); rangeBand = 0; ranger = {t: "rangePoints", x: x, p: padding}; return scale; }; scale.rangeBands = function(x, padding) { if (arguments.length < 2) padding = 0; var start = x[0], stop = x[1], step = (stop - start) / (domain.length + padding); range = steps(start + step * padding, step); rangeBand = step * (1 - padding); ranger = {t: "rangeBands", x: x, p: padding}; return scale; }; scale.rangeRoundBands = function(x, padding) { if (arguments.length < 2) padding = 0; var start = x[0], stop = x[1], step = Math.floor((stop - start) / (domain.length + padding)); range = steps(start + Math.round((stop - start - (domain.length - padding) * step) / 2), step); rangeBand = Math.round(step * (1 - padding)); ranger = {t: "rangeRoundBands", x: x, p: padding}; return scale; }; scale.rangeBand = function() { return rangeBand; }; scale.rangeExtent = function() { return ranger.t === "range" ? d3_scaleExtent(ranger.x) : ranger.x; }; scale.copy = function() { return d3_scale_ordinal(domain, ranger); }; return scale.domain(domain); }; /* * This product includes color specifications and designs developed by Cynthia * Brewer (http://colorbrewer.org/). See lib/colorbrewer for more information. */ d3.scale.category10 = function() { return d3.scale.ordinal().range(d3_category10); }; d3.scale.category20 = function() { return d3.scale.ordinal().range(d3_category20); }; d3.scale.category20b = function() { return d3.scale.ordinal().range(d3_category20b); }; d3.scale.category20c = function() { return d3.scale.ordinal().range(d3_category20c); }; var d3_category10 = [ "#1f77b4", "#ff7f0e", "#2ca02c", "#d62728", "#9467bd", "#8c564b", "#e377c2", "#7f7f7f", "#bcbd22", "#17becf" ]; var d3_category20 = [ "#1f77b4", "#aec7e8", "#ff7f0e", "#ffbb78", "#2ca02c", "#98df8a", "#d62728", "#ff9896", "#9467bd", "#c5b0d5", "#8c564b", "#c49c94", "#e377c2", "#f7b6d2", "#7f7f7f", "#c7c7c7", "#bcbd22", "#dbdb8d", "#17becf", "#9edae5" ]; var d3_category20b = [ "#393b79", "#5254a3", "#6b6ecf", "#9c9ede", "#637939", "#8ca252", "#b5cf6b", "#cedb9c", "#8c6d31", "#bd9e39", "#e7ba52", "#e7cb94", "#843c39", "#ad494a", "#d6616b", "#e7969c", "#7b4173", "#a55194", "#ce6dbd", "#de9ed6" ]; var d3_category20c = [ "#3182bd", "#6baed6", "#9ecae1", "#c6dbef", "#e6550d", "#fd8d3c", "#fdae6b", "#fdd0a2", "#31a354", "#74c476", "#a1d99b", "#c7e9c0", "#756bb1", "#9e9ac8", "#bcbddc", "#dadaeb", "#636363", "#969696", "#bdbdbd", "#d9d9d9" ]; d3.scale.quantile = function() { return d3_scale_quantile([], []); }; function d3_scale_quantile(domain, range) { var thresholds; function rescale() { var k = 0, n = domain.length, q = range.length; thresholds = []; while (++k < q) thresholds[k - 1] = d3.quantile(domain, k / q); return scale; } function scale(x) { if (isNaN(x = +x)) return NaN; return range[d3.bisect(thresholds, x)]; } scale.domain = function(x) { if (!arguments.length) return domain; domain = x.filter(function(d) { return !isNaN(d); }).sort(d3.ascending); return rescale(); }; scale.range = function(x) { if (!arguments.length) return range; range = x; return rescale(); }; scale.quantiles = function() { return thresholds; }; scale.copy = function() { return d3_scale_quantile(domain, range); // copy on write! }; return rescale(); }; d3.scale.quantize = function() { return d3_scale_quantize(0, 1, [0, 1]); }; function d3_scale_quantize(x0, x1, range) { var kx, i; function scale(x) { return range[Math.max(0, Math.min(i, Math.floor(kx * (x - x0))))]; } function rescale() { kx = range.length / (x1 - x0); i = range.length - 1; return scale; } scale.domain = function(x) { if (!arguments.length) return [x0, x1]; x0 = +x[0]; x1 = +x[x.length - 1]; return rescale(); }; scale.range = function(x) { if (!arguments.length) return range; range = x; return rescale(); }; scale.copy = function() { return d3_scale_quantize(x0, x1, range); // copy on write }; return rescale(); }; d3.svg = {}; d3.svg.arc = function() { var innerRadius = d3_svg_arcInnerRadius, outerRadius = d3_svg_arcOuterRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle; function arc() { var r0 = innerRadius.apply(this, arguments), r1 = outerRadius.apply(this, arguments), a0 = startAngle.apply(this, arguments) + d3_svg_arcOffset, a1 = endAngle.apply(this, arguments) + d3_svg_arcOffset, da = (a1 < a0 && (da = a0, a0 = a1, a1 = da), a1 - a0), df = da < Math.PI ? "0" : "1", c0 = Math.cos(a0), s0 = Math.sin(a0), c1 = Math.cos(a1), s1 = Math.sin(a1); return da >= d3_svg_arcMax ? (r0 ? "M0," + r1 + "A" + r1 + "," + r1 + " 0 1,1 0," + (-r1) + "A" + r1 + "," + r1 + " 0 1,1 0," + r1 + "M0," + r0 + "A" + r0 + "," + r0 + " 0 1,0 0," + (-r0) + "A" + r0 + "," + r0 + " 0 1,0 0," + r0 + "Z" : "M0," + r1 + "A" + r1 + "," + r1 + " 0 1,1 0," + (-r1) + "A" + r1 + "," + r1 + " 0 1,1 0," + r1 + "Z") : (r0 ? "M" + r1 * c0 + "," + r1 * s0 + "A" + r1 + "," + r1 + " 0 " + df + ",1 " + r1 * c1 + "," + r1 * s1 + "L" + r0 * c1 + "," + r0 * s1 + "A" + r0 + "," + r0 + " 0 " + df + ",0 " + r0 * c0 + "," + r0 * s0 + "Z" : "M" + r1 * c0 + "," + r1 * s0 + "A" + r1 + "," + r1 + " 0 " + df + ",1 " + r1 * c1 + "," + r1 * s1 + "L0,0" + "Z"); } arc.innerRadius = function(v) { if (!arguments.length) return innerRadius; innerRadius = d3.functor(v); return arc; }; arc.outerRadius = function(v) { if (!arguments.length) return outerRadius; outerRadius = d3.functor(v); return arc; }; arc.startAngle = function(v) { if (!arguments.length) return startAngle; startAngle = d3.functor(v); return arc; }; arc.endAngle = function(v) { if (!arguments.length) return endAngle; endAngle = d3.functor(v); return arc; }; arc.centroid = function() { var r = (innerRadius.apply(this, arguments) + outerRadius.apply(this, arguments)) / 2, a = (startAngle.apply(this, arguments) + endAngle.apply(this, arguments)) / 2 + d3_svg_arcOffset; return [Math.cos(a) * r, Math.sin(a) * r]; }; return arc; }; var d3_svg_arcOffset = -Math.PI / 2, d3_svg_arcMax = 2 * Math.PI - 1e-6; function d3_svg_arcInnerRadius(d) { return d.innerRadius; } function d3_svg_arcOuterRadius(d) { return d.outerRadius; } function d3_svg_arcStartAngle(d) { return d.startAngle; } function d3_svg_arcEndAngle(d) { return d.endAngle; } function d3_svg_line(projection) { var x = d3_svg_lineX, y = d3_svg_lineY, interpolate = "linear", interpolator = d3_svg_lineInterpolators[interpolate], tension = .7; function line(d) { return d.length < 1 ? null : "M" + interpolator(projection(d3_svg_linePoints(this, d, x, y)), tension); } line.x = function(v) { if (!arguments.length) return x; x = v; return line; }; line.y = function(v) { if (!arguments.length) return y; y = v; return line; }; line.interpolate = function(v) { if (!arguments.length) return interpolate; interpolator = d3_svg_lineInterpolators[interpolate = v]; return line; }; line.tension = function(v) { if (!arguments.length) return tension; tension = v; return line; }; return line; } d3.svg.line = function() { return d3_svg_line(Object); }; // Converts the specified array of data into an array of points // (x-y tuples), by evaluating the specified `x` and `y` functions on each // data point. The `this` context of the evaluated functions is the specified // "self" object; each function is passed the current datum and index. function d3_svg_linePoints(self, d, x, y) { var points = [], i = -1, n = d.length, fx = typeof x === "function", fy = typeof y === "function", value; if (fx && fy) { while (++i < n) points.push([ x.call(self, value = d[i], i), y.call(self, value, i) ]); } else if (fx) { while (++i < n) points.push([x.call(self, d[i], i), y]); } else if (fy) { while (++i < n) points.push([x, y.call(self, d[i], i)]); } else { while (++i < n) points.push([x, y]); } return points; } // The default `x` property, which references d[0]. function d3_svg_lineX(d) { return d[0]; } // The default `y` property, which references d[1]. function d3_svg_lineY(d) { return d[1]; } // The various interpolators supported by the `line` class. var d3_svg_lineInterpolators = { "linear": d3_svg_lineLinear, "step-before": d3_svg_lineStepBefore, "step-after": d3_svg_lineStepAfter, "basis": d3_svg_lineBasis, "basis-open": d3_svg_lineBasisOpen, "basis-closed": d3_svg_lineBasisClosed, "bundle": d3_svg_lineBundle, "cardinal": d3_svg_lineCardinal, "cardinal-open": d3_svg_lineCardinalOpen, "cardinal-closed": d3_svg_lineCardinalClosed, "monotone": d3_svg_lineMonotone }; // Linear interpolation; generates "L" commands. function d3_svg_lineLinear(points) { var i = 0, n = points.length, p = points[0], path = [p[0], ",", p[1]]; while (++i < n) path.push("L", (p = points[i])[0], ",", p[1]); return path.join(""); } // Step interpolation; generates "H" and "V" commands. function d3_svg_lineStepBefore(points) { var i = 0, n = points.length, p = points[0], path = [p[0], ",", p[1]]; while (++i < n) path.push("V", (p = points[i])[1], "H", p[0]); return path.join(""); } // Step interpolation; generates "H" and "V" commands. function d3_svg_lineStepAfter(points) { var i = 0, n = points.length, p = points[0], path = [p[0], ",", p[1]]; while (++i < n) path.push("H", (p = points[i])[0], "V", p[1]); return path.join(""); } // Open cardinal spline interpolation; generates "C" commands. function d3_svg_lineCardinalOpen(points, tension) { return points.length < 4 ? d3_svg_lineLinear(points) : points[1] + d3_svg_lineHermite(points.slice(1, points.length - 1), d3_svg_lineCardinalTangents(points, tension)); } // Closed cardinal spline interpolation; generates "C" commands. function d3_svg_lineCardinalClosed(points, tension) { return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite((points.push(points[0]), points), d3_svg_lineCardinalTangents([points[points.length - 2]] .concat(points, [points[1]]), tension)); } // Cardinal spline interpolation; generates "C" commands. function d3_svg_lineCardinal(points, tension, closed) { return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineCardinalTangents(points, tension)); } // Hermite spline construction; generates "C" commands. function d3_svg_lineHermite(points, tangents) { if (tangents.length < 1 || (points.length != tangents.length && points.length != tangents.length + 2)) { return d3_svg_lineLinear(points); } var quad = points.length != tangents.length, path = "", p0 = points[0], p = points[1], t0 = tangents[0], t = t0, pi = 1; if (quad) { path += "Q" + (p[0] - t0[0] * 2 / 3) + "," + (p[1] - t0[1] * 2 / 3) + "," + p[0] + "," + p[1]; p0 = points[1]; pi = 2; } if (tangents.length > 1) { t = tangents[1]; p = points[pi]; pi++; path += "C" + (p0[0] + t0[0]) + "," + (p0[1] + t0[1]) + "," + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1]; for (var i = 2; i < tangents.length; i++, pi++) { p = points[pi]; t = tangents[i]; path += "S" + (p[0] - t[0]) + "," + (p[1] - t[1]) + "," + p[0] + "," + p[1]; } } if (quad) { var lp = points[pi]; path += "Q" + (p[0] + t[0] * 2 / 3) + "," + (p[1] + t[1] * 2 / 3) + "," + lp[0] + "," + lp[1]; } return path; } // Generates tangents for a cardinal spline. function d3_svg_lineCardinalTangents(points, tension) { var tangents = [], a = (1 - tension) / 2, p0, p1 = points[0], p2 = points[1], i = 1, n = points.length; while (++i < n) { p0 = p1; p1 = p2; p2 = points[i]; tangents.push([a * (p2[0] - p0[0]), a * (p2[1] - p0[1])]); } return tangents; } // B-spline interpolation; generates "C" commands. function d3_svg_lineBasis(points) { if (points.length < 3) return d3_svg_lineLinear(points); var i = 1, n = points.length, pi = points[0], x0 = pi[0], y0 = pi[1], px = [x0, x0, x0, (pi = points[1])[0]], py = [y0, y0, y0, pi[1]], path = [x0, ",", y0]; d3_svg_lineBasisBezier(path, px, py); while (++i < n) { pi = points[i]; px.shift(); px.push(pi[0]); py.shift(); py.push(pi[1]); d3_svg_lineBasisBezier(path, px, py); } i = -1; while (++i < 2) { px.shift(); px.push(pi[0]); py.shift(); py.push(pi[1]); d3_svg_lineBasisBezier(path, px, py); } return path.join(""); } // Open B-spline interpolation; generates "C" commands. function d3_svg_lineBasisOpen(points) { if (points.length < 4) return d3_svg_lineLinear(points); var path = [], i = -1, n = points.length, pi, px = [0], py = [0]; while (++i < 3) { pi = points[i]; px.push(pi[0]); py.push(pi[1]); } path.push(d3_svg_lineDot4(d3_svg_lineBasisBezier3, px) + "," + d3_svg_lineDot4(d3_svg_lineBasisBezier3, py)); --i; while (++i < n) { pi = points[i]; px.shift(); px.push(pi[0]); py.shift(); py.push(pi[1]); d3_svg_lineBasisBezier(path, px, py); } return path.join(""); } // Closed B-spline interpolation; generates "C" commands. function d3_svg_lineBasisClosed(points) { var path, i = -1, n = points.length, m = n + 4, pi, px = [], py = []; while (++i < 4) { pi = points[i % n]; px.push(pi[0]); py.push(pi[1]); } path = [ d3_svg_lineDot4(d3_svg_lineBasisBezier3, px), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, py) ]; --i; while (++i < m) { pi = points[i % n]; px.shift(); px.push(pi[0]); py.shift(); py.push(pi[1]); d3_svg_lineBasisBezier(path, px, py); } return path.join(""); } function d3_svg_lineBundle(points, tension) { var n = points.length - 1, x0 = points[0][0], y0 = points[0][1], dx = points[n][0] - x0, dy = points[n][1] - y0, i = -1, p, t; while (++i <= n) { p = points[i]; t = i / n; p[0] = tension * p[0] + (1 - tension) * (x0 + t * dx); p[1] = tension * p[1] + (1 - tension) * (y0 + t * dy); } return d3_svg_lineBasis(points); } // Returns the dot product of the given four-element vectors. function d3_svg_lineDot4(a, b) { return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; } // Matrix to transform basis (b-spline) control points to bezier // control points. Derived from FvD 11.2.8. var d3_svg_lineBasisBezier1 = [0, 2/3, 1/3, 0], d3_svg_lineBasisBezier2 = [0, 1/3, 2/3, 0], d3_svg_lineBasisBezier3 = [0, 1/6, 2/3, 1/6]; // Pushes a "C" Bézier curve onto the specified path array, given the // two specified four-element arrays which define the control points. function d3_svg_lineBasisBezier(path, x, y) { path.push( "C", d3_svg_lineDot4(d3_svg_lineBasisBezier1, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier1, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier2, y), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, x), ",", d3_svg_lineDot4(d3_svg_lineBasisBezier3, y)); } // Computes the slope from points p0 to p1. function d3_svg_lineSlope(p0, p1) { return (p1[1] - p0[1]) / (p1[0] - p0[0]); } // Compute three-point differences for the given points. // http://en.wikipedia.org/wiki/Cubic_Hermite_spline#Finite_difference function d3_svg_lineFiniteDifferences(points) { var i = 0, j = points.length - 1, m = [], p0 = points[0], p1 = points[1], d = m[0] = d3_svg_lineSlope(p0, p1); while (++i < j) { m[i] = d + (d = d3_svg_lineSlope(p0 = p1, p1 = points[i + 1])); } m[i] = d; return m; } // Interpolates the given points using Fritsch-Carlson Monotone cubic Hermite // interpolation. Returns an array of tangent vectors. For details, see // http://en.wikipedia.org/wiki/Monotone_cubic_interpolation function d3_svg_lineMonotoneTangents(points) { var tangents = [], d, a, b, s, m = d3_svg_lineFiniteDifferences(points), i = -1, j = points.length - 1; // The first two steps are done by computing finite-differences: // 1. Compute the slopes of the secant lines between successive points. // 2. Initialize the tangents at every point as the average of the secants. // Then, for each segment… while (++i < j) { d = d3_svg_lineSlope(points[i], points[i + 1]); // 3. If two successive yk = y{k + 1} are equal (i.e., d is zero), then set // mk = m{k + 1} = 0 as the spline connecting these points must be flat to // preserve monotonicity. Ignore step 4 and 5 for those k. if (Math.abs(d) < 1e-6) { m[i] = m[i + 1] = 0; } else { // 4. Let ak = mk / dk and bk = m{k + 1} / dk. a = m[i] / d; b = m[i + 1] / d; // 5. Prevent overshoot and ensure monotonicity by restricting the // magnitude of vector to a circle of radius 3. s = a * a + b * b; if (s > 9) { s = d * 3 / Math.sqrt(s); m[i] = s * a; m[i + 1] = s * b; } } } // Compute the normalized tangent vector from the slopes. Note that if x is // not monotonic, it's possible that the slope will be infinite, so we protect // against NaN by setting the coordinate to zero. i = -1; while (++i <= j) { s = (points[Math.min(j, i + 1)][0] - points[Math.max(0, i - 1)][0]) / (6 * (1 + m[i] * m[i])); tangents.push([s || 0, m[i] * s || 0]); } return tangents; } function d3_svg_lineMonotone(points) { return points.length < 3 ? d3_svg_lineLinear(points) : points[0] + d3_svg_lineHermite(points, d3_svg_lineMonotoneTangents(points)); } d3.svg.line.radial = function() { var line = d3_svg_line(d3_svg_lineRadial); line.radius = line.x, delete line.x; line.angle = line.y, delete line.y; return line; }; function d3_svg_lineRadial(points) { var point, i = -1, n = points.length, r, a; while (++i < n) { point = points[i]; r = point[0]; a = point[1] + d3_svg_arcOffset; point[0] = r * Math.cos(a); point[1] = r * Math.sin(a); } return points; } function d3_svg_area(projection) { var x0 = d3_svg_lineX, x1 = d3_svg_lineX, y0 = 0, y1 = d3_svg_lineY, interpolate, i0, i1, tension = .7; function area(d) { if (d.length < 1) return null; var points0 = d3_svg_linePoints(this, d, x0, y0), points1 = d3_svg_linePoints(this, d, x0 === x1 ? d3_svg_areaX(points0) : x1, y0 === y1 ? d3_svg_areaY(points0) : y1); return "M" + i0(projection(points1), tension) + "L" + i1(projection(points0.reverse()), tension) + "Z"; } area.x = function(x) { if (!arguments.length) return x1; x0 = x1 = x; return area; }; area.x0 = function(x) { if (!arguments.length) return x0; x0 = x; return area; }; area.x1 = function(x) { if (!arguments.length) return x1; x1 = x; return area; }; area.y = function(y) { if (!arguments.length) return y1; y0 = y1 = y; return area; }; area.y0 = function(y) { if (!arguments.length) return y0; y0 = y; return area; }; area.y1 = function(y) { if (!arguments.length) return y1; y1 = y; return area; }; area.interpolate = function(x) { if (!arguments.length) return interpolate; i0 = d3_svg_lineInterpolators[interpolate = x]; i1 = i0.reverse || i0; return area; }; area.tension = function(x) { if (!arguments.length) return tension; tension = x; return area; }; return area.interpolate("linear"); } d3_svg_lineStepBefore.reverse = d3_svg_lineStepAfter; d3_svg_lineStepAfter.reverse = d3_svg_lineStepBefore; d3.svg.area = function() { return d3_svg_area(Object); }; function d3_svg_areaX(points) { return function(d, i) { return points[i][0]; }; } function d3_svg_areaY(points) { return function(d, i) { return points[i][1]; }; } d3.svg.area.radial = function() { var area = d3_svg_area(d3_svg_lineRadial); area.radius = area.x, delete area.x; area.innerRadius = area.x0, delete area.x0; area.outerRadius = area.x1, delete area.x1; area.angle = area.y, delete area.y; area.startAngle = area.y0, delete area.y0; area.endAngle = area.y1, delete area.y1; return area; }; d3.svg.chord = function() { var source = d3_svg_chordSource, target = d3_svg_chordTarget, radius = d3_svg_chordRadius, startAngle = d3_svg_arcStartAngle, endAngle = d3_svg_arcEndAngle; // TODO Allow control point to be customized. function chord(d, i) { var s = subgroup(this, source, d, i), t = subgroup(this, target, d, i); return "M" + s.p0 + arc(s.r, s.p1, s.a1 - s.a0) + (equals(s, t) ? curve(s.r, s.p1, s.r, s.p0) : curve(s.r, s.p1, t.r, t.p0) + arc(t.r, t.p1, t.a1 - t.a0) + curve(t.r, t.p1, s.r, s.p0)) + "Z"; } function subgroup(self, f, d, i) { var subgroup = f.call(self, d, i), r = radius.call(self, subgroup, i), a0 = startAngle.call(self, subgroup, i) + d3_svg_arcOffset, a1 = endAngle.call(self, subgroup, i) + d3_svg_arcOffset; return { r: r, a0: a0, a1: a1, p0: [r * Math.cos(a0), r * Math.sin(a0)], p1: [r * Math.cos(a1), r * Math.sin(a1)] }; } function equals(a, b) { return a.a0 == b.a0 && a.a1 == b.a1; } function arc(r, p, a) { return "A" + r + "," + r + " 0 " + +(a > Math.PI) + ",1 " + p; } function curve(r0, p0, r1, p1) { return "Q 0,0 " + p1; } chord.radius = function(v) { if (!arguments.length) return radius; radius = d3.functor(v); return chord; }; chord.source = function(v) { if (!arguments.length) return source; source = d3.functor(v); return chord; }; chord.target = function(v) { if (!arguments.length) return target; target = d3.functor(v); return chord; }; chord.startAngle = function(v) { if (!arguments.length) return startAngle; startAngle = d3.functor(v); return chord; }; chord.endAngle = function(v) { if (!arguments.length) return endAngle; endAngle = d3.functor(v); return chord; }; return chord; }; function d3_svg_chordSource(d) { return d.source; } function d3_svg_chordTarget(d) { return d.target; } function d3_svg_chordRadius(d) { return d.radius; } function d3_svg_chordStartAngle(d) { return d.startAngle; } function d3_svg_chordEndAngle(d) { return d.endAngle; } d3.svg.diagonal = function() { var source = d3_svg_chordSource, target = d3_svg_chordTarget, projection = d3_svg_diagonalProjection; function diagonal(d, i) { var p0 = source.call(this, d, i), p3 = target.call(this, d, i), m = (p0.y + p3.y) / 2, p = [p0, {x: p0.x, y: m}, {x: p3.x, y: m}, p3]; p = p.map(projection); return "M" + p[0] + "C" + p[1] + " " + p[2] + " " + p[3]; } diagonal.source = function(x) { if (!arguments.length) return source; source = d3.functor(x); return diagonal; }; diagonal.target = function(x) { if (!arguments.length) return target; target = d3.functor(x); return diagonal; }; diagonal.projection = function(x) { if (!arguments.length) return projection; projection = x; return diagonal; }; return diagonal; }; function d3_svg_diagonalProjection(d) { return [d.x, d.y]; } d3.svg.diagonal.radial = function() { var diagonal = d3.svg.diagonal(), projection = d3_svg_diagonalProjection, projection_ = diagonal.projection; diagonal.projection = function(x) { return arguments.length ? projection_(d3_svg_diagonalRadialProjection(projection = x)) : projection; }; return diagonal; }; function d3_svg_diagonalRadialProjection(projection) { return function() { var d = projection.apply(this, arguments), r = d[0], a = d[1] + d3_svg_arcOffset; return [r * Math.cos(a), r * Math.sin(a)]; }; } d3.svg.mouse = function(container) { return d3_svg_mousePoint(container, d3.event); }; // https://bugs.webkit.org/show_bug.cgi?id=44083 var d3_mouse_bug44083 = /WebKit/.test(navigator.userAgent) ? -1 : 0; function d3_svg_mousePoint(container, e) { var point = (container.ownerSVGElement || container).createSVGPoint(); if ((d3_mouse_bug44083 < 0) && (window.scrollX || window.scrollY)) { var svg = d3.select(document.body) .append("svg") .style("position", "absolute") .style("top", 0) .style("left", 0); var ctm = svg[0][0].getScreenCTM(); d3_mouse_bug44083 = !(ctm.f || ctm.e); svg.remove(); } if (d3_mouse_bug44083) { point.x = e.pageX; point.y = e.pageY; } else { point.x = e.clientX; point.y = e.clientY; } point = point.matrixTransform(container.getScreenCTM().inverse()); return [point.x, point.y]; }; d3.svg.touches = function(container, touches) { if (arguments.length < 2) touches = d3.event.touches; return touches ? d3_array(touches).map(function(touch) { var point = d3_svg_mousePoint(container, touch); point.identifier = touch.identifier; return point; }) : []; }; d3.svg.symbol = function() { var type = d3_svg_symbolType, size = d3_svg_symbolSize; function symbol(d, i) { return (d3_svg_symbols[type.call(this, d, i)] || d3_svg_symbols.circle) (size.call(this, d, i)); } symbol.type = function(x) { if (!arguments.length) return type; type = d3.functor(x); return symbol; }; // size of symbol in square pixels symbol.size = function(x) { if (!arguments.length) return size; size = d3.functor(x); return symbol; }; return symbol; }; function d3_svg_symbolSize() { return 64; } function d3_svg_symbolType() { return "circle"; } // TODO cross-diagonal? var d3_svg_symbols = { "circle": function(size) { var r = Math.sqrt(size / Math.PI); return "M0," + r + "A" + r + "," + r + " 0 1,1 0," + (-r) + "A" + r + "," + r + " 0 1,1 0," + r + "Z"; }, "cross": function(size) { var r = Math.sqrt(size / 5) / 2; return "M" + -3 * r + "," + -r + "H" + -r + "V" + -3 * r + "H" + r + "V" + -r + "H" + 3 * r + "V" + r + "H" + r + "V" + 3 * r + "H" + -r + "V" + r + "H" + -3 * r + "Z"; }, "diamond": function(size) { var ry = Math.sqrt(size / (2 * d3_svg_symbolTan30)), rx = ry * d3_svg_symbolTan30; return "M0," + -ry + "L" + rx + ",0" + " 0," + ry + " " + -rx + ",0" + "Z"; }, "square": function(size) { var r = Math.sqrt(size) / 2; return "M" + -r + "," + -r + "L" + r + "," + -r + " " + r + "," + r + " " + -r + "," + r + "Z"; }, "triangle-down": function(size) { var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2; return "M0," + ry + "L" + rx +"," + -ry + " " + -rx + "," + -ry + "Z"; }, "triangle-up": function(size) { var rx = Math.sqrt(size / d3_svg_symbolSqrt3), ry = rx * d3_svg_symbolSqrt3 / 2; return "M0," + -ry + "L" + rx +"," + ry + " " + -rx + "," + ry + "Z"; } }; d3.svg.symbolTypes = d3.keys(d3_svg_symbols); var d3_svg_symbolSqrt3 = Math.sqrt(3), d3_svg_symbolTan30 = Math.tan(30 * Math.PI / 180); d3.svg.axis = function() { var scale = d3.scale.linear(), orient = "bottom", tickMajorSize = 6, tickMinorSize = 6, tickEndSize = 6, tickPadding = 3, tickArguments_ = [10], tickFormat_, tickSubdivide = 0; function axis(selection) { selection.each(function(d, i, j) { var g = d3.select(this); // If selection is a transition, create subtransitions. var transition = selection.delay ? function(o) { var id = d3_transitionInheritId; try { d3_transitionInheritId = selection.id; return o.transition() .delay(selection[j][i].delay) .duration(selection[j][i].duration) .ease(selection.ease()); } finally { d3_transitionInheritId = id; } } : Object; // Ticks, or domain values for ordinal scales. var ticks = scale.ticks ? scale.ticks.apply(scale, tickArguments_) : scale.domain(), tickFormat = tickFormat_ == null ? (scale.tickFormat ? scale.tickFormat.apply(scale, tickArguments_) : String) : tickFormat_; // Minor ticks. var subticks = d3_svg_axisSubdivide(scale, ticks, tickSubdivide), subtick = g.selectAll(".minor").data(subticks, String), subtickEnter = subtick.enter().insert("line", "g").attr("class", "tick minor").style("opacity", 1e-6), subtickExit = transition(subtick.exit()).style("opacity", 1e-6).remove(), subtickUpdate = transition(subtick).style("opacity", 1); // Major ticks. var tick = g.selectAll("g").data(ticks, String), tickEnter = tick.enter().insert("g", "path").style("opacity", 1e-6), tickExit = transition(tick.exit()).style("opacity", 1e-6).remove(), tickUpdate = transition(tick).style("opacity", 1), tickTransform; // Domain. var range = d3_scaleRange(scale), path = g.selectAll(".domain").data([0]), pathEnter = path.enter().append("path").attr("class", "domain"), pathUpdate = transition(path); // Stash a snapshot of the new scale, and retrieve the old snapshot. var scale1 = scale.copy(), scale0 = this.__chart__ || scale1; this.__chart__ = scale1; tickEnter.append("line").attr("class", "tick"); tickEnter.append("text"); tickUpdate.select("text").text(tickFormat); switch (orient) { case "bottom": { tickTransform = d3_svg_axisX; subtickUpdate.attr("x2", 0).attr("y2", tickMinorSize); tickUpdate.select("line").attr("x2", 0).attr("y2", tickMajorSize); tickUpdate.select("text").attr("x", 0).attr("y", Math.max(tickMajorSize, 0) + tickPadding).attr("dy", ".71em").attr("text-anchor", "middle"); pathUpdate.attr("d", "M" + range[0] + "," + tickEndSize + "V0H" + range[1] + "V" + tickEndSize); break; } case "top": { tickTransform = d3_svg_axisX; subtickUpdate.attr("x2", 0).attr("y2", -tickMinorSize); tickUpdate.select("line").attr("x2", 0).attr("y2", -tickMajorSize); tickUpdate.select("text").attr("x", 0).attr("y", -(Math.max(tickMajorSize, 0) + tickPadding)).attr("dy", "0em").attr("text-anchor", "middle"); pathUpdate.attr("d", "M" + range[0] + "," + -tickEndSize + "V0H" + range[1] + "V" + -tickEndSize); break; } case "left": { tickTransform = d3_svg_axisY; subtickUpdate.attr("x2", -tickMinorSize).attr("y2", 0); tickUpdate.select("line").attr("x2", -tickMajorSize).attr("y2", 0); tickUpdate.select("text").attr("x", -(Math.max(tickMajorSize, 0) + tickPadding)).attr("y", 0).attr("dy", ".32em").attr("text-anchor", "end"); pathUpdate.attr("d", "M" + -tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + -tickEndSize); break; } case "right": { tickTransform = d3_svg_axisY; subtickUpdate.attr("x2", tickMinorSize).attr("y2", 0); tickUpdate.select("line").attr("x2", tickMajorSize).attr("y2", 0); tickUpdate.select("text").attr("x", Math.max(tickMajorSize, 0) + tickPadding).attr("y", 0).attr("dy", ".32em").attr("text-anchor", "start"); pathUpdate.attr("d", "M" + tickEndSize + "," + range[0] + "H0V" + range[1] + "H" + tickEndSize); break; } } // For quantitative scales: // - enter new ticks from the old scale // - exit old ticks to the new scale if (scale.ticks) { tickEnter.call(tickTransform, scale0); tickUpdate.call(tickTransform, scale1); tickExit.call(tickTransform, scale1); subtickEnter.call(tickTransform, scale0); subtickUpdate.call(tickTransform, scale1); subtickExit.call(tickTransform, scale1); } // For ordinal scales: // - any entering ticks are undefined in the old scale // - any exiting ticks are undefined in the new scale // Therefore, we only need to transition updating ticks. else { var dx = scale1.rangeBand() / 2, x = function(d) { return scale1(d) + dx; }; tickEnter.call(tickTransform, x); tickUpdate.call(tickTransform, x); } }); } axis.scale = function(x) { if (!arguments.length) return scale; scale = x; return axis; }; axis.orient = function(x) { if (!arguments.length) return orient; orient = x; return axis; }; axis.ticks = function() { if (!arguments.length) return tickArguments_; tickArguments_ = arguments; return axis; }; axis.tickFormat = function(x) { if (!arguments.length) return tickFormat_; tickFormat_ = x; return axis; }; axis.tickSize = function(x, y, z) { if (!arguments.length) return tickMajorSize; var n = arguments.length - 1; tickMajorSize = +x; tickMinorSize = n > 1 ? +y : tickMajorSize; tickEndSize = n > 0 ? +arguments[n] : tickMajorSize; return axis; }; axis.tickPadding = function(x) { if (!arguments.length) return tickPadding; tickPadding = +x; return axis; }; axis.tickSubdivide = function(x) { if (!arguments.length) return tickSubdivide; tickSubdivide = +x; return axis; }; return axis; }; function d3_svg_axisX(selection, x) { selection.attr("transform", function(d) { return "translate(" + x(d) + ",0)"; }); } function d3_svg_axisY(selection, y) { selection.attr("transform", function(d) { return "translate(0," + y(d) + ")"; }); } function d3_svg_axisSubdivide(scale, ticks, m) { subticks = []; if (m && ticks.length > 1) { var extent = d3_scaleExtent(scale.domain()), subticks, i = -1, n = ticks.length, d = (ticks[1] - ticks[0]) / ++m, j, v; while (++i < n) { for (j = m; --j > 0;) { if ((v = +ticks[i] - j * d) >= extent[0]) { subticks.push(v); } } } for (--i, j = 0; ++j < m && (v = +ticks[i] + j * d) < extent[1];) { subticks.push(v); } } return subticks; } d3.svg.brush = function() { var event = d3.dispatch("brushstart", "brush", "brushend"), x, // x-scale, optional y, // y-scale, optional extent = [[0, 0], [0, 0]]; // [x0, y0], [x1, y1] function brush(g) { var resizes = x && y ? ["n", "e", "s", "w", "nw", "ne", "se", "sw"] : x ? ["e", "w"] : y ? ["n", "s"] : []; g.each(function() { var g = d3.select(this).on("mousedown.brush", down), bg = g.selectAll(".background").data([,]), fg = g.selectAll(".extent").data([,]), tz = g.selectAll(".resize").data(resizes, String), e; // An invisible, mouseable area for starting a new brush. bg.enter().append("rect") .attr("class", "background") .style("visibility", "hidden") .style("pointer-events", "all") .style("cursor", "crosshair"); // The visible brush extent; style this as you like! fg.enter().append("rect") .attr("class", "extent") .style("cursor", "move"); // More invisible rects for resizing the extent. tz.enter().append("rect") .attr("class", function(d) { return "resize " + d; }) .attr("width", 6) .attr("height", 6) .style("visibility", "hidden") .style("pointer-events", brush.empty() ? "none" : "all") .style("cursor", function(d) { return d3_svg_brushCursor[d]; }); // Remove any superfluous resizers. tz.exit().remove(); // Initialize the background to fill the defined range. // If the range isn't defined, you can post-process. if (x) { e = d3_scaleRange(x); bg.attr("x", e[0]).attr("width", e[1] - e[0]); d3_svg_brushRedrawX(g, extent); } if (y) { e = d3_scaleRange(y); bg.attr("y", e[0]).attr("height", e[1] - e[0]); d3_svg_brushRedrawY(g, extent); } }); } function down() { var target = d3.select(d3.event.target); // Store some global state for the duration of the brush gesture. d3_svg_brush = brush; d3_svg_brushTarget = this; d3_svg_brushExtent = extent; d3_svg_brushOffset = d3.svg.mouse(d3_svg_brushTarget); // If the extent was clicked on, drag rather than brush; // store the offset between the mouse and extent origin instead. if (d3_svg_brushDrag = target.classed("extent")) { d3_svg_brushOffset[0] = extent[0][0] - d3_svg_brushOffset[0]; d3_svg_brushOffset[1] = extent[0][1] - d3_svg_brushOffset[1]; } // If a resizer was clicked on, record which side is to be resized. // Also, set the offset to the opposite side. else if (target.classed("resize")) { d3_svg_brushResize = d3.event.target.__data__; d3_svg_brushOffset[0] = extent[+/w$/.test(d3_svg_brushResize)][0]; d3_svg_brushOffset[1] = extent[+/^n/.test(d3_svg_brushResize)][1]; } // If the ALT key is down when starting a brush, the center is at the mouse. else if (d3.event.altKey) { d3_svg_brushCenter = d3_svg_brushOffset.slice(); } // Restrict which dimensions are resized. d3_svg_brushX = !/^(n|s)$/.test(d3_svg_brushResize) && x; d3_svg_brushY = !/^(e|w)$/.test(d3_svg_brushResize) && y; // Notify listeners. d3_svg_brushDispatch = dispatcher(this, arguments); d3_svg_brushDispatch("brushstart"); d3_svg_brushMove(); d3_eventCancel(); } function dispatcher(that, argumentz) { return function(type) { var e = d3.event; try { d3.event = {type: type, target: brush}; event[type].apply(that, argumentz); } finally { d3.event = e; } }; } brush.x = function(z) { if (!arguments.length) return x; x = z; return brush; }; brush.y = function(z) { if (!arguments.length) return y; y = z; return brush; }; brush.extent = function(z) { var x0, x1, y0, y1, t; // Invert the pixel extent to data-space. if (!arguments.length) { if (x) { x0 = extent[0][0], x1 = extent[1][0]; if (x.invert) x0 = x.invert(x0), x1 = x.invert(x1); if (x1 < x0) t = x0, x0 = x1, x1 = t; } if (y) { y0 = extent[0][1], y1 = extent[1][1]; if (y.invert) y0 = y.invert(y0), y1 = y.invert(y1); if (y1 < y0) t = y0, y0 = y1, y1 = t; } return x && y ? [[x0, y0], [x1, y1]] : x ? [x0, x1] : y && [y0, y1]; } // Scale the data-space extent to pixels. if (x) { x0 = z[0], x1 = z[1]; if (y) x0 = x0[0], x1 = x1[0]; if (x.invert) x0 = x(x0), x1 = x(x1); if (x1 < x0) t = x0, x0 = x1, x1 = t; extent[0][0] = x0, extent[1][0] = x1; } if (y) { y0 = z[0], y1 = z[1]; if (x) y0 = y0[1], y1 = y1[1]; if (y.invert) y0 = y(y0), y1 = y(y1); if (y1 < y0) t = y0, y0 = y1, y1 = t; extent[0][1] = y0, extent[1][1] = y1; } return brush; }; brush.clear = function() { extent[0][0] = extent[0][1] = extent[1][0] = extent[1][1] = 0; return brush; }; brush.empty = function() { return (x && extent[0][0] === extent[1][0]) || (y && extent[0][1] === extent[1][1]); }; d3.select(window) .on("mousemove.brush", d3_svg_brushMove) .on("mouseup.brush", d3_svg_brushUp) .on("keydown.brush", d3_svg_brushKeydown) .on("keyup.brush", d3_svg_brushKeyup); return d3.rebind(brush, event, "on"); }; var d3_svg_brush, d3_svg_brushDispatch, d3_svg_brushTarget, d3_svg_brushX, d3_svg_brushY, d3_svg_brushExtent, d3_svg_brushDrag, d3_svg_brushResize, d3_svg_brushCenter, d3_svg_brushOffset; function d3_svg_brushRedrawX(g, extent) { g.select(".extent").attr("x", extent[0][0]); g.selectAll(".n,.s,.w,.nw,.sw").attr("x", extent[0][0] - 2); g.selectAll(".e,.ne,.se").attr("x", extent[1][0] - 3); g.selectAll(".extent,.n,.s").attr("width", extent[1][0] - extent[0][0]); } function d3_svg_brushRedrawY(g, extent) { g.select(".extent").attr("y", extent[0][1]); g.selectAll(".n,.e,.w,.nw,.ne").attr("y", extent[0][1] - 3); g.selectAll(".s,.se,.sw").attr("y", extent[1][1] - 4); g.selectAll(".extent,.e,.w").attr("height", extent[1][1] - extent[0][1]); } function d3_svg_brushKeydown() { if (d3.event.keyCode == 32 && d3_svg_brushTarget && !d3_svg_brushDrag) { d3_svg_brushCenter = null; d3_svg_brushOffset[0] -= d3_svg_brushExtent[1][0]; d3_svg_brushOffset[1] -= d3_svg_brushExtent[1][1]; d3_svg_brushDrag = 2; d3_eventCancel(); } } function d3_svg_brushKeyup() { if (d3.event.keyCode == 32 && d3_svg_brushDrag == 2) { d3_svg_brushOffset[0] += d3_svg_brushExtent[1][0]; d3_svg_brushOffset[1] += d3_svg_brushExtent[1][1]; d3_svg_brushDrag = 0; d3_eventCancel(); } } function d3_svg_brushMove() { if (d3_svg_brushOffset) { var mouse = d3.svg.mouse(d3_svg_brushTarget), g = d3.select(d3_svg_brushTarget); if (!d3_svg_brushDrag) { // If needed, determine the center from the current extent. if (d3.event.altKey) { if (!d3_svg_brushCenter) { d3_svg_brushCenter = [ (d3_svg_brushExtent[0][0] + d3_svg_brushExtent[1][0]) / 2, (d3_svg_brushExtent[0][1] + d3_svg_brushExtent[1][1]) / 2 ]; } // Update the offset, for when the ALT key is released. d3_svg_brushOffset[0] = d3_svg_brushExtent[+(mouse[0] < d3_svg_brushCenter[0])][0]; d3_svg_brushOffset[1] = d3_svg_brushExtent[+(mouse[1] < d3_svg_brushCenter[1])][1]; } // When the ALT key is released, we clear the center. else d3_svg_brushCenter = null; } // Update the brush extent for each dimension. if (d3_svg_brushX) { d3_svg_brushMove1(mouse, d3_svg_brushX, 0); d3_svg_brushRedrawX(g, d3_svg_brushExtent); } if (d3_svg_brushY) { d3_svg_brushMove1(mouse, d3_svg_brushY, 1); d3_svg_brushRedrawY(g, d3_svg_brushExtent); } // Notify listeners. d3_svg_brushDispatch("brush"); } } function d3_svg_brushMove1(mouse, scale, i) { var range = d3_scaleRange(scale), r0 = range[0], r1 = range[1], offset = d3_svg_brushOffset[i], size = d3_svg_brushExtent[1][i] - d3_svg_brushExtent[0][i], min, max; // When dragging, reduce the range by the extent size and offset. if (d3_svg_brushDrag) { r0 -= offset; r1 -= size + offset; } // Clamp the mouse so that the extent fits within the range extent. min = Math.max(r0, Math.min(r1, mouse[i])); // Compute the new extent bounds. if (d3_svg_brushDrag) { max = (min += offset) + size; } else { // If the ALT key is pressed, then preserve the center of the extent. if (d3_svg_brushCenter) offset = Math.max(r0, Math.min(r1, 2 * d3_svg_brushCenter[i] - min)); // Compute the min and max of the offset and mouse. if (offset < min) { max = min; min = offset; } else { max = offset; } } // Update the stored bounds. d3_svg_brushExtent[0][i] = min; d3_svg_brushExtent[1][i] = max; } function d3_svg_brushUp() { if (d3_svg_brushOffset) { d3_svg_brushMove(); d3.select(d3_svg_brushTarget).selectAll(".resize").style("pointer-events", d3_svg_brush.empty() ? "none" : "all"); d3_svg_brushDispatch("brushend"); d3_svg_brush = d3_svg_brushDispatch = d3_svg_brushTarget = d3_svg_brushX = d3_svg_brushY = d3_svg_brushExtent = d3_svg_brushDrag = d3_svg_brushResize = d3_svg_brushCenter = d3_svg_brushOffset = null; d3_eventCancel(); } } var d3_svg_brushCursor = { n: "ns-resize", e: "ew-resize", s: "ns-resize", w: "ew-resize", nw: "nwse-resize", ne: "nesw-resize", se: "nwse-resize", sw: "nesw-resize" }; d3.behavior = {}; // TODO Track touch points by identifier. d3.behavior.drag = function() { var event = d3.dispatch("drag", "dragstart", "dragend"), origin = null; function drag() { this .on("mousedown.drag", mousedown) .on("touchstart.drag", mousedown); d3.select(window) .on("mousemove.drag", d3_behavior_dragMove) .on("touchmove.drag", d3_behavior_dragMove) .on("mouseup.drag", d3_behavior_dragUp, true) .on("touchend.drag", d3_behavior_dragUp, true) .on("click.drag", d3_behavior_dragClick, true); } // snapshot the local context for subsequent dispatch function start() { d3_behavior_dragEvent = event; d3_behavior_dragEventTarget = d3.event.target; d3_behavior_dragTarget = this; d3_behavior_dragArguments = arguments; d3_behavior_dragOrigin = d3_behavior_dragPoint(); if (origin) { d3_behavior_dragOffset = origin.apply(d3_behavior_dragTarget, d3_behavior_dragArguments); d3_behavior_dragOffset = [d3_behavior_dragOffset.x - d3_behavior_dragOrigin[0], d3_behavior_dragOffset.y - d3_behavior_dragOrigin[1]]; } else { d3_behavior_dragOffset = [0, 0]; } d3_behavior_dragMoved = 0; } function mousedown() { start.apply(this, arguments); d3_behavior_dragDispatch("dragstart"); } drag.origin = function(x) { if (!arguments.length) return origin; origin = x; return drag; }; return d3.rebind(drag, event, "on"); }; var d3_behavior_dragEvent, d3_behavior_dragEventTarget, d3_behavior_dragTarget, d3_behavior_dragArguments, d3_behavior_dragOffset, d3_behavior_dragOrigin, d3_behavior_dragMoved; function d3_behavior_dragDispatch(type) { var p = d3_behavior_dragPoint(), o = d3.event, e = d3.event = {type: type}; if (p) { e.x = p[0] + d3_behavior_dragOffset[0]; e.y = p[1] + d3_behavior_dragOffset[1]; e.dx = p[0] - d3_behavior_dragOrigin[0]; e.dy = p[1] - d3_behavior_dragOrigin[1]; d3_behavior_dragMoved |= e.dx | e.dy; d3_behavior_dragOrigin = p; } try { d3_behavior_dragEvent[type].apply(d3_behavior_dragTarget, d3_behavior_dragArguments); } finally { d3.event = o; } o.stopPropagation(); o.preventDefault(); } function d3_behavior_dragPoint() { var p = d3_behavior_dragTarget.parentNode, t = d3.event.changedTouches; return p && (t ? d3.svg.touches(p, t)[0] : d3.svg.mouse(p)); } function d3_behavior_dragMove() { if (!d3_behavior_dragTarget) return; var parent = d3_behavior_dragTarget.parentNode; // O NOES! The drag element was removed from the DOM. if (!parent) return d3_behavior_dragUp(); d3_behavior_dragDispatch("drag"); d3_eventCancel(); } function d3_behavior_dragUp() { if (!d3_behavior_dragTarget) return; d3_behavior_dragDispatch("dragend"); // If the node was moved, prevent the mouseup from propagating. // Also prevent the subsequent click from propagating (e.g., for anchors). if (d3_behavior_dragMoved) { d3_eventCancel(); d3_behavior_dragMoved = d3.event.target === d3_behavior_dragEventTarget; } d3_behavior_dragEvent = d3_behavior_dragEventTarget = d3_behavior_dragTarget = d3_behavior_dragArguments = d3_behavior_dragOffset = d3_behavior_dragOrigin = null; } function d3_behavior_dragClick() { if (d3_behavior_dragMoved) { d3_eventCancel(); d3_behavior_dragMoved = 0; } } // TODO unbind zoom behavior? d3.behavior.zoom = function() { var xyz = [0, 0, 0], event = d3.dispatch("zoom"), extent = d3_behavior_zoomInfiniteExtent; function zoom() { this .on("mousedown.zoom", mousedown) .on("mousewheel.zoom", mousewheel) .on("DOMMouseScroll.zoom", mousewheel) .on("dblclick.zoom", dblclick) .on("touchstart.zoom", touchstart); d3.select(window) .on("mousemove.zoom", d3_behavior_zoomMousemove) .on("mouseup.zoom", d3_behavior_zoomMouseup) .on("touchmove.zoom", d3_behavior_zoomTouchmove) .on("touchend.zoom", d3_behavior_zoomTouchup) .on("click.zoom", d3_behavior_zoomClick, true); } // snapshot the local context for subsequent dispatch function start() { d3_behavior_zoomXyz = xyz; d3_behavior_zoomExtent = extent; d3_behavior_zoomDispatch = event.zoom; d3_behavior_zoomEventTarget = d3.event.target; d3_behavior_zoomTarget = this; d3_behavior_zoomArguments = arguments; } function mousedown() { start.apply(this, arguments); d3_behavior_zoomPanning = d3_behavior_zoomLocation(d3.svg.mouse(d3_behavior_zoomTarget)); d3_behavior_zoomMoved = 0; d3.event.preventDefault(); window.focus(); } // store starting mouse location function mousewheel() { start.apply(this, arguments); if (!d3_behavior_zoomZooming) d3_behavior_zoomZooming = d3_behavior_zoomLocation(d3.svg.mouse(d3_behavior_zoomTarget)); d3_behavior_zoomTo(d3_behavior_zoomDelta() + xyz[2], d3.svg.mouse(d3_behavior_zoomTarget), d3_behavior_zoomZooming); } function dblclick() { start.apply(this, arguments); var mouse = d3.svg.mouse(d3_behavior_zoomTarget); d3_behavior_zoomTo(d3.event.shiftKey ? Math.ceil(xyz[2] - 1) : Math.floor(xyz[2] + 1), mouse, d3_behavior_zoomLocation(mouse)); } // doubletap detection function touchstart() { start.apply(this, arguments); var touches = d3_behavior_zoomTouchup(), touch, now = Date.now(); if ((touches.length === 1) && (now - d3_behavior_zoomLast < 300)) { d3_behavior_zoomTo(1 + Math.floor(xyz[2]), touch = touches[0], d3_behavior_zoomLocations[touch.identifier]); } d3_behavior_zoomLast = now; } zoom.extent = function(x) { if (!arguments.length) return extent; extent = x == null ? d3_behavior_zoomInfiniteExtent : x; return zoom; }; return d3.rebind(zoom, event, "on"); }; var d3_behavior_zoomDiv, d3_behavior_zoomPanning, d3_behavior_zoomZooming, d3_behavior_zoomLocations = {}, // identifier -> location d3_behavior_zoomLast = 0, d3_behavior_zoomXyz, d3_behavior_zoomExtent, d3_behavior_zoomDispatch, d3_behavior_zoomEventTarget, d3_behavior_zoomTarget, d3_behavior_zoomArguments, d3_behavior_zoomMoved; function d3_behavior_zoomLocation(point) { return [ point[0] - d3_behavior_zoomXyz[0], point[1] - d3_behavior_zoomXyz[1], d3_behavior_zoomXyz[2] ]; } // detect the pixels that would be scrolled by this wheel event function d3_behavior_zoomDelta() { // mousewheel events are totally broken! // https://bugs.webkit.org/show_bug.cgi?id=40441 // not only that, but Chrome and Safari differ in re. to acceleration! if (!d3_behavior_zoomDiv) { d3_behavior_zoomDiv = d3.select("body").append("div") .style("visibility", "hidden") .style("top", 0) .style("height", 0) .style("width", 0) .style("overflow-y", "scroll") .append("div") .style("height", "2000px") .node().parentNode; } var e = d3.event, delta; try { d3_behavior_zoomDiv.scrollTop = 1000; d3_behavior_zoomDiv.dispatchEvent(e); delta = 1000 - d3_behavior_zoomDiv.scrollTop; } catch (error) { delta = e.wheelDelta || (-e.detail * 5); } return delta * .005; } // Note: Since we don't rotate, it's possible for the touches to become // slightly detached from their original positions. Thus, we recompute the // touch points on touchend as well as touchstart! function d3_behavior_zoomTouchup() { var touches = d3.svg.touches(d3_behavior_zoomTarget), i = -1, n = touches.length, touch; while (++i < n) d3_behavior_zoomLocations[(touch = touches[i]).identifier] = d3_behavior_zoomLocation(touch); return touches; } function d3_behavior_zoomTouchmove() { var touches = d3.svg.touches(d3_behavior_zoomTarget); switch (touches.length) { // single-touch pan case 1: { var touch = touches[0]; d3_behavior_zoomTo(d3_behavior_zoomXyz[2], touch, d3_behavior_zoomLocations[touch.identifier]); break; } // double-touch pan + zoom case 2: { var p0 = touches[0], p1 = touches[1], p2 = [(p0[0] + p1[0]) / 2, (p0[1] + p1[1]) / 2], l0 = d3_behavior_zoomLocations[p0.identifier], l1 = d3_behavior_zoomLocations[p1.identifier], l2 = [(l0[0] + l1[0]) / 2, (l0[1] + l1[1]) / 2, l0[2]]; d3_behavior_zoomTo(Math.log(d3.event.scale) / Math.LN2 + l0[2], p2, l2); break; } } } function d3_behavior_zoomMousemove() { d3_behavior_zoomZooming = null; if (d3_behavior_zoomPanning) { d3_behavior_zoomMoved = 1; d3_behavior_zoomTo(d3_behavior_zoomXyz[2], d3.svg.mouse(d3_behavior_zoomTarget), d3_behavior_zoomPanning); } } function d3_behavior_zoomMouseup() { if (d3_behavior_zoomPanning) { if (d3_behavior_zoomMoved) { d3_eventCancel(); d3_behavior_zoomMoved = d3_behavior_zoomEventTarget === d3.event.target; } d3_behavior_zoomXyz = d3_behavior_zoomExtent = d3_behavior_zoomDispatch = d3_behavior_zoomEventTarget = d3_behavior_zoomTarget = d3_behavior_zoomArguments = d3_behavior_zoomPanning = null; } } function d3_behavior_zoomClick() { if (d3_behavior_zoomMoved) { d3_eventCancel(); d3_behavior_zoomMoved = 0; } } function d3_behavior_zoomTo(z, x0, x1) { z = d3_behavior_zoomExtentClamp(z, 2); var j = Math.pow(2, d3_behavior_zoomXyz[2]), k = Math.pow(2, z), K = Math.pow(2, (d3_behavior_zoomXyz[2] = z) - x1[2]), x_ = d3_behavior_zoomXyz[0], y_ = d3_behavior_zoomXyz[1], x = d3_behavior_zoomXyz[0] = d3_behavior_zoomExtentClamp((x0[0] - x1[0] * K), 0, k), y = d3_behavior_zoomXyz[1] = d3_behavior_zoomExtentClamp((x0[1] - x1[1] * K), 1, k), o = d3.event; // Events can be reentrant (e.g., focus). d3.event = { scale: k, translate: [x, y], transform: function(sx, sy) { if (sx) transform(sx, x_, x); if (sy) transform(sy, y_, y); } }; function transform(scale, a, b) { scale.domain(scale.range().map(function(v) { return scale.invert(((v - b) * j) / k + a); })); } try { d3_behavior_zoomDispatch.apply(d3_behavior_zoomTarget, d3_behavior_zoomArguments); } finally { d3.event = o; } o.preventDefault(); } var d3_behavior_zoomInfiniteExtent = [ [-Infinity, Infinity], [-Infinity, Infinity], [-Infinity, Infinity] ]; function d3_behavior_zoomExtentClamp(x, i, k) { var range = d3_behavior_zoomExtent[i], r0 = range[0], r1 = range[1]; return arguments.length === 3 ? Math.max(r1 * (r1 === Infinity ? -Infinity : 1 / k - 1), Math.min(r0 === -Infinity ? Infinity : r0, x / k)) * k : Math.max(r0, Math.min(r1, x)); } })(); science.js-1.9.3/lib/d3/d3.layout.js000066400000000000000000001362311256532472600170260ustar00rootroot00000000000000(function(){d3.layout = {}; // Implements hierarchical edge bundling using Holten's algorithm. For each // input link, a path is computed that travels through the tree, up the parent // hierarchy to the least common ancestor, and then back down to the destination // node. Each path is simply an array of nodes. d3.layout.bundle = function() { return function(links) { var paths = [], i = -1, n = links.length; while (++i < n) paths.push(d3_layout_bundlePath(links[i])); return paths; }; }; function d3_layout_bundlePath(link) { var start = link.source, end = link.target, lca = d3_layout_bundleLeastCommonAncestor(start, end), points = [start]; while (start !== lca) { start = start.parent; points.push(start); } var k = points.length; while (end !== lca) { points.splice(k, 0, end); end = end.parent; } return points; } function d3_layout_bundleAncestors(node) { var ancestors = [], parent = node.parent; while (parent != null) { ancestors.push(node); node = parent; parent = parent.parent; } ancestors.push(node); return ancestors; } function d3_layout_bundleLeastCommonAncestor(a, b) { if (a === b) return a; var aNodes = d3_layout_bundleAncestors(a), bNodes = d3_layout_bundleAncestors(b), aNode = aNodes.pop(), bNode = bNodes.pop(), sharedNode = null; while (aNode === bNode) { sharedNode = aNode; aNode = aNodes.pop(); bNode = bNodes.pop(); } return sharedNode; } d3.layout.chord = function() { var chord = {}, chords, groups, matrix, n, padding = 0, sortGroups, sortSubgroups, sortChords; function relayout() { var subgroups = {}, groupSums = [], groupIndex = d3.range(n), subgroupIndex = [], k, x, x0, i, j; chords = []; groups = []; // Compute the sum. k = 0, i = -1; while (++i < n) { x = 0, j = -1; while (++j < n) { x += matrix[i][j]; } groupSums.push(x); subgroupIndex.push(d3.range(n)); k += x; } // Sort groups… if (sortGroups) { groupIndex.sort(function(a, b) { return sortGroups(groupSums[a], groupSums[b]); }); } // Sort subgroups… if (sortSubgroups) { subgroupIndex.forEach(function(d, i) { d.sort(function(a, b) { return sortSubgroups(matrix[i][a], matrix[i][b]); }); }); } // Convert the sum to scaling factor for [0, 2pi]. // TODO Allow start and end angle to be specified. // TODO Allow padding to be specified as percentage? k = (2 * Math.PI - padding * n) / k; // Compute the start and end angle for each group and subgroup. // Note: Opera has a bug reordering object literal properties! x = 0, i = -1; while (++i < n) { x0 = x, j = -1; while (++j < n) { var di = groupIndex[i], dj = subgroupIndex[di][j], v = matrix[di][dj], a0 = x, a1 = x += v * k; subgroups[di + "-" + dj] = { index: di, subindex: dj, startAngle: a0, endAngle: a1, value: v }; } groups.push({ index: di, startAngle: x0, endAngle: x, value: (x - x0) / k }); x += padding; } // Generate chords for each (non-empty) subgroup-subgroup link. i = -1; while (++i < n) { j = i - 1; while (++j < n) { var source = subgroups[i + "-" + j], target = subgroups[j + "-" + i]; if (source.value || target.value) { chords.push(source.value < target.value ? {source: target, target: source} : {source: source, target: target}); } } } if (sortChords) resort(); } function resort() { chords.sort(function(a, b) { return sortChords( (a.source.value + a.target.value) / 2, (b.source.value + b.target.value) / 2); }); } chord.matrix = function(x) { if (!arguments.length) return matrix; n = (matrix = x) && matrix.length; chords = groups = null; return chord; }; chord.padding = function(x) { if (!arguments.length) return padding; padding = x; chords = groups = null; return chord; }; chord.sortGroups = function(x) { if (!arguments.length) return sortGroups; sortGroups = x; chords = groups = null; return chord; }; chord.sortSubgroups = function(x) { if (!arguments.length) return sortSubgroups; sortSubgroups = x; chords = null; return chord; }; chord.sortChords = function(x) { if (!arguments.length) return sortChords; sortChords = x; if (chords) resort(); return chord; }; chord.chords = function() { if (!chords) relayout(); return chords; }; chord.groups = function() { if (!groups) relayout(); return groups; }; return chord; }; // A rudimentary force layout using Gauss-Seidel. d3.layout.force = function() { var force = {}, event = d3.dispatch("tick"), size = [1, 1], drag, alpha, friction = .9, linkDistance = d3_layout_forceLinkDistance, linkStrength = d3_layout_forceLinkStrength, charge = -30, gravity = .1, theta = .8, interval, nodes = [], links = [], distances, strengths, charges; function repulse(node) { return function(quad, x1, y1, x2, y2) { if (quad.point !== node) { var dx = quad.cx - node.x, dy = quad.cy - node.y, dn = 1 / Math.sqrt(dx * dx + dy * dy); /* Barnes-Hut criterion. */ if ((x2 - x1) * dn < theta) { var k = quad.charge * dn * dn; node.px -= dx * k; node.py -= dy * k; return true; } if (quad.point && isFinite(dn)) { var k = quad.pointCharge * dn * dn; node.px -= dx * k; node.py -= dy * k; } } return !quad.charge; }; } function tick() { var n = nodes.length, m = links.length, q, i, // current index o, // current object s, // current source t, // current target l, // current distance k, // current force x, // x-distance y; // y-distance // gauss-seidel relaxation for links for (i = 0; i < m; ++i) { o = links[i]; s = o.source; t = o.target; x = t.x - s.x; y = t.y - s.y; if (l = (x * x + y * y)) { l = alpha * strengths[i] * ((l = Math.sqrt(l)) - distances[i]) / l; x *= l; y *= l; t.x -= x * (k = s.weight / (t.weight + s.weight)); t.y -= y * k; s.x += x * (k = 1 - k); s.y += y * k; } } // apply gravity forces if (k = alpha * gravity) { x = size[0] / 2; y = size[1] / 2; i = -1; if (k) while (++i < n) { o = nodes[i]; o.x += (x - o.x) * k; o.y += (y - o.y) * k; } } // compute quadtree center of mass and apply charge forces if (charge) { d3_layout_forceAccumulate(q = d3.geom.quadtree(nodes), alpha, charges); i = -1; while (++i < n) { if (!(o = nodes[i]).fixed) { q.visit(repulse(o)); } } } // position verlet integration i = -1; while (++i < n) { o = nodes[i]; if (o.fixed) { o.x = o.px; o.y = o.py; } else { o.x -= (o.px - (o.px = o.x)) * friction; o.y -= (o.py - (o.py = o.y)) * friction; } } event.tick({type: "tick", alpha: alpha}); // simulated annealing, basically return (alpha *= .99) < .005; } force.nodes = function(x) { if (!arguments.length) return nodes; nodes = x; return force; }; force.links = function(x) { if (!arguments.length) return links; links = x; return force; }; force.size = function(x) { if (!arguments.length) return size; size = x; return force; }; force.linkDistance = function(x) { if (!arguments.length) return linkDistance; linkDistance = d3.functor(x); return force; }; // For backwards-compatibility. force.distance = force.linkDistance; force.linkStrength = function(x) { if (!arguments.length) return linkStrength; linkStrength = d3.functor(x); return force; }; force.friction = function(x) { if (!arguments.length) return friction; friction = x; return force; }; force.charge = function(x) { if (!arguments.length) return charge; charge = typeof x === "function" ? x : +x; return force; }; force.gravity = function(x) { if (!arguments.length) return gravity; gravity = x; return force; }; force.theta = function(x) { if (!arguments.length) return theta; theta = x; return force; }; force.start = function() { var i, j, n = nodes.length, m = links.length, w = size[0], h = size[1], neighbors, o; for (i = 0; i < n; ++i) { (o = nodes[i]).index = i; o.weight = 0; } distances = []; strengths = []; for (i = 0; i < m; ++i) { o = links[i]; if (typeof o.source == "number") o.source = nodes[o.source]; if (typeof o.target == "number") o.target = nodes[o.target]; distances[i] = linkDistance.call(this, o, i); strengths[i] = linkStrength.call(this, o, i); ++o.source.weight; ++o.target.weight; } for (i = 0; i < n; ++i) { o = nodes[i]; if (isNaN(o.x)) o.x = position("x", w); if (isNaN(o.y)) o.y = position("y", h); if (isNaN(o.px)) o.px = o.x; if (isNaN(o.py)) o.py = o.y; } charges = []; if (typeof charge === "function") { for (i = 0; i < n; ++i) { charges[i] = +charge.call(this, nodes[i], i); } } else { for (i = 0; i < n; ++i) { charges[i] = charge; } } // initialize node position based on first neighbor function position(dimension, size) { var neighbors = neighbor(i), j = -1, m = neighbors.length, x; while (++j < m) if (!isNaN(x = neighbors[j][dimension])) return x; return Math.random() * size; } // initialize neighbors lazily function neighbor() { if (!neighbors) { neighbors = []; for (j = 0; j < n; ++j) { neighbors[j] = []; } for (j = 0; j < m; ++j) { var o = links[j]; neighbors[o.source.index].push(o.target); neighbors[o.target.index].push(o.source); } } return neighbors[i]; } return force.resume(); }; force.resume = function() { alpha = .1; d3.timer(tick); return force; }; force.stop = function() { alpha = 0; return force; }; // use `node.call(force.drag)` to make nodes draggable force.drag = function() { if (!drag) drag = d3.behavior.drag() .origin(Object) .on("dragstart", dragstart) .on("drag", d3_layout_forceDrag) .on("dragend", d3_layout_forceDragEnd); this.on("mouseover.force", d3_layout_forceDragOver) .on("mouseout.force", d3_layout_forceDragOut) .call(drag); }; function dragstart(d) { d3_layout_forceDragOver(d3_layout_forceDragNode = d); d3_layout_forceDragForce = force; } return d3.rebind(force, event, "on"); }; var d3_layout_forceDragForce, d3_layout_forceDragNode; function d3_layout_forceDragOver(d) { d.fixed |= 2; } function d3_layout_forceDragOut(d) { if (d !== d3_layout_forceDragNode) d.fixed &= 1; } function d3_layout_forceDragEnd() { d3_layout_forceDrag(); d3_layout_forceDragNode.fixed &= 1; d3_layout_forceDragForce = d3_layout_forceDragNode = null; } function d3_layout_forceDrag() { d3_layout_forceDragNode.px = d3.event.x; d3_layout_forceDragNode.py = d3.event.y; d3_layout_forceDragForce.resume(); // restart annealing } function d3_layout_forceAccumulate(quad, alpha, charges) { var cx = 0, cy = 0; quad.charge = 0; if (!quad.leaf) { var nodes = quad.nodes, n = nodes.length, i = -1, c; while (++i < n) { c = nodes[i]; if (c == null) continue; d3_layout_forceAccumulate(c, alpha, charges); quad.charge += c.charge; cx += c.charge * c.cx; cy += c.charge * c.cy; } } if (quad.point) { // jitter internal nodes that are coincident if (!quad.leaf) { quad.point.x += Math.random() - .5; quad.point.y += Math.random() - .5; } var k = alpha * charges[quad.point.index]; quad.charge += quad.pointCharge = k; cx += k * quad.point.x; cy += k * quad.point.y; } quad.cx = cx / quad.charge; quad.cy = cy / quad.charge; } function d3_layout_forceLinkDistance(link) { return 20; } function d3_layout_forceLinkStrength(link) { return 1; } d3.layout.partition = function() { var hierarchy = d3.layout.hierarchy(), size = [1, 1]; // width, height function position(node, x, dx, dy) { var children = node.children; node.x = x; node.y = node.depth * dy; node.dx = dx; node.dy = dy; if (children && (n = children.length)) { var i = -1, n, c, d; dx = node.value ? dx / node.value : 0; while (++i < n) { position(c = children[i], x, d = c.value * dx, dy); x += d; } } } function depth(node) { var children = node.children, d = 0; if (children && (n = children.length)) { var i = -1, n; while (++i < n) d = Math.max(d, depth(children[i])); } return 1 + d; } function partition(d, i) { var nodes = hierarchy.call(this, d, i); position(nodes[0], 0, size[0], size[1] / depth(nodes[0])); return nodes; } partition.size = function(x) { if (!arguments.length) return size; size = x; return partition; }; return d3_layout_hierarchyRebind(partition, hierarchy); }; d3.layout.pie = function() { var value = Number, sort = d3_layout_pieSortByValue, startAngle = 0, endAngle = 2 * Math.PI; function pie(data, i) { // Compute the numeric values for each data element. var values = data.map(function(d, i) { return +value.call(pie, d, i); }); // Compute the start angle. var a = +(typeof startAngle === "function" ? startAngle.apply(this, arguments) : startAngle); // Compute the angular scale factor: from value to radians. var k = ((typeof endAngle === "function" ? endAngle.apply(this, arguments) : endAngle) - startAngle) / d3.sum(values); // Optionally sort the data. var index = d3.range(data.length); if (sort != null) index.sort(sort === d3_layout_pieSortByValue ? function(i, j) { return values[j] - values[i]; } : function(i, j) { return sort(data[i], data[j]); }); // Compute the arcs! // They are stored in the original data's order. var arcs = []; index.forEach(function(i) { arcs[i] = { data: data[i], value: d = values[i], startAngle: a, endAngle: a += d * k }; }); return arcs; } /** * Specifies the value function *x*, which returns a nonnegative numeric value * for each datum. The default value function is `Number`. The value function * is passed two arguments: the current datum and the current index. */ pie.value = function(x) { if (!arguments.length) return value; value = x; return pie; }; /** * Specifies a sort comparison operator *x*. The comparator is passed two data * elements from the data array, a and b; it returns a negative value if a is * less than b, a positive value if a is greater than b, and zero if a equals * b. */ pie.sort = function(x) { if (!arguments.length) return sort; sort = x; return pie; }; /** * Specifies the overall start angle of the pie chart. Defaults to 0. The * start angle can be specified either as a constant or as a function; in the * case of a function, it is evaluated once per array (as opposed to per * element). */ pie.startAngle = function(x) { if (!arguments.length) return startAngle; startAngle = x; return pie; }; /** * Specifies the overall end angle of the pie chart. Defaults to 2π. The * end angle can be specified either as a constant or as a function; in the * case of a function, it is evaluated once per array (as opposed to per * element). */ pie.endAngle = function(x) { if (!arguments.length) return endAngle; endAngle = x; return pie; }; return pie; }; var d3_layout_pieSortByValue = {}; // data is two-dimensional array of x,y; we populate y0 d3.layout.stack = function() { var values = Object, order = d3_layout_stackOrders["default"], offset = d3_layout_stackOffsets["zero"], out = d3_layout_stackOut, x = d3_layout_stackX, y = d3_layout_stackY; function stack(data, index) { // Convert series to canonical two-dimensional representation. var series = data.map(function(d, i) { return values.call(stack, d, i); }); // Convert each series to canonical [[x,y]] representation. var points = series.map(function(d, i) { return d.map(function(v, i) { return [x.call(stack, v, i), y.call(stack, v, i)]; }); }); // Compute the order of series, and permute them. var orders = order.call(stack, points, index); series = d3.permute(series, orders); points = d3.permute(points, orders); // Compute the baseline… var offsets = offset.call(stack, points, index); // And propagate it to other series. var n = series.length, m = series[0].length, i, j, o; for (j = 0; j < m; ++j) { out.call(stack, series[0][j], o = offsets[j], points[0][j][1]); for (i = 1; i < n; ++i) { out.call(stack, series[i][j], o += points[i - 1][j][1], points[i][j][1]); } } return data; } stack.values = function(x) { if (!arguments.length) return values; values = x; return stack; }; stack.order = function(x) { if (!arguments.length) return order; order = typeof x === "function" ? x : d3_layout_stackOrders[x]; return stack; }; stack.offset = function(x) { if (!arguments.length) return offset; offset = typeof x === "function" ? x : d3_layout_stackOffsets[x]; return stack; }; stack.x = function(z) { if (!arguments.length) return x; x = z; return stack; }; stack.y = function(z) { if (!arguments.length) return y; y = z; return stack; }; stack.out = function(z) { if (!arguments.length) return out; out = z; return stack; }; return stack; } function d3_layout_stackX(d) { return d.x; } function d3_layout_stackY(d) { return d.y; } function d3_layout_stackOut(d, y0, y) { d.y0 = y0; d.y = y; } var d3_layout_stackOrders = { "inside-out": function(data) { var n = data.length, i, j, max = data.map(d3_layout_stackMaxIndex), sums = data.map(d3_layout_stackReduceSum), index = d3.range(n).sort(function(a, b) { return max[a] - max[b]; }), top = 0, bottom = 0, tops = [], bottoms = []; for (i = 0; i < n; ++i) { j = index[i]; if (top < bottom) { top += sums[j]; tops.push(j); } else { bottom += sums[j]; bottoms.push(j); } } return bottoms.reverse().concat(tops); }, "reverse": function(data) { return d3.range(data.length).reverse(); }, "default": function(data) { return d3.range(data.length); } }; var d3_layout_stackOffsets = { "silhouette": function(data) { var n = data.length, m = data[0].length, sums = [], max = 0, i, j, o, y0 = []; for (j = 0; j < m; ++j) { for (i = 0, o = 0; i < n; i++) o += data[i][j][1]; if (o > max) max = o; sums.push(o); } for (j = 0; j < m; ++j) { y0[j] = (max - sums[j]) / 2; } return y0; }, "wiggle": function(data) { var n = data.length, x = data[0], m = x.length, max = 0, i, j, k, s1, s2, s3, dx, o, o0, y0 = []; y0[0] = o = o0 = 0; for (j = 1; j < m; ++j) { for (i = 0, s1 = 0; i < n; ++i) s1 += data[i][j][1]; for (i = 0, s2 = 0, dx = x[j][0] - x[j - 1][0]; i < n; ++i) { for (k = 0, s3 = (data[i][j][1] - data[i][j - 1][1]) / (2 * dx); k < i; ++k) { s3 += (data[k][j][1] - data[k][j - 1][1]) / dx; } s2 += s3 * data[i][j][1]; } y0[j] = o -= s1 ? s2 / s1 * dx : 0; if (o < o0) o0 = o; } for (j = 0; j < m; ++j) y0[j] -= o0; return y0; }, "expand": function(data) { var n = data.length, m = data[0].length, k = 1 / n, i, j, o, y0 = []; for (j = 0; j < m; ++j) { for (i = 0, o = 0; i < n; i++) o += data[i][j][1]; if (o) for (i = 0; i < n; i++) data[i][j][1] /= o; else for (i = 0; i < n; i++) data[i][j][1] = k; } for (j = 0; j < m; ++j) y0[j] = 0; return y0; }, "zero": function(data) { var j = -1, m = data[0].length, y0 = []; while (++j < m) y0[j] = 0; return y0; } }; function d3_layout_stackMaxIndex(array) { var i = 1, j = 0, v = array[0][1], k, n = array.length; for (; i < n; ++i) { if ((k = array[i][1]) > v) { j = i; v = k; } } return j; } function d3_layout_stackReduceSum(d) { return d.reduce(d3_layout_stackSum, 0); } function d3_layout_stackSum(p, d) { return p + d[1]; } d3.layout.histogram = function() { var frequency = true, valuer = Number, ranger = d3_layout_histogramRange, binner = d3_layout_histogramBinSturges; function histogram(data, i) { var bins = [], values = data.map(valuer, this), range = ranger.call(this, values, i), thresholds = binner.call(this, range, values, i), bin, i = -1, n = values.length, m = thresholds.length - 1, k = frequency ? 1 : 1 / n, x; // Initialize the bins. while (++i < m) { bin = bins[i] = []; bin.dx = thresholds[i + 1] - (bin.x = thresholds[i]); bin.y = 0; } // Fill the bins, ignoring values outside the range. i = -1; while(++i < n) { x = values[i]; if ((x >= range[0]) && (x <= range[1])) { bin = bins[d3.bisect(thresholds, x, 1, m) - 1]; bin.y += k; bin.push(data[i]); } } return bins; } // Specifies how to extract a value from the associated data. The default // value function is `Number`, which is equivalent to the identity function. histogram.value = function(x) { if (!arguments.length) return valuer; valuer = x; return histogram; }; // Specifies the range of the histogram. Values outside the specified range // will be ignored. The argument `x` may be specified either as a two-element // array representing the minimum and maximum value of the range, or as a // function that returns the range given the array of values and the current // index `i`. The default range is the extent (minimum and maximum) of the // values. histogram.range = function(x) { if (!arguments.length) return ranger; ranger = d3.functor(x); return histogram; }; // Specifies how to bin values in the histogram. The argument `x` may be // specified as a number, in which case the range of values will be split // uniformly into the given number of bins. Or, `x` may be an array of // threshold values, defining the bins; the specified array must contain the // rightmost (upper) value, thus specifying n + 1 values for n bins. Or, `x` // may be a function which is evaluated, being passed the range, the array of // values, and the current index `i`, returning an array of thresholds. The // default bin function will divide the values into uniform bins using // Sturges' formula. histogram.bins = function(x) { if (!arguments.length) return binner; binner = typeof x === "number" ? function(range) { return d3_layout_histogramBinFixed(range, x); } : d3.functor(x); return histogram; }; // Specifies whether the histogram's `y` value is a count (frequency) or a // probability (density). The default value is true. histogram.frequency = function(x) { if (!arguments.length) return frequency; frequency = !!x; return histogram; }; return histogram; }; function d3_layout_histogramBinSturges(range, values) { return d3_layout_histogramBinFixed(range, Math.ceil(Math.log(values.length) / Math.LN2 + 1)); } function d3_layout_histogramBinFixed(range, n) { var x = -1, b = +range[0], m = (range[1] - b) / n, f = []; while (++x <= n) f[x] = m * x + b; return f; } function d3_layout_histogramRange(values) { return [d3.min(values), d3.max(values)]; } d3.layout.hierarchy = function() { var sort = d3_layout_hierarchySort, children = d3_layout_hierarchyChildren, value = d3_layout_hierarchyValue; // Recursively compute the node depth and value. // Also converts the data representation into a standard hierarchy structure. function recurse(data, depth, nodes) { var childs = children.call(hierarchy, data, depth), node = d3_layout_hierarchyInline ? data : {data: data}; node.depth = depth; nodes.push(node); if (childs && (n = childs.length)) { var i = -1, n, c = node.children = [], v = 0, j = depth + 1; while (++i < n) { d = recurse(childs[i], j, nodes); d.parent = node; c.push(d); v += d.value; } if (sort) c.sort(sort); if (value) node.value = v; } else if (value) { node.value = +value.call(hierarchy, data, depth) || 0; } return node; } // Recursively re-evaluates the node value. function revalue(node, depth) { var children = node.children, v = 0; if (children && (n = children.length)) { var i = -1, n, j = depth + 1; while (++i < n) v += revalue(children[i], j); } else if (value) { v = +value.call(hierarchy, d3_layout_hierarchyInline ? node : node.data, depth) || 0; } if (value) node.value = v; return v; } function hierarchy(d) { var nodes = []; recurse(d, 0, nodes); return nodes; } hierarchy.sort = function(x) { if (!arguments.length) return sort; sort = x; return hierarchy; }; hierarchy.children = function(x) { if (!arguments.length) return children; children = x; return hierarchy; }; hierarchy.value = function(x) { if (!arguments.length) return value; value = x; return hierarchy; }; // Re-evaluates the `value` property for the specified hierarchy. hierarchy.revalue = function(root) { revalue(root, 0); return root; }; return hierarchy; }; // A method assignment helper for hierarchy subclasses. function d3_layout_hierarchyRebind(object, hierarchy) { d3.rebind(object, hierarchy, "sort", "children", "value"); // Add an alias for links, for convenience. object.links = d3_layout_hierarchyLinks; // If the new API is used, enabling inlining. object.nodes = function(d) { d3_layout_hierarchyInline = true; return (object.nodes = object)(d); }; return object; } function d3_layout_hierarchyChildren(d) { return d.children; } function d3_layout_hierarchyValue(d) { return d.value; } function d3_layout_hierarchySort(a, b) { return b.value - a.value; } // Returns an array source+target objects for the specified nodes. function d3_layout_hierarchyLinks(nodes) { return d3.merge(nodes.map(function(parent) { return (parent.children || []).map(function(child) { return {source: parent, target: child}; }); })); } // For backwards-compatibility, don't enable inlining by default. var d3_layout_hierarchyInline = false; d3.layout.pack = function() { var hierarchy = d3.layout.hierarchy().sort(d3_layout_packSort), size = [1, 1]; function pack(d, i) { var nodes = hierarchy.call(this, d, i), root = nodes[0]; // Recursively compute the layout. root.x = 0; root.y = 0; d3_layout_packTree(root); // Scale the layout to fit the requested size. var w = size[0], h = size[1], k = 1 / Math.max(2 * root.r / w, 2 * root.r / h); d3_layout_packTransform(root, w / 2, h / 2, k); return nodes; } pack.size = function(x) { if (!arguments.length) return size; size = x; return pack; }; return d3_layout_hierarchyRebind(pack, hierarchy); }; function d3_layout_packSort(a, b) { return a.value - b.value; } function d3_layout_packInsert(a, b) { var c = a._pack_next; a._pack_next = b; b._pack_prev = a; b._pack_next = c; c._pack_prev = b; } function d3_layout_packSplice(a, b) { a._pack_next = b; b._pack_prev = a; } function d3_layout_packIntersects(a, b) { var dx = b.x - a.x, dy = b.y - a.y, dr = a.r + b.r; return (dr * dr - dx * dx - dy * dy) > .001; // within epsilon } function d3_layout_packCircle(nodes) { var xMin = Infinity, xMax = -Infinity, yMin = Infinity, yMax = -Infinity, n = nodes.length, a, b, c, j, k; function bound(node) { xMin = Math.min(node.x - node.r, xMin); xMax = Math.max(node.x + node.r, xMax); yMin = Math.min(node.y - node.r, yMin); yMax = Math.max(node.y + node.r, yMax); } // Create node links. nodes.forEach(d3_layout_packLink); // Create first node. a = nodes[0]; a.x = -a.r; a.y = 0; bound(a); // Create second node. if (n > 1) { b = nodes[1]; b.x = b.r; b.y = 0; bound(b); // Create third node and build chain. if (n > 2) { c = nodes[2]; d3_layout_packPlace(a, b, c); bound(c); d3_layout_packInsert(a, c); a._pack_prev = c; d3_layout_packInsert(c, b); b = a._pack_next; // Now iterate through the rest. for (var i = 3; i < n; i++) { d3_layout_packPlace(a, b, c = nodes[i]); // Search for the closest intersection. var isect = 0, s1 = 1, s2 = 1; for (j = b._pack_next; j !== b; j = j._pack_next, s1++) { if (d3_layout_packIntersects(j, c)) { isect = 1; break; } } if (isect == 1) { for (k = a._pack_prev; k !== j._pack_prev; k = k._pack_prev, s2++) { if (d3_layout_packIntersects(k, c)) { if (s2 < s1) { isect = -1; j = k; } break; } } } // Update node chain. if (isect == 0) { d3_layout_packInsert(a, c); b = c; bound(c); } else if (isect > 0) { d3_layout_packSplice(a, j); b = j; i--; } else { // isect < 0 d3_layout_packSplice(j, b); a = j; i--; } } } } // Re-center the circles and return the encompassing radius. var cx = (xMin + xMax) / 2, cy = (yMin + yMax) / 2, cr = 0; for (var i = 0; i < n; i++) { var node = nodes[i]; node.x -= cx; node.y -= cy; cr = Math.max(cr, node.r + Math.sqrt(node.x * node.x + node.y * node.y)); } // Remove node links. nodes.forEach(d3_layout_packUnlink); return cr; } function d3_layout_packLink(node) { node._pack_next = node._pack_prev = node; } function d3_layout_packUnlink(node) { delete node._pack_next; delete node._pack_prev; } function d3_layout_packTree(node) { var children = node.children; if (children && children.length) { children.forEach(d3_layout_packTree); node.r = d3_layout_packCircle(children); } else { node.r = Math.sqrt(node.value); } } function d3_layout_packTransform(node, x, y, k) { var children = node.children; node.x = (x += k * node.x); node.y = (y += k * node.y); node.r *= k; if (children) { var i = -1, n = children.length; while (++i < n) d3_layout_packTransform(children[i], x, y, k); } } function d3_layout_packPlace(a, b, c) { var db = a.r + c.r, dx = b.x - a.x, dy = b.y - a.y; if (db && (dx || dy)) { var da = b.r + c.r, dc = Math.sqrt(dx * dx + dy * dy), cos = Math.max(-1, Math.min(1, (db * db + dc * dc - da * da) / (2 * db * dc))), theta = Math.acos(cos), x = cos * (db /= dc), y = Math.sin(theta) * db; c.x = a.x + x * dx + y * dy; c.y = a.y + x * dy - y * dx; } else { c.x = a.x + db; c.y = a.y; } } // Implements a hierarchical layout using the cluster (or dendogram) algorithm. d3.layout.cluster = function() { var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [1, 1]; // width, height function cluster(d, i) { var nodes = hierarchy.call(this, d, i), root = nodes[0], previousNode, x = 0, kx, ky; // First walk, computing the initial x & y values. d3_layout_treeVisitAfter(root, function(node) { var children = node.children; if (children && children.length) { node.x = d3_layout_clusterX(children); node.y = d3_layout_clusterY(children); } else { node.x = previousNode ? x += separation(node, previousNode) : 0; node.y = 0; previousNode = node; } }); // Compute the left-most, right-most, and depth-most nodes for extents. var left = d3_layout_clusterLeft(root), right = d3_layout_clusterRight(root), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2; // Second walk, normalizing x & y to the desired size. d3_layout_treeVisitAfter(root, function(node) { node.x = (node.x - x0) / (x1 - x0) * size[0]; node.y = (1 - (root.y ? node.y / root.y : 1)) * size[1]; }); return nodes; } cluster.separation = function(x) { if (!arguments.length) return separation; separation = x; return cluster; }; cluster.size = function(x) { if (!arguments.length) return size; size = x; return cluster; }; return d3_layout_hierarchyRebind(cluster, hierarchy); }; function d3_layout_clusterY(children) { return 1 + d3.max(children, function(child) { return child.y; }); } function d3_layout_clusterX(children) { return children.reduce(function(x, child) { return x + child.x; }, 0) / children.length; } function d3_layout_clusterLeft(node) { var children = node.children; return children && children.length ? d3_layout_clusterLeft(children[0]) : node; } function d3_layout_clusterRight(node) { var children = node.children, n; return children && (n = children.length) ? d3_layout_clusterRight(children[n - 1]) : node; } // Node-link tree diagram using the Reingold-Tilford "tidy" algorithm d3.layout.tree = function() { var hierarchy = d3.layout.hierarchy().sort(null).value(null), separation = d3_layout_treeSeparation, size = [1, 1]; // width, height function tree(d, i) { var nodes = hierarchy.call(this, d, i), root = nodes[0]; function firstWalk(node, previousSibling) { var children = node.children, layout = node._tree; if (children && (n = children.length)) { var n, firstChild = children[0], previousChild, ancestor = firstChild, child, i = -1; while (++i < n) { child = children[i]; firstWalk(child, previousChild); ancestor = apportion(child, previousChild, ancestor); previousChild = child; } d3_layout_treeShift(node); var midpoint = .5 * (firstChild._tree.prelim + child._tree.prelim); if (previousSibling) { layout.prelim = previousSibling._tree.prelim + separation(node, previousSibling); layout.mod = layout.prelim - midpoint; } else { layout.prelim = midpoint; } } else { if (previousSibling) { layout.prelim = previousSibling._tree.prelim + separation(node, previousSibling); } } } function secondWalk(node, x) { node.x = node._tree.prelim + x; var children = node.children; if (children && (n = children.length)) { var i = -1, n; x += node._tree.mod; while (++i < n) { secondWalk(children[i], x); } } } function apportion(node, previousSibling, ancestor) { if (previousSibling) { var vip = node, vop = node, vim = previousSibling, vom = node.parent.children[0], sip = vip._tree.mod, sop = vop._tree.mod, sim = vim._tree.mod, som = vom._tree.mod, shift; while (vim = d3_layout_treeRight(vim), vip = d3_layout_treeLeft(vip), vim && vip) { vom = d3_layout_treeLeft(vom); vop = d3_layout_treeRight(vop); vop._tree.ancestor = node; shift = vim._tree.prelim + sim - vip._tree.prelim - sip + separation(vim, vip); if (shift > 0) { d3_layout_treeMove(d3_layout_treeAncestor(vim, node, ancestor), node, shift); sip += shift; sop += shift; } sim += vim._tree.mod; sip += vip._tree.mod; som += vom._tree.mod; sop += vop._tree.mod; } if (vim && !d3_layout_treeRight(vop)) { vop._tree.thread = vim; vop._tree.mod += sim - sop; } if (vip && !d3_layout_treeLeft(vom)) { vom._tree.thread = vip; vom._tree.mod += sip - som; ancestor = node; } } return ancestor; } // Initialize temporary layout variables. d3_layout_treeVisitAfter(root, function(node, previousSibling) { node._tree = { ancestor: node, prelim: 0, mod: 0, change: 0, shift: 0, number: previousSibling ? previousSibling._tree.number + 1 : 0 }; }); // Compute the layout using Buchheim et al.'s algorithm. firstWalk(root); secondWalk(root, -root._tree.prelim); // Compute the left-most, right-most, and depth-most nodes for extents. var left = d3_layout_treeSearch(root, d3_layout_treeLeftmost), right = d3_layout_treeSearch(root, d3_layout_treeRightmost), deep = d3_layout_treeSearch(root, d3_layout_treeDeepest), x0 = left.x - separation(left, right) / 2, x1 = right.x + separation(right, left) / 2, y1 = deep.depth || 1; // Clear temporary layout variables; transform x and y. d3_layout_treeVisitAfter(root, function(node) { node.x = (node.x - x0) / (x1 - x0) * size[0]; node.y = node.depth / y1 * size[1]; delete node._tree; }); return nodes; } tree.separation = function(x) { if (!arguments.length) return separation; separation = x; return tree; }; tree.size = function(x) { if (!arguments.length) return size; size = x; return tree; }; return d3_layout_hierarchyRebind(tree, hierarchy); }; function d3_layout_treeSeparation(a, b) { return a.parent == b.parent ? 1 : 2; } // function d3_layout_treeSeparationRadial(a, b) { // return (a.parent == b.parent ? 1 : 2) / a.depth; // } function d3_layout_treeLeft(node) { var children = node.children; return children && children.length ? children[0] : node._tree.thread; } function d3_layout_treeRight(node) { var children = node.children, n; return children && (n = children.length) ? children[n - 1] : node._tree.thread; } function d3_layout_treeSearch(node, compare) { var children = node.children; if (children && (n = children.length)) { var child, n, i = -1; while (++i < n) { if (compare(child = d3_layout_treeSearch(children[i], compare), node) > 0) { node = child; } } } return node; } function d3_layout_treeRightmost(a, b) { return a.x - b.x; } function d3_layout_treeLeftmost(a, b) { return b.x - a.x; } function d3_layout_treeDeepest(a, b) { return a.depth - b.depth; } function d3_layout_treeVisitAfter(node, callback) { function visit(node, previousSibling) { var children = node.children; if (children && (n = children.length)) { var child, previousChild = null, i = -1, n; while (++i < n) { child = children[i]; visit(child, previousChild); previousChild = child; } } callback(node, previousSibling); } visit(node, null); } function d3_layout_treeShift(node) { var shift = 0, change = 0, children = node.children, i = children.length, child; while (--i >= 0) { child = children[i]._tree; child.prelim += shift; child.mod += shift; shift += child.shift + (change += child.change); } } function d3_layout_treeMove(ancestor, node, shift) { ancestor = ancestor._tree; node = node._tree; var change = shift / (node.number - ancestor.number); ancestor.change += change; node.change -= change; node.shift += shift; node.prelim += shift; node.mod += shift; } function d3_layout_treeAncestor(vim, node, ancestor) { return vim._tree.ancestor.parent == node.parent ? vim._tree.ancestor : ancestor; } // Squarified Treemaps by Mark Bruls, Kees Huizing, and Jarke J. van Wijk // Modified to support a target aspect ratio by Jeff Heer d3.layout.treemap = function() { var hierarchy = d3.layout.hierarchy(), round = Math.round, size = [1, 1], // width, height padding = null, pad = d3_layout_treemapPadNull, sticky = false, stickies, ratio = 0.5 * (1 + Math.sqrt(5)); // golden ratio // Compute the area for each child based on value & scale. function scale(children, k) { var i = -1, n = children.length, child, area; while (++i < n) { area = (child = children[i]).value * (k < 0 ? 0 : k); child.area = isNaN(area) || area <= 0 ? 0 : area; } } // Recursively arranges the specified node's children into squarified rows. function squarify(node) { var children = node.children; if (children && children.length) { var rect = pad(node), row = [], remaining = children.slice(), // copy-on-write child, best = Infinity, // the best row score so far score, // the current row score u = Math.min(rect.dx, rect.dy), // initial orientation n; scale(remaining, rect.dx * rect.dy / node.value); row.area = 0; while ((n = remaining.length) > 0) { row.push(child = remaining[n - 1]); row.area += child.area; if ((score = worst(row, u)) <= best) { // continue with this orientation remaining.pop(); best = score; } else { // abort, and try a different orientation row.area -= row.pop().area; position(row, u, rect, false); u = Math.min(rect.dx, rect.dy); row.length = row.area = 0; best = Infinity; } } if (row.length) { position(row, u, rect, true); row.length = row.area = 0; } children.forEach(squarify); } } // Recursively resizes the specified node's children into existing rows. // Preserves the existing layout! function stickify(node) { var children = node.children; if (children && children.length) { var rect = pad(node), remaining = children.slice(), // copy-on-write child, row = []; scale(remaining, rect.dx * rect.dy / node.value); row.area = 0; while (child = remaining.pop()) { row.push(child); row.area += child.area; if (child.z != null) { position(row, child.z ? rect.dx : rect.dy, rect, !remaining.length); row.length = row.area = 0; } } children.forEach(stickify); } } // Computes the score for the specified row, as the worst aspect ratio. function worst(row, u) { var s = row.area, r, rmax = 0, rmin = Infinity, i = -1, n = row.length; while (++i < n) { if (!(r = row[i].area)) continue; if (r < rmin) rmin = r; if (r > rmax) rmax = r; } s *= s; u *= u; return s ? Math.max((u * rmax * ratio) / s, s / (u * rmin * ratio)) : Infinity; } // Positions the specified row of nodes. Modifies `rect`. function position(row, u, rect, flush) { var i = -1, n = row.length, x = rect.x, y = rect.y, v = u ? round(row.area / u) : 0, o; if (u == rect.dx) { // horizontal subdivision if (flush || v > rect.dy) v = v ? rect.dy : 0; // over+underflow while (++i < n) { o = row[i]; o.x = x; o.y = y; o.dy = v; x += o.dx = v ? round(o.area / v) : 0; } o.z = true; o.dx += rect.x + rect.dx - x; // rounding error rect.y += v; rect.dy -= v; } else { // vertical subdivision if (flush || v > rect.dx) v = v ? rect.dx : 0; // over+underflow while (++i < n) { o = row[i]; o.x = x; o.y = y; o.dx = v; y += o.dy = v ? round(o.area / v) : 0; } o.z = false; o.dy += rect.y + rect.dy - y; // rounding error rect.x += v; rect.dx -= v; } } function treemap(d) { var nodes = stickies || hierarchy(d), root = nodes[0]; root.x = 0; root.y = 0; root.dx = size[0]; root.dy = size[1]; if (stickies) hierarchy.revalue(root); scale([root], root.dx * root.dy / root.value); (stickies ? stickify : squarify)(root); if (sticky) stickies = nodes; return nodes; } treemap.size = function(x) { if (!arguments.length) return size; size = x; return treemap; }; treemap.padding = function(x) { if (!arguments.length) return padding; function padFunction(node) { var p = x.call(treemap, node, node.depth); return p == null ? d3_layout_treemapPadNull(node) : d3_layout_treemapPad(node, typeof p === "number" ? [p, p, p, p] : p); } function padConstant(node) { return d3_layout_treemapPad(node, x); } var type; pad = (padding = x) == null ? d3_layout_treemapPadNull : (type = typeof x) === "function" ? padFunction : type === "number" ? (x = [x, x, x, x], padConstant) : padConstant; return treemap; }; treemap.round = function(x) { if (!arguments.length) return round != Number; round = x ? Math.round : Number; return treemap; }; treemap.sticky = function(x) { if (!arguments.length) return sticky; sticky = x; stickies = null; return treemap; }; treemap.ratio = function(x) { if (!arguments.length) return ratio; ratio = x; return treemap; }; return d3_layout_hierarchyRebind(treemap, hierarchy); }; function d3_layout_treemapPadNull(node) { return {x: node.x, y: node.y, dx: node.dx, dy: node.dy}; } function d3_layout_treemapPad(node, padding) { var x = node.x + padding[3], y = node.y + padding[0], dx = node.dx - padding[1] - padding[3], dy = node.dy - padding[0] - padding[2]; if (dx < 0) { x += dx / 2; dx = 0; } if (dy < 0) { y += dy / 2; dy = 0; } return {x: x, y: y, dx: dx, dy: dy}; } })(); science.js-1.9.3/lib/d3/d3.layout.min.js000066400000000000000000000420311256532472600176020ustar00rootroot00000000000000(function(){function a(a){var b=a.source,d=a.target,e=c(b,d),f=[b];while(b!==e)b=b.parent,f.push(b);var g=f.length;while(d!==e)f.splice(g,0,d),d=d.parent;return f}function b(a){var b=[],c=a.parent;while(c!=null)b.push(a),a=c,c=c.parent;return b.push(a),b}function c(a,c){if(a===c)return a;var d=b(a),e=b(c),f=d.pop(),g=e.pop(),h=null;while(f===g)h=f,f=d.pop(),g=e.pop();return h}function g(a){a.fixed|=2}function h(a){a!==f&&(a.fixed&=1)}function i(){j(),f.fixed&=1,e=f=null}function j(){f.px=d3.event.x,f.py=d3.event.y,e.resume()}function k(a,b,c){var d=0,e=0;a.charge=0;if(!a.leaf){var f=a.nodes,g=f.length,h=-1,i;while(++hd&&(c=b,d=e);return c}function u(a){return a.reduce(v,0)}function v(a,b){return a+b[1]}function w(a,b){return x(a,Math.ceil(Math.log(b.length)/Math.LN2+1))}function x(a,b){var c=-1,d=+a[0],e=(a[1]-d)/b,f=[];while(++c<=b)f[c]=e*c+d;return f}function y(a){return[d3.min(a),d3.max(a)]}function z(a,b){return d3.rebind(a,b,"sort","children","value"),a.links=D,a.nodes=function(b){return E=!0,(a.nodes=a)(b)},a}function A(a){return a.children}function B(a){return a.value}function C(a,b){return b.value-a.value}function D(a){return d3.merge(a.map(function(a){return(a.children||[]).map(function(b){return{source:a,target:b}})}))}function F(a,b){return a.value-b.value}function G(a,b){var c=a._pack_next;a._pack_next=b,b._pack_prev=a,b._pack_next=c,c._pack_prev=b}function H(a,b){a._pack_next=b,b._pack_prev=a}function I(a,b){var c=b.x-a.x,d=b.y-a.y,e=a.r+b.r;return e*e-c*c-d*d>.001}function J(a){function l(a){b=Math.min(a.x-a.r,b),c=Math.max(a.x+a.r,c),d=Math.min(a.y-a.r,d),e=Math.max(a.y+a.r,e)}var b=Infinity,c=-Infinity,d=Infinity,e=-Infinity,f=a.length,g,h,i,j,k;a.forEach(K),g=a[0],g.x=-g.r,g.y=0,l(g);if(f>1){h=a[1],h.x=h.r,h.y=0,l(h);if(f>2){i=a[2],O(g,h,i),l(i),G(g,i),g._pack_prev=i,G(i,h),h=g._pack_next;for(var m=3;m0?(H(g,j),h=j,m--):(H(j,h),g=j,m--)}}}var q=(b+c)/2,r=(d+e)/2,s=0;for(var m=0;m0&&(a=d)}return a}function X(a,b){return a.x-b.x}function Y(a,b){return b.x-a.x}function Z(a,b){return a.depth-b.depth}function $(a,b){function c(a,d){var e=a.children;if(e&&(i=e.length)){var f,g=null,h=-1,i;while(++h=0)f=d[e]._tree,f.prelim+=b,f.mod+=b,b+=f.shift+(c+=f.change)}function ba(a,b,c){a=a._tree,b=b._tree;var d=c/(b.number-a.number);a.change+=d,b.change-=d,b.shift+=c,b.prelim+=c,b.mod+=c}function bb(a,b,c){return a._tree.ancestor.parent==b.parent?a._tree.ancestor:c}function bc(a){return{x:a.x,y:a.y,dx:a.dx,dy:a.dy}}function bd(a,b){var c=a.x+b[3],d=a.y+b[0],e=a.dx-b[1]-b[3],f=a.dy-b[0]-b[2];return e<0&&(c+=e/2,e=0),f<0&&(d+=f/2,f=0),{x:c,y:d,dx:e,dy:f}}d3.layout={},d3.layout.bundle=function(){return function(b){var c=[],d=-1,e=b.length;while(++de&&(e=h),d.push(h)}for(g=0;g=i[0]&&o<=i[1]&&(k=g[d3.bisect(j,o,1,m)-1],k.y+=n,k.push(e[f]));return g}var a=!0,b=Number,c=y,d=w;return e.value=function(a){return arguments.length?(b=a,e):b},e.range=function(a){return arguments.length?(c=d3.functor(a),e):c},e.bins=function(a){return arguments.length?(d=typeof a=="number"?function(b){return x(b,a)}:d3.functor(a),e):d},e.frequency=function(b){return arguments.length?(a=!!b,e):a},e},d3.layout.hierarchy=function(){function e(f,h,i){var j=b.call(g,f,h),k=E?f:{data:f};k.depth=h,i.push(k);if(j&&(m=j.length)){var l=-1,m,n=k.children=[],o=0,p=h+1;while(++l0&&(ba(bb(g,a,d),a,m),i+=m,j+=m),k+=g._tree.mod,i+=e._tree.mod,l+=h._tree.mod,j+=f._tree.mod;g&&!V(f)&&(f._tree.thread=g,f._tree.mod+=k-j),e&&!U(h)&&(h._tree.thread=e,h._tree.mod+=i-l,d=a)}return d}var f=a.call(this,d,e),g=f[0];$(g,function(a,b){a._tree={ancestor:a,prelim:0,mod:0,change:0,shift:0,number:b?b._tree.number+1:0}}),h(g),i(g,-g._tree.prelim);var k=W(g,Y),l=W(g,X),m=W(g,Z),n=k.x-b(k,l)/2,o=l.x+b(l,k)/2,p=m.depth||1;return $(g,function(a){a.x=(a.x-n)/(o-n)*c[0],a.y=a.depth/p*c[1],delete a._tree}),f}var a=d3.layout.hierarchy().sort(null).value(null),b=T,c=[1,1];return d.separation=function(a){return arguments.length?(b=a,d):b},d.size=function(a){return arguments.length?(c=a,d):c},z(d,a)},d3.layout.treemap=function(){function i(a,b){var c=-1,d=a.length,e,f;while(++c0)d.push(g=f[o-1]),d.area+=g.area,(k=l(d,n))<=h?(f.pop(),h=k):(d.area-=d.pop().area,m(d,n,c,!1),n=Math.min(c.dx,c.dy),d.length=d.area=0,h=Infinity);d.length&&(m(d,n,c,!0),d.length=d.area=0),b.forEach(j)}}function k(a){var b=a.children;if(b&&b.length){var c=e(a),d=b.slice(),f,g=[];i(d,c.dx*c.dy/a.value),g.area=0;while(f=d.pop())g.push(f),g.area+=f.area,f.z!=null&&(m(g,f.z?c.dx:c.dy,c,!d.length),g.length=g.area=0);b.forEach(k)}}function l(a,b){var c=a.area,d,e=0,f=Infinity,g=-1,i=a.length;while(++ge&&(e=d)}return c*=c,b*=b,c?Math.max(b*e*h/c,c/(b*f*h)):Infinity}function m(a,c,d,e){var f=-1,g=a.length,h=d.x,i=d.y,j=c?b(a.area/c):0,k;if(c==d.dx){if(e||j>d.dy)j=j?d.dy:0;while(++fd.dx)j=j?d.dx:0;while(++f=0?a.substring(b):(b=a.length,""),d=[];while(b>0)d.push(a.substring(b-=3,b+3));return d.reverse().join(",")+c}function y(a,b){return{scale:Math.pow(10,(8-b)*3),symbol:a}}function D(a){return function(b){return b<=0?0:b>=1?1:a(b)}}function E(a){return function(b){return 1-a(1-b)}}function F(a){return function(b){return.5*(b<.5?a(2*b):2-a(2-2*b))}}function G(a){return a}function H(a){return function(b){return Math.pow(b,a)}}function I(a){return 1-Math.cos(a*Math.PI/2)}function J(a){return Math.pow(2,10*(a-1))}function K(a){return 1-Math.sqrt(1-a*a)}function L(a,b){var c;return arguments.length<2&&(b=.45),arguments.length<1?(a=1,c=b/4):c=b/(2*Math.PI)*Math.asin(1/a),function(d){return 1+a*Math.pow(2,10*-d)*Math.sin((d-c)*2*Math.PI/b)}}function M(a){return a||(a=1.70158),function(b){return b*b*((a+1)*b-a)}}function N(a){return a<1/2.75?7.5625*a*a:a<2/2.75?7.5625*(a-=1.5/2.75)*a+.75:a<2.5/2.75?7.5625*(a-=2.25/2.75)*a+.9375:7.5625*(a-=2.625/2.75)*a+.984375}function O(){d3.event.stopPropagation(),d3.event.preventDefault()}function Q(a){return a=="transform"?d3.interpolateTransform:d3.interpolate}function R(a,b){return b=b-(a=+a)?1/(b-a):0,function(c){return(c-a)*b}}function S(a,b){return b=b-(a=+a)?1/(b-a):0,function(c){return Math.max(0,Math.min(1,(c-a)*b))}}function T(a,b,c){return new U(a,b,c)}function U(a,b,c){this.r=a,this.g=b,this.b=c}function V(a){return a<16?"0"+Math.max(0,a).toString(16):Math.min(255,a).toString(16)}function W(a,b,c){var d=0,e=0,f=0,g,h,i;g=/([a-z]+)\((.*)\)/i.exec(a);if(g){h=g[2].split(",");switch(g[1]){case"hsl":return c(parseFloat(h[0]),parseFloat(h[1])/100,parseFloat(h[2])/100);case"rgb":return b(Y(h[0]),Y(h[1]),Y(h[2]))}}return(i=Z[a])?b(i.r,i.g,i.b):(a!=null&&a.charAt(0)==="#"&&(a.length===4?(d=a.charAt(1),d+=d,e=a.charAt(2),e+=e,f=a.charAt(3),f+=f):a.length===7&&(d=a.substring(1,3),e=a.substring(3,5),f=a.substring(5,7)),d=parseInt(d,16),e=parseInt(e,16),f=parseInt(f,16)),b(d,e,f))}function X(a,b,c){var d=Math.min(a/=255,b/=255,c/=255),e=Math.max(a,b,c),f=e-d,g,h,i=(e+d)/2;return f?(h=i<.5?f/(e+d):f/(2-e-d),a==e?g=(b-c)/f+(b360?a-=360:a<0&&(a+=360),a<60?d+(e-d)*a/60:a<180?e:a<240?d+(e-d)*(240-a)/60:d}function g(a){return Math.round(f(a)*255)}var d,e;return a%=360,a<0&&(a+=360),b=b<0?0:b>1?1:b,c=c<0?0:c>1?1:c,e=c<=.5?c*(1+b):c+b-c*b,d=2*c-e,T(g(a+120),g(a),g(a-120))}function bc(a){return h(a,bi),a}function bj(a){return function(){return bd(a,this)}}function bk(a){return function(){return be(a,this)}}function bm(a,b){function f(){if(b=this.classList)return b.add(a);var b=this.className,d=b.baseVal!=null,e=d?b.baseVal:b;c.lastIndex=0,c.test(e)||(e=n(e+" "+a),d?b.baseVal=e:this.className=e)}function g(){if(b=this.classList)return b.remove(a);var b=this.className,d=b.baseVal!=null,e=d?b.baseVal:b;e=n(e.replace(c," ")),d?b.baseVal=e:this.className=e}function h(){(b.apply(this,arguments)?f:g).call(this)}var c=new RegExp("(^|\\s+)"+d3.requote(a)+"(\\s+|$)","g");if(arguments.length<2){var d=this.node();if(e=d.classList)return e.contains(a);var e=d.className;return c.lastIndex=0,c.test(e.baseVal!=null?e.baseVal:e)}return this.each(typeof b=="function"?h:b?f:g)}function bn(a){return{__data__:a}}function bo(a){return function(){return bh(this,a)}}function bp(a){return arguments.length||(a=d3.ascending),function(b,c){return a(b&&b.__data__,c&&c.__data__)}}function br(a){return h(a,bs),a}function bt(a,b,c){h(a,bx);var d={},e=d3.dispatch("start","end"),f=bA;return a.id=b,a.time=c,a.tween=function(b,c){return arguments.length<2?d[b]:(c==null?delete d[b]:d[b]=c,a)},a.ease=function(b){return arguments.length?(f=typeof b=="function"?b:d3.ease.apply(d3,arguments),a):f},a.each=function(b,c){return arguments.length<2?bB.call(a,b):(e.on(b,c),a)},d3.timer(function(g){return a.each(function(h,i,j){function p(a){if(o.active>b)return r();o.active=b;for(var f in d)(f=d[f].call(l,h,i))&&k.push(f);return e.start.call(l,h,i),q(a)||d3.timer(q,0,c),1}function q(a){if(o.active!==b)return r();var c=(a-m)/n,d=f(c),g=k.length;while(g>0)k[--g].call(l,d);if(c>=1)return r(),bz=b,e.end.call(l,h,i),bz=0,1}function r(){return--o.count||delete l.__transition__,1}var k=[],l=this,m=a[j][i].delay,n=a[j][i].duration,o=l.__transition__||(l.__transition__={active:0,count:0});++o.count,m<=g?p(g):d3.timer(p,m,c)}),1},0,c),a}function bv(a,b,c){return c!=""&&bu}function bw(a,b){function d(a,d,e){var f=b.call(this,a,d);return f==null?e!=""&&bu:e!=f&&c(e,f)}function e(a,d,e){return e!=b&&c(e,b)}var c=Q(a);return typeof b=="function"?d:b==null?bv:(b+="",e)}function bB(a){for(var b=0,c=this.length;b=c.delay&&(c.flush=c.callback(a)),c=c.next;var d=bG()-b;d>24?(isFinite(d)&&(clearTimeout(bE),bE=setTimeout(bF,d)),bD=0):(bD=1,bH(bF))}function bG(){var a=null,b=bC,c=Infinity;while(b)b.flush?b=a?a.next=b.next:bC=b.next:(c=Math.min(c,b.then+b.delay),b=(a=b).next);return c}function bI(a){var b=[a.a,a.b],c=[a.c,a.d],d=bK(b),e=bJ(b,c),f=bK(bL(c,b,-e))||0;b[0]*c[1]0;j--)e.push(c(f)*j)}else{for(;fi;g--);e=e.slice(f,g)}return e},d.tickFormat=function(a,e){arguments.length<2&&(e=b_);if(arguments.length<1)return e;var f=a/d.ticks().length,g=b===cb?(h=-1e-12,Math.floor):(h=1e-12,Math.ceil),h;return function(a){return a/c(g(b(a)+h))1){h=b[1],f=a[i],i++,d+="C"+(e[0]+g[0])+","+(e[1]+g[1])+","+(f[0]-h[0])+","+(f[1]-h[1])+","+f[0]+","+f[1];for(var j=2;j9&&(f=c*3/Math.sqrt(f),g[h]=f*d,g[h+1]=f*e));h=-1;while(++h<=i)f=(a[Math.min(i,h+1)][0]-a[Math.max(0,h-1)][0])/(6*(1+g[h]*g[h])),b.push([f||0,g[h]*f||0]);return b}function cQ(a){return a.length<3?cw(a):a[0]+cC(a,cP(a))}function cR(a){var b,c=-1,d=a.length,e,f;while(++c1){var d=bO(a.domain()),e,f=-1,g=b.length,h=(b[1]-b[0])/++c,i,j;while(++f0;)(j=+b[f]-i*h)>=d[0]&&e.push(j);for(--f,i=0;++ib?1:a>=b?0:NaN},d3.descending=function(a,b){return ba?1:b>=a?0:NaN},d3.mean=function(a,b){var c=a.length,d,e=0,f=-1,g=0;if(arguments.length===1)while(++f1&&(a=a.map(b)),a=a.filter(k),a.length?d3.quantile(a.sort(d3.ascending),.5):undefined},d3.min=function(a,b){var c=-1,d=a.length,e,f;if(arguments.length===1){while(++cf&&(e=f)}else{while(++cf&&(e=f)}return e},d3.max=function(a,b){var c=-1,d=a.length,e,f;if(arguments.length===1){while(++ce&&(e=f)}else{while(++ce&&(e=f)}return e},d3.extent=function(a,b){var c=-1,d=a.length,e,f,g;if(arguments.length===1){while(++cf&&(e=f),gf&&(e=f),g1);return a+b*c*Math.sqrt(-2*Math.log(e)/e)}}},d3.sum=function(a,b){var c=0,d=a.length,e,f=-1;if(arguments.length===1)while(++f>1;a[e]>1;b0&&(e=f);return e},d3.last=function(a,b){var c=0,d=a.length,e=a[0],f;arguments.length===1&&(b=d3.ascending);while(++c=b.length)return e?e.call(a,c):d?c.sort(d):c;var h=-1,i=c.length,j=b[g++],k,l,m={};while(++h=b.length)return a;var e=[],f=c[d++],h;for(h in a)e.push({key:h,values:g(a[h],d)});return f&&e.sort(function(a,b){return f(a.key,b.key)}),e}var a={},b=[],c=[],d,e;return a.map=function(a){return f(a,0)},a.entries=function(a){return g(f(a,0),0)},a.key=function(c){return b.push(c),a},a.sortKeys=function(d){return c[b.length-1]=d,a},a.sortValues=function(b){return d=b,a},a.rollup=function(b){return e=b,a},a},d3.keys=function(a){var b=[];for(var c in a)b.push(c);return b},d3.values=function(a){var b=[];for(var c in a)b.push(a[c]);return b},d3.entries=function(a){var b=[];for(var c in a)b.push({key:c,value:a[c]});return b},d3.permute=function(a,b){var c=[],d=-1,e=b.length;while(++db)d.push(f);else while((f=a+c*++e)0&&(d=a.substring(c+1),a=a.substring(0,c)),arguments.length<2?this[a].on(d):(this[a].on(d,b),this)},d3.format=function(a){var b=s.exec(a),c=b[1]||" ",d=b[3]||"",e=b[5],f=+b[6],g=b[7],h=b[8],i=b[9],j=1,k="",l=!1;h&&(h=+h.substring(1)),e&&(c="0",g&&(f-=Math.floor((f-1)/4)));switch(i){case"n":g=!0,i="g";break;case"%":j=100,k="%",i="f";break;case"p":j=100,k="%",i="r";break;case"d":l=!0,h=0;break;case"s":j=-1,i="r"}return i=="r"&&!h&&(i="g"),i=t[i]||v,function(a){if(l&&a%1)return"";var b=a<0&&(a=-a)?"−":d;if(j<0){var m=d3.formatPrefix(a,h);a*=m.scale,k=m.symbol}else a*=j;a=i(a,h);if(e){var n=a.length+b.length;n=^]))?([+\- ])?(#)?(0)?([0-9]+)?(,)?(\.[0-9]+)?([a-zA-Z%])?/,t={g:function(a,b){return a.toPrecision(b)},e:function(a,b){return a.toExponential(b)},f:function(a,b){return a.toFixed(b)},r:function(a,b){return d3.round(a,b=u(a,b)).toFixed(Math.max(0,Math.min(20,b)))}},x=["y","z","a","f","p","n","μ","m","","k","M","G","T","P","E","Z","Y"].map(y);d3.formatPrefix=function(a,b){var c=0;return a&&(a<0&&(a*=-1),b&&(a=d3.round(a,u(a,b))),c=1+Math.floor(1e-12+Math.log(a)/Math.LN10),c=Math.max(-24,Math.min(24,Math.floor((c<=0?c+1:c-1)/3)*3))),x[8+c/3]};var z=H(2),A=H(3),B={linear:function(){return G},poly:H,quad:function(){return z},cubic:function(){return A},sin:function(){return I},exp:function(){return J},circle:function(){return K},elastic:L,back:M,bounce:function(){return N}},C={"in":function(a){return a},out:E,"in-out":F,"out-in":function(a){return F(E(a))}};d3.ease=function(a){var b=a.indexOf("-"),c=b>=0?a.substring(0,b):a,d=b>=0?a.substring(b+1):"in";return D(C[d](B[c].apply(null,Array.prototype.slice.call(arguments,1))))},d3.event=null,d3.interpolate=function(a,b){var c=d3.interpolators.length,d;while(--c>=0&&!(d=d3.interpolators[c](a,b)));return d},d3.interpolateNumber=function(a,b){return b-=a,function(c){return a+b*c}},d3.interpolateRound=function(a,b){return b-=a,function(c){return Math.round(a+b*c)}},d3.interpolateString=function(a,b){var c,d,e,f=0,g=0,h=[],i=[],j,k;P.lastIndex=0;for(d=0;c=P.exec(b);++d)c.index&&h.push(b.substring(f,g=c.index)),i.push({i:h.length,x:c[0]}),h.push(null),f=P.lastIndex;f1){while(++e=0;)if(f=c[d])e&&e.parentNode.insertBefore(f,e),e=f;return this},bi.sort=function(a){a=bp.apply(this,arguments);for(var b=-1,c=this.length;++b0&&(a=a.substring(0,e)),arguments.length<2?(e=this.node()[d])&&e._:this.each(function(e,f){function h(a){var c=d3.event;d3.event=a;try{b.call(g,g.__data__,f)}finally{d3.event=c}}var g=this;g[d]&&g.removeEventListener(a,g[d],c),b&&g.addEventListener(a,g[d]=h,c),h._=b})},bi.each=function(a){for(var b=-1,c=this.length;++b=cm?e?"M0,"+f+"A"+f+","+f+" 0 1,1 0,"+ -f+"A"+f+","+f+" 0 1,1 0,"+f+"M0,"+e+"A"+e+","+e+" 0 1,0 0,"+ -e+"A"+e+","+e+" 0 1,0 0,"+e+"Z":"M0,"+f+"A"+f+","+f+" 0 1,1 0,"+ -f+"A"+f+","+f+" 0 1,1 0,"+f+"Z":e?"M"+f*k+","+f*l+"A"+f+","+f+" 0 "+j+",1 "+f*m+","+f*n+"L"+e*m+","+e*n+"A"+e+","+e+" 0 "+j+",0 "+e*k+","+e*l+"Z":"M"+f*k+","+f*l+"A"+f+","+f+" 0 "+j+",1 "+f*m+","+f*n+"L0,0"+"Z"}var a=cn,b=co,c=cp,d=cq;return e.innerRadius=function(b){return arguments.length?(a=d3.functor(b),e):a},e.outerRadius=function(a){return arguments.length?(b=d3.functor(a),e):b},e.startAngle=function(a){return arguments.length?(c=d3.functor(a),e):c},e.endAngle=function(a){return arguments.length?(d=d3.functor(a),e):d},e.centroid=function(){var e=(a.apply(this,arguments)+b.apply(this,arguments))/2,f=(c.apply(this,arguments)+d.apply(this,arguments))/2+cl;return[Math.cos(f)*e,Math.sin(f)*e]},e};var cl=-Math.PI/2,cm=2*Math.PI-1e-6;d3.svg.line=function(){return cr(Object)};var cv={linear:cw,"step-before":cx,"step-after":cy,basis:cE,"basis-open":cF,"basis-closed":cG,bundle:cH,cardinal:cB,"cardinal-open":cz,"cardinal-closed":cA,monotone:cQ},cJ=[0,2/3,1/3,0],cK=[0,1/3,2/3,0],cL=[0,1/6,2/3,1/6];d3.svg.line.radial=function(){var a=cr(cR);return a.radius=a.x,delete a.x,a.angle=a.y,delete a.y,a},cx.reverse=cy,cy.reverse=cx,d3.svg.area=function(){return cS(Object)},d3.svg.area.radial=function(){var a=cS(cR);return a.radius=a.x,delete a.x,a.innerRadius=a.x0,delete a.x0,a.outerRadius=a.x1,delete a.x1,a.angle=a.y,delete a.y,a.startAngle=a.y0,delete a.y0,a.endAngle=a.y1,delete a.y1,a},d3.svg.chord=function(){function f(c,d){var e=g(this,a,c,d),f=g(this,b,c,d);return"M"+e.p0+i(e.r,e.p1,e.a1-e.a0)+(h(e,f)?j(e.r,e.p1,e.r,e.p0):j(e.r,e.p1,f.r,f.p0)+i(f.r,f.p1,f.a1-f.a0)+j(f.r,f.p1,e.r,e.p0))+"Z"}function g(a,b,f,g){var h=b.call(a,f,g),i=c.call(a,h,g),j=d.call(a,h,g)+cl,k=e.call(a,h,g)+cl;return{r:i,a0:j,a1:k,p0:[i*Math.cos(j),i*Math.sin(j)],p1:[i*Math.cos(k),i*Math.sin(k)]}}function h(a,b){return a.a0==b.a0&&a.a1==b.a1}function i(a,b,c){return"A"+a+","+a+" 0 "+ +(c>Math.PI)+",1 "+b}function j(a,b,c,d){return"Q 0,0 "+d}var a=cV,b=cW,c=cX,d=cp,e=cq;return f.radius=function(a){return arguments.length?(c=d3.functor(a),f):c},f.source=function(b){return arguments.length?(a=d3.functor(b),f):a},f.target=function(a){return arguments.length?(b=d3.functor(a),f):b},f.startAngle=function(a){return arguments.length?(d=d3.functor(a),f):d},f.endAngle=function(a){return arguments.length?(e=d3.functor(a),f):e},f},d3.svg.diagonal=function(){function d(d,e){var f=a.call(this,d,e),g=b.call(this,d,e),h=(f.y+g.y)/2,i=[f,{x:f.x,y:h},{x:g.x,y:h},g];return i=i.map(c),"M"+i[0]+"C"+i[1]+" "+i[2]+" "+i[3]}var a=cV,b=cW,c=c$;return d.source=function(b){return arguments.length?(a=d3.functor(b),d):a},d.target=function(a){return arguments.length?(b=d3.functor(a),d):b},d.projection=function(a){return arguments.length?(c=a,d):c},d},d3.svg.diagonal.radial=function(){var a=d3.svg.diagonal(),b=c$,c=a.projection;return a.projection=function(a){return arguments.length?c(c_(b=a)):b},a},d3.svg.mouse=function(a){return db(a,d3.event)};var da=/WebKit/.test(navigator.userAgent)?-1:0;d3.svg.touches=function(a,b){return arguments.length<2&&(b=d3.event.touches),b?d(b).map(function(b){var c=db(a,b);return c.identifier=b.identifier,c}):[]},d3.svg.symbol=function(){function c(c,d){return(de[a.call(this,c,d)]||de.circle)(b.call(this,c,d))}var a=dd,b=dc;return c.type=function(b){return arguments.length?(a=d3.functor(b),c):a},c.size=function(a){return arguments.length?(b=d3.functor(a),c):b},c};var de={circle:function(a){var b=Math.sqrt(a/Math.PI);return"M0,"+b+"A"+b+","+b+" 0 1,1 0,"+ -b+"A"+b+","+b+" 0 1,1 0,"+b+"Z"},cross:function(a){var b=Math.sqrt(a/5)/2;return"M"+ -3*b+","+ -b+"H"+ -b+"V"+ -3*b+"H"+b+"V"+ -b+"H"+3*b+"V"+b+"H"+b+"V"+3*b+"H"+ -b+"V"+b+"H"+ -3*b+"Z"},diamond:function(a){var b=Math.sqrt(a/(2*dg)),c=b*dg;return"M0,"+ -b+"L"+c+",0"+" 0,"+b+" "+ -c+",0"+"Z"},square:function(a){var b=Math.sqrt(a)/2;return"M"+ -b+","+ -b+"L"+b+","+ -b+" "+b+","+b+" "+ -b+","+b+"Z"},"triangle-down":function(a){var b=Math.sqrt(a/df),c=b*df/2;return"M0,"+c+"L"+b+","+ -c+" "+ -b+","+ -c+"Z"},"triangle-up":function(a){var b=Math.sqrt(a/df),c=b*df/2;return"M0,"+ -c+"L"+b+","+c+" "+ -b+","+c+"Z"}};d3.svg.symbolTypes=d3.keys(de);var df=Math.sqrt(3),dg=Math.tan(30*Math.PI/180);d3.svg.axis=function(){function j(j){j.each(function(k,l,m){var n=d3.select(this),o=j.delay?function(a){var b=bz;try{return bz=j.id,a.transition().delay(j[m][l].delay).duration(j[m][l].duration).ease(j.ease())}finally{bz=b}}:Object,p=a.ticks?a.ticks.apply(a,g):a.domain(),q=h==null?a.tickFormat?a.tickFormat.apply(a,g):String:h,r=dj(a,p,i),s=n.selectAll(".minor").data(r,String),t=s.enter().insert("line","g").attr("class","tick minor").style("opacity",1e-6),u=o(s.exit()).style("opacity",1e-6).remove(),v=o(s).style("opacity",1),w=n.selectAll("g").data(p,String),x=w.enter().insert("g","path").style("opacity",1e-6),y=o(w.exit()).style("opacity",1e-6).remove(),z=o(w).style("opacity",1),A,B=bP(a),C=n.selectAll(".domain").data([0]),D=C.enter().append("path").attr("class","domain"),E=o(C),F=a.copy(),G=this.__chart__||F;this.__chart__=F,x.append("line").attr("class","tick"),x.append("text"),z.select("text").text(q);switch(b){case"bottom":A=dh,v.attr("x2",0).attr("y2",d),z.select("line").attr("x2",0).attr("y2",c),z.select("text").attr("x",0).attr("y",Math.max(c,0)+f).attr("dy",".71em").attr("text-anchor","middle"),E.attr("d","M"+B[0]+","+e+"V0H"+B[1]+"V"+e);break;case"top":A=dh,v.attr("x2",0).attr("y2",-d),z.select("line").attr("x2",0).attr("y2",-c),z.select("text").attr("x",0).attr("y",-(Math.max(c,0)+f)).attr("dy","0em").attr("text-anchor","middle"),E.attr("d","M"+B[0]+","+ -e+"V0H"+B[1]+"V"+ -e);break;case"left":A=di,v.attr("x2",-d).attr("y2",0),z.select("line").attr("x2",-c).attr("y2",0),z.select("text").attr("x",-(Math.max(c,0)+f)).attr("y",0).attr("dy",".32em").attr("text-anchor","end"),E.attr("d","M"+ -e+","+B[0]+"H0V"+B[1]+"H"+ -e);break;case"right":A=di,v.attr("x2",d).attr("y2",0),z.select("line").attr("x2",c).attr("y2",0),z.select("text").attr("x",Math.max(c,0)+f).attr("y",0).attr("dy",".32em").attr("text-anchor","start"),E.attr("d","M"+e+","+B[0]+"H0V"+B[1]+"H"+e)}if(a.ticks)x.call(A,G),z.call(A,F),y.call(A,F),t.call(A,G),v.call(A,F),u.call(A,F);else{var H=F.rangeBand()/2,I=function(a){return F(a)+H};x.call(A,I),z.call(A,I)}})}var a=d3.scale.linear(),b="bottom",c=6,d=6,e=6,f=3,g=[10],h,i=0;return j.scale=function(b){return arguments.length?(a=b,j):a},j.orient=function(a){return arguments.length?(b=a,j):b},j.ticks=function(){return arguments.length?(g=arguments,j):g},j.tickFormat=function(a){return arguments.length?(h=a,j):h},j.tickSize=function(a,b,f){if(!arguments.length)return c;var g=arguments.length-1;return c=+a,d=g>1?+b:c,e=g>0?+arguments[g]:c,j},j.tickPadding=function(a){return arguments.length?(f=+a,j):f},j.tickSubdivide=function(a){return arguments.length?(i=+a,j):i},j},d3.svg.brush=function(){function e(a){var g=b&&c?["n","e","s","w","nw","ne","se","sw"]:b?["e","w"]:c?["n","s"]:[];a.each(function(){var a=d3.select(this).on("mousedown.brush",f),h=a.selectAll(".background").data([,]),i=a.selectAll(".extent").data([,]),j=a.selectAll(".resize").data(g,String),k;h.enter().append("rect").attr("class","background").style("visibility","hidden").style("pointer-events","all").style("cursor","crosshair"),i.enter().append("rect").attr("class","extent").style("cursor","move"),j.enter().append("rect").attr("class",function(a){return"resize "+a}).attr("width",6).attr("height",6).style("visibility","hidden").style("pointer-events",e.empty()?"none":"all").style("cursor",function(a){return dC[a]}),j.exit().remove(),b&&(k=bP(b),h.attr("x",k[0]).attr("width",k[1]-k[0]),dv(a,d)),c&&(k=bP(c),h.attr("y",k[0]).attr("height",k[1]-k[0]),dw(a,d))})}function f(){var a=d3.select(d3.event.target);dk=e,dm=this,dq=d,du=d3.svg.mouse(dm),(dr=a.classed("extent"))?(du[0]=d[0][0]-du[0],du[1]=d[0][1]-du[1]):a.classed("resize")?(ds=d3.event.target.__data__,du[0]=d[+/w$/.test(ds)][0],du[1]=d[+/^n/.test(ds)][1]):d3.event.altKey&&(dt=du.slice()),dn=!/^(n|s)$/.test(ds)&&b,dp=!/^(e|w)$/.test(ds)&&c,dl=g(this,arguments),dl("brushstart"),dz(),O()}function g(b,c){return function(d){var f=d3.event;try{d3.event={type:d,target:e},a[d].apply(b,c)}finally{d3.event=f}}}var a=d3.dispatch("brushstart","brush","brushend"),b,c,d=[[0,0],[0,0]];return e.x=function(a){return arguments.length?(b=a,e):b},e.y=function(a){return arguments.length?(c=a,e):c},e.extent=function(a){var f,g,h,i,j;return arguments.length?(b&&(f=a[0],g=a[1],c&&(f=f[0],g=g[0]),b.invert&&(f=b(f),g=b(g)),g= m) return -1; c = template.charCodeAt(i++); if (c == 37) { p = d3_time_parsers[template.charAt(i++)]; if (!p || ((j = p(date, string, j)) < 0)) return -1; } else if (c != string.charCodeAt(j++)) { return -1; } } return j; } var d3_time_zfill2 = d3.format("02d"), d3_time_zfill3 = d3.format("03d"), d3_time_zfill4 = d3.format("04d"), d3_time_sfill2 = d3.format("2d"); var d3_time_formats = { a: function(d) { return d3_time_weekdays[d.getDay()].substring(0, 3); }, A: function(d) { return d3_time_weekdays[d.getDay()]; }, b: function(d) { return d3_time_months[d.getMonth()].substring(0, 3); }, B: function(d) { return d3_time_months[d.getMonth()]; }, c: d3.time.format("%a %b %e %H:%M:%S %Y"), d: function(d) { return d3_time_zfill2(d.getDate()); }, e: function(d) { return d3_time_sfill2(d.getDate()); }, H: function(d) { return d3_time_zfill2(d.getHours()); }, I: function(d) { return d3_time_zfill2(d.getHours() % 12 || 12); }, j: d3_time_dayOfYear, L: function(d) { return d3_time_zfill3(d.getMilliseconds()); }, m: function(d) { return d3_time_zfill2(d.getMonth() + 1); }, M: function(d) { return d3_time_zfill2(d.getMinutes()); }, p: function(d) { return d.getHours() >= 12 ? "PM" : "AM"; }, S: function(d) { return d3_time_zfill2(d.getSeconds()); }, U: d3_time_weekNumberSunday, w: function(d) { return d.getDay(); }, W: d3_time_weekNumberMonday, x: d3.time.format("%m/%d/%y"), X: d3.time.format("%H:%M:%S"), y: function(d) { return d3_time_zfill2(d.getFullYear() % 100); }, Y: function(d) { return d3_time_zfill4(d.getFullYear() % 10000); }, Z: d3_time_zone, "%": function(d) { return "%"; } }; var d3_time_parsers = { a: d3_time_parseWeekdayAbbrev, A: d3_time_parseWeekday, b: d3_time_parseMonthAbbrev, B: d3_time_parseMonth, c: d3_time_parseLocaleFull, d: d3_time_parseDay, e: d3_time_parseDay, H: d3_time_parseHour24, I: d3_time_parseHour12, // j: function(d, s, i) { /*TODO day of year [001,366] */ return i; }, L: d3_time_parseMilliseconds, m: d3_time_parseMonthNumber, M: d3_time_parseMinutes, p: d3_time_parseAmPm, S: d3_time_parseSeconds, // U: function(d, s, i) { /*TODO week number (sunday) [00,53] */ return i; }, // w: function(d, s, i) { /*TODO weekday [0,6] */ return i; }, // W: function(d, s, i) { /*TODO week number (monday) [00,53] */ return i; }, x: d3_time_parseLocaleDate, X: d3_time_parseLocaleTime, y: d3_time_parseYear, Y: d3_time_parseFullYear // , // Z: function(d, s, i) { /*TODO time zone */ return i; }, // "%": function(d, s, i) { /*TODO literal % */ return i; } }; // Note: weekday is validated, but does not set the date. function d3_time_parseWeekdayAbbrev(date, string, i) { return string.substring(i, i += 3).toLowerCase() in d3_time_weekdayAbbrevLookup ? i : -1; } var d3_time_weekdayAbbrevLookup = { sun: 3, mon: 3, tue: 3, wed: 3, thu: 3, fri: 3, sat: 3 }; // Note: weekday is validated, but does not set the date. function d3_time_parseWeekday(date, string, i) { d3_time_weekdayRe.lastIndex = 0; var n = d3_time_weekdayRe.exec(string.substring(i, i + 10)); return n ? i += n[0].length : -1; } var d3_time_weekdayRe = /^(?:Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday)/ig; var d3_time_weekdays = [ "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" ]; function d3_time_parseMonthAbbrev(date, string, i) { var n = d3_time_monthAbbrevLookup[string.substring(i, i += 3).toLowerCase()]; return n == null ? -1 : (date.setMonth(n), i); } var d3_time_monthAbbrevLookup = { jan: 0, feb: 1, mar: 2, apr: 3, may: 4, jun: 5, jul: 6, aug: 7, sep: 8, oct: 9, nov: 10, dec: 11 }; function d3_time_parseMonth(date, string, i) { d3_time_monthRe.lastIndex = 0; var n = d3_time_monthRe.exec(string.substring(i, i + 12)); return n ? (date.setMonth(d3_time_monthLookup[n[0].toLowerCase()]), i += n[0].length) : -1; } var d3_time_monthRe = /^(?:January|February|March|April|May|June|July|August|September|October|November|December)/ig; var d3_time_monthLookup = { january: 0, february: 1, march: 2, april: 3, may: 4, june: 5, july: 6, august: 7, september: 8, october: 9, november: 10, december: 11 }; var d3_time_months = [ "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" ]; function d3_time_parseLocaleFull(date, string, i) { return d3_time_parse(date, d3_time_formats.c.toString(), string, i); } function d3_time_parseLocaleDate(date, string, i) { return d3_time_parse(date, d3_time_formats.x.toString(), string, i); } function d3_time_parseLocaleTime(date, string, i) { return d3_time_parse(date, d3_time_formats.X.toString(), string, i); } function d3_time_parseFullYear(date, string, i) { d3_time_numberRe.lastIndex = 0; var n = d3_time_numberRe.exec(string.substring(i, i + 4)); return n ? (date.setFullYear(n[0]), i += n[0].length) : -1; } function d3_time_parseYear(date, string, i) { d3_time_numberRe.lastIndex = 0; var n = d3_time_numberRe.exec(string.substring(i, i + 2)); return n ? (date.setFullYear(d3_time_century() + +n[0]), i += n[0].length) : -1; } function d3_time_century() { return ~~(new Date().getFullYear() / 1000) * 1000; } function d3_time_parseMonthNumber(date, string, i) { d3_time_numberRe.lastIndex = 0; var n = d3_time_numberRe.exec(string.substring(i, i + 2)); return n ? (date.setMonth(n[0] - 1), i += n[0].length) : -1; } function d3_time_parseDay(date, string, i) { d3_time_numberRe.lastIndex = 0; var n = d3_time_numberRe.exec(string.substring(i, i + 2)); return n ? (date.setDate(+n[0]), i += n[0].length) : -1; } // Note: we don't validate that the hour is in the range [0,23]. function d3_time_parseHour24(date, string, i) { d3_time_numberRe.lastIndex = 0; var n = d3_time_numberRe.exec(string.substring(i, i + 2)); return n ? (date.setHours(+n[0]), i += n[0].length) : -1; } // Note: we don't validate that the hour is in the range [1,12]. function d3_time_parseHour12(date, string, i) { date.hour12 = true; return d3_time_parseHour24(date, string, i); } function d3_time_parseMinutes(date, string, i) { d3_time_numberRe.lastIndex = 0; var n = d3_time_numberRe.exec(string.substring(i, i + 2)); return n ? (date.setMinutes(+n[0]), i += n[0].length) : -1; } function d3_time_parseSeconds(date, string, i) { d3_time_numberRe.lastIndex = 0; var n = d3_time_numberRe.exec(string.substring(i, i + 2)); return n ? (date.setSeconds(+n[0]), i += n[0].length) : -1; } function d3_time_parseMilliseconds(date, string, i) { d3_time_numberRe.lastIndex = 0; var n = d3_time_numberRe.exec(string.substring(i, i + 3)); return n ? (date.setMilliseconds(+n[0]), i += n[0].length) : -1; } // Note: we don't look at the next directive. var d3_time_numberRe = /\s*\d+/; function d3_time_parseAmPm(date, string, i) { var n = d3_time_amPmLookup[string.substring(i, i += 2).toLowerCase()]; return n == null ? -1 : (date.hour12pm = n, i); } var d3_time_amPmLookup = { am: 0, pm: 1 }; function d3_time_year(d) { return new d3_time(d.getFullYear(), 0, 1); } function d3_time_daysElapsed(d0, d1) { return ~~((d1 - d0) / 864e5 - (d1.getTimezoneOffset() - d0.getTimezoneOffset()) / 1440); } function d3_time_dayOfYear(d) { return d3_time_zfill3(1 + d3_time_daysElapsed(d3_time_year(d), d)); } function d3_time_weekNumberSunday(d) { var d0 = d3_time_year(d); return d3_time_zfill2(~~((d3_time_daysElapsed(d0, d) + d0.getDay()) / 7)); } function d3_time_weekNumberMonday(d) { var d0 = d3_time_year(d); return d3_time_zfill2(~~((d3_time_daysElapsed(d0, d) + (d0.getDay() + 6) % 7) / 7)); } // TODO table of time zone offset names? function d3_time_zone(d) { var z = d.getTimezoneOffset(), zs = z > 0 ? "-" : "+", zh = ~~(Math.abs(z) / 60), zm = Math.abs(z) % 60; return zs + d3_time_zfill2(zh) + d3_time_zfill2(zm); } d3.time.format.utc = function(template) { var local = d3.time.format(template); function format(date) { try { d3_time = d3_time_format_utc; var utc = new d3_time(); utc._ = date; return local(utc); } finally { d3_time = Date; } } format.parse = function(string) { try { d3_time = d3_time_format_utc; var date = local.parse(string); return date && date._; } finally { d3_time = Date; } }; format.toString = local.toString; return format; }; function d3_time_format_utc() { this._ = new Date(Date.UTC.apply(this, arguments)); } d3_time_format_utc.prototype = { getDate: function() { return this._.getUTCDate(); }, getDay: function() { return this._.getUTCDay(); }, getFullYear: function() { return this._.getUTCFullYear(); }, getHours: function() { return this._.getUTCHours(); }, getMilliseconds: function() { return this._.getUTCMilliseconds(); }, getMinutes: function() { return this._.getUTCMinutes(); }, getMonth: function() { return this._.getUTCMonth(); }, getSeconds: function() { return this._.getUTCSeconds(); }, getTimezoneOffset: function() { return 0; }, valueOf: function() { return this._.getTime(); }, setDate: function(x) { this._.setUTCDate(x); }, setDay: function(x) { this._.setUTCDay(x); }, setFullYear: function(x) { this._.setUTCFullYear(x); }, setHours: function(x) { this._.setUTCHours(x); }, setMilliseconds: function(x) { this._.setUTCMilliseconds(x); }, setMinutes: function(x) { this._.setUTCMinutes(x); }, setMonth: function(x) { this._.setUTCMonth(x); }, setSeconds: function(x) { this._.setUTCSeconds(x); } }; var d3_time_formatIso = d3.time.format.utc("%Y-%m-%dT%H:%M:%S.%LZ"); d3.time.format.iso = Date.prototype.toISOString ? d3_time_formatIsoNative : d3_time_formatIso; function d3_time_formatIsoNative(date) { return date.toISOString(); } d3_time_formatIsoNative.parse = function(string) { return new Date(string); }; d3_time_formatIsoNative.toString = d3_time_formatIso.toString; function d3_time_range(floor, step, number) { return function(t0, t1, dt) { var time = floor(t0), times = []; if (time < t0) step(time); if (dt > 1) { while (time < t1) { var date = new Date(+time); if (!(number(date) % dt)) times.push(date); step(time); } } else { while (time < t1) times.push(new Date(+time)), step(time); } return times; }; } d3.time.second = function(date) { return new Date(~~(date / 1e3) * 1e3); }; d3.time.second.utc = d3.time.second; d3.time.seconds = d3_time_range(d3.time.second, function(date) { date.setTime(date.getTime() + 1e3); }, function(date) { return date.getSeconds(); }); d3.time.seconds.utc = d3.time.seconds; d3.time.minute = function(date) { return new Date(~~(date / 6e4) * 6e4); }; d3.time.minute.utc = d3.time.minute;d3.time.minutes = d3_time_range(d3.time.minute, d3_time_minutesStep, function(date) { return date.getMinutes(); }); d3.time.minutes.utc = d3_time_range(d3.time.minute, d3_time_minutesStep, function(date) { return date.getUTCMinutes(); }); function d3_time_minutesStep(date) { date.setTime(date.getTime() + 6e4); // assumes no leap seconds } d3.time.hour = function(date) { var offset = date.getTimezoneOffset() / 60; return new Date((~~(date / 36e5 - offset) + offset) * 36e5); }; d3.time.hour.utc = function(date) { return new Date(~~(date / 36e5) * 36e5); }; d3.time.hours = d3_time_range(d3.time.hour, d3_time_hoursStep, function(date) { return date.getHours(); }); d3.time.hours.utc = d3_time_range(d3.time.hour.utc, d3_time_hoursStep, function(date) { return date.getUTCHours(); }); function d3_time_hoursStep(date) { date.setTime(date.getTime() + 36e5); } d3.time.day = function(date) { return new Date(date.getFullYear(), date.getMonth(), date.getDate()); }; d3.time.day.utc = function(date) { return new Date(~~(date / 864e5) * 864e5); }; d3.time.days = d3_time_range(d3.time.day, function(date) { date.setDate(date.getDate() + 1); }, function(date) { return date.getDate() - 1; }); d3.time.days.utc = d3_time_range(d3.time.day.utc, function(date) { date.setUTCDate(date.getUTCDate() + 1); }, function(date) { return date.getUTCDate() - 1; }); d3.time.week = function(date) { (date = d3.time.day(date)).setDate(date.getDate() - date.getDay()); return date; }; d3.time.week.utc = function(date) { (date = d3.time.day.utc(date)).setUTCDate(date.getUTCDate() - date.getUTCDay()); return date; }; d3.time.weeks = d3_time_range(d3.time.week, function(date) { date.setDate(date.getDate() + 7); }, function(date) { return ~~((date - new Date(date.getFullYear(), 0, 1)) / 6048e5); }); d3.time.weeks.utc = d3_time_range(d3.time.week.utc, function(date) { date.setUTCDate(date.getUTCDate() + 7); }, function(date) { return ~~((date - Date.UTC(date.getUTCFullYear(), 0, 1)) / 6048e5); }); d3.time.month = function(date) { return new Date(date.getFullYear(), date.getMonth(), 1); }; d3.time.month.utc = function(date) { return new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1)); }; d3.time.months = d3_time_range(d3.time.month, function(date) { date.setMonth(date.getMonth() + 1); }, function(date) { return date.getMonth(); }); d3.time.months.utc = d3_time_range(d3.time.month.utc, function(date) { date.setUTCMonth(date.getUTCMonth() + 1); }, function(date) { return date.getUTCMonth(); }); d3.time.year = function(date) { return new Date(date.getFullYear(), 0, 1); }; d3.time.year.utc = function(date) { return new Date(Date.UTC(date.getUTCFullYear(), 0, 1)); }; d3.time.years = d3_time_range(d3.time.year, function(date) { date.setFullYear(date.getFullYear() + 1); }, function(date) { return date.getFullYear(); }); d3.time.years.utc = d3_time_range(d3.time.year.utc, function(date) { date.setUTCFullYear(date.getUTCFullYear() + 1); }, function(date) { return date.getUTCFullYear(); }); // TODO nice function d3_time_scale(linear, methods, format) { function scale(x) { return linear(x); } scale.invert = function(x) { return d3_time_scaleDate(linear.invert(x)); }; scale.domain = function(x) { if (!arguments.length) return linear.domain().map(d3_time_scaleDate); linear.domain(x); return scale; }; scale.ticks = function(m, k) { var extent = d3_time_scaleExtent(scale.domain()); if (typeof m !== "function") { var span = extent[1] - extent[0], target = span / m, i = d3.bisect(d3_time_scaleSteps, target, 1, d3_time_scaleSteps.length - 1); if (Math.log(target / d3_time_scaleSteps[i - 1]) < Math.log(d3_time_scaleSteps[i] / target)) --i; m = methods[i]; k = m[1]; m = m[0]; } return m(extent[0], extent[1], k); }; scale.tickFormat = function() { return format; }; scale.copy = function() { return d3_time_scale(linear.copy(), methods, format); }; // TOOD expose d3_scale_linear_rebind? return d3.rebind(scale, linear, "range", "rangeRound", "interpolate", "clamp"); } // TODO expose d3_scaleExtent? function d3_time_scaleExtent(domain) { var start = domain[0], stop = domain[domain.length - 1]; return start < stop ? [start, stop] : [stop, start]; } function d3_time_scaleDate(t) { return new Date(t); } function d3_time_scaleFormat(formats) { return function(date) { var i = formats.length - 1, f = formats[i]; while (!f[1](date)) f = formats[--i]; return f[0](date); }; } var d3_time_scaleSteps = [ 1e3, // 1-second 5e3, // 5-second 15e3, // 15-second 3e4, // 30-second 6e4, // 1-minute 3e5, // 5-minute 9e5, // 15-minute 18e5, // 30-minute 36e5, // 1-hour 108e5, // 3-hour 216e5, // 6-hour 432e5, // 12-hour 864e5, // 1-day 1728e5, // 2-day 6048e5, // 1-week 1728e6, // 1-month 7776e6, // 3-month 31536e6 // 1-year ]; var d3_time_scaleLocalMethods = [ [d3.time.seconds, 1], [d3.time.seconds, 5], [d3.time.seconds, 15], [d3.time.seconds, 30], [d3.time.minutes, 1], [d3.time.minutes, 5], [d3.time.minutes, 15], [d3.time.minutes, 30], [d3.time.hours, 1], [d3.time.hours, 3], [d3.time.hours, 6], [d3.time.hours, 12], [d3.time.days, 1], [d3.time.days, 2], [d3.time.weeks, 1], [d3.time.months, 1], [d3.time.months, 3], [d3.time.years, 1] ]; var d3_time_scaleLocalFormats = [ [d3.time.format("%Y"), function(d) { return true; }], [d3.time.format("%B"), function(d) { return d.getMonth(); }], [d3.time.format("%b %d"), function(d) { return d.getDate() != 1; }], [d3.time.format("%a %d"), function(d) { return d.getDay() && d.getDate() != 1; }], [d3.time.format("%I %p"), function(d) { return d.getHours(); }], [d3.time.format("%I:%M"), function(d) { return d.getMinutes(); }], [d3.time.format(":%S"), function(d) { return d.getSeconds() || d.getMilliseconds(); }] ]; var d3_time_scaleLocalFormat = d3_time_scaleFormat(d3_time_scaleLocalFormats); d3.time.scale = function() { return d3_time_scale(d3.scale.linear(), d3_time_scaleLocalMethods, d3_time_scaleLocalFormat); }; var d3_time_scaleUTCMethods = [ [d3.time.seconds.utc, 1], [d3.time.seconds.utc, 5], [d3.time.seconds.utc, 15], [d3.time.seconds.utc, 30], [d3.time.minutes.utc, 1], [d3.time.minutes.utc, 5], [d3.time.minutes.utc, 15], [d3.time.minutes.utc, 30], [d3.time.hours.utc, 1], [d3.time.hours.utc, 3], [d3.time.hours.utc, 6], [d3.time.hours.utc, 12], [d3.time.days.utc, 1], [d3.time.days.utc, 2], [d3.time.weeks.utc, 1], [d3.time.months.utc, 1], [d3.time.months.utc, 3], [d3.time.years.utc, 1] ]; var d3_time_scaleUTCFormats = [ [d3.time.format.utc("%Y"), function(d) { return true; }], [d3.time.format.utc("%B"), function(d) { return d.getUTCMonth(); }], [d3.time.format.utc("%b %d"), function(d) { return d.getUTCDate() != 1; }], [d3.time.format.utc("%a %d"), function(d) { return d.getUTCDay() && d.getUTCDate() != 1; }], [d3.time.format.utc("%I %p"), function(d) { return d.getUTCHours(); }], [d3.time.format.utc("%I:%M"), function(d) { return d.getUTCMinutes(); }], [d3.time.format.utc(":%S"), function(d) { return d.getUTCSeconds() || d.getUTCMilliseconds(); }] ]; var d3_time_scaleUTCFormat = d3_time_scaleFormat(d3_time_scaleUTCFormats); d3.time.scale.utc = function() { return d3_time_scale(d3.scale.linear(), d3_time_scaleUTCMethods, d3_time_scaleUTCFormat); }; })(); science.js-1.9.3/lib/d3/d3.time.min.js000066400000000000000000000254421256532472600172320ustar00rootroot00000000000000(function(){function b(a,b,c,d){var e,f,g=0,i=b.length,j=c.length;while(g=j)return-1;e=b.charCodeAt(g++);if(e==37){f=h[b.charAt(g++)];if(!f||(d=f(a,c,d))<0)return-1}else if(e!=c.charCodeAt(d++))return-1}return d}function i(a,b,c){return b.substring(c,c+=3).toLowerCase()in j?c:-1}function k(a,b,c){l.lastIndex=0;var d=l.exec(b.substring(c,c+10));return d?c+=d[0].length:-1}function n(a,b,c){var d=o[b.substring(c,c+=3).toLowerCase()];return d==null?-1:(a.setMonth(d),c)}function p(a,b,c){q.lastIndex=0;var d=q.exec(b.substring(c,c+12));return d?(a.setMonth(r[d[0].toLowerCase()]),c+=d[0].length):-1}function t(a,c,d){return b(a,g.c.toString(),c,d)}function u(a,c,d){return b(a,g.x.toString(),c,d)}function v(a,c,d){return b(a,g.X.toString(),c,d)}function w(a,b,c){G.lastIndex=0;var d=G.exec(b.substring(c,c+4));return d?(a.setFullYear(d[0]),c+=d[0].length):-1}function x(a,b,c){G.lastIndex=0;var d=G.exec(b.substring(c,c+2));return d?(a.setFullYear(y()+ +d[0]),c+=d[0].length):-1}function y(){return~~((new Date).getFullYear()/1e3)*1e3}function z(a,b,c){G.lastIndex=0;var d=G.exec(b.substring(c,c+2));return d?(a.setMonth(d[0]-1),c+=d[0].length):-1}function A(a,b,c){G.lastIndex=0;var d=G.exec(b.substring(c,c+2));return d?(a.setDate(+d[0]),c+=d[0].length):-1}function B(a,b,c){G.lastIndex=0;var d=G.exec(b.substring(c,c+2));return d?(a.setHours(+d[0]),c+=d[0].length):-1}function C(a,b,c){return a.hour12=!0,B(a,b,c)}function D(a,b,c){G.lastIndex=0;var d=G.exec(b.substring(c,c+2));return d?(a.setMinutes(+d[0]),c+=d[0].length):-1}function E(a,b,c){G.lastIndex=0;var d=G.exec(b.substring(c,c+2));return d?(a.setSeconds(+d[0]),c+=d[0].length):-1}function F(a,b,c){G.lastIndex=0;var d=G.exec(b.substring(c,c+3));return d?(a.setMilliseconds(+d[0]),c+=d[0].length):-1}function H(a,b,c){var d=I[b.substring(c,c+=2).toLowerCase()];return d==null?-1:(a.hour12pm=d,c)}function J(b){return new a(b.getFullYear(),0,1)}function K(a,b){return~~((b-a)/864e5-(b.getTimezoneOffset()-a.getTimezoneOffset())/1440)}function L(a){return d(1+K(J(a),a))}function M(a){var b=J(a);return c(~~((K(b,a)+b.getDay())/7))}function N(a){var b=J(a);return c(~~((K(b,a)+(b.getDay()+6)%7)/7))}function O(a){var b=a.getTimezoneOffset(),d=b>0?"-":"+",e=~~(Math.abs(b)/60),f=Math.abs(b)%60;return d+c(e)+c(f)}function P(){this._=new Date(Date.UTC.apply(this,arguments))}function R(a){return a.toISOString()}function S(a,b,c){return function(d,e,f){var g=a(d),h=[];g1)while(g=12?"PM":"AM"},S:function(a){return c(a.getSeconds())},U:M,w:function(a){return a.getDay()},W:N,x:d3.time.format("%m/%d/%y"),X:d3.time.format("%H:%M:%S"),y:function(a){return c(a.getFullYear()%100)},Y:function(a){return e(a.getFullYear()%1e4)},Z:O,"%":function(a){return"%"}},h={a:i,A:k,b:n,B:p,c:t,d:A,e:A,H:B,I:C,L:F,m:z,M:D,p:H,S:E,x:u,X:v,y:x,Y:w},j={sun:3,mon:3,tue:3,wed:3,thu:3,fri:3,sat:3},l=/^(?:Sunday|Monday|Tuesday|Wednesday|Thursday|Friday|Saturday)/ig,m=["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],o={jan:0,feb:1,mar:2,apr:3,may:4,jun:5,jul:6,aug:7,sep:8,oct:9,nov:10,dec:11},q=/^(?:January|February|March|April|May|June|July|August|September|October|November|December)/ig,r={january:0,february:1,march:2,april:3,may:4,june:5,july:6,august:7,september:8,october:9,november:10,december:11},s=["January","February","March","April","May","June","July","August","September","October","November","December"],G=/\s*\d+/,I={am:0,pm:1};d3.time.format.utc=function(b){function d(b){try{a=P;var d=new a;return d._=b,c(d)}finally{a=Date}}var c=d3.time.format(b);return d.parse=function(b){try{a=P;var d=c.parse(b);return d&&d._}finally{a=Date}},d.toString=c.toString,d},P.prototype={getDate:function(){return this._.getUTCDate()},getDay:function(){return this._.getUTCDay()},getFullYear:function(){return this._.getUTCFullYear()},getHours:function(){return this._.getUTCHours()},getMilliseconds:function(){return this._.getUTCMilliseconds()},getMinutes:function(){return this._.getUTCMinutes()},getMonth:function(){return this._.getUTCMonth()},getSeconds:function(){return this._.getUTCSeconds()},getTimezoneOffset:function(){return 0},valueOf:function(){return this._.getTime()},setDate:function(a){this._.setUTCDate(a)},setDay:function(a){this._.setUTCDay(a)},setFullYear:function(a){this._.setUTCFullYear(a)},setHours:function(a){this._.setUTCHours(a)},setMilliseconds:function(a){this._.setUTCMilliseconds(a)},setMinutes:function(a){this._.setUTCMinutes(a)},setMonth:function(a){this._.setUTCMonth(a)},setSeconds:function(a){this._.setUTCSeconds(a)}};var Q=d3.time.format.utc("%Y-%m-%dT%H:%M:%S.%LZ");d3.time.format.iso=Date.prototype.toISOString?R:Q,R.parse=function(a){return new Date(a)},R.toString=Q.toString,d3.time.second=function(a){return new Date(~~(a/1e3)*1e3)},d3.time.second.utc=d3.time.second,d3.time.seconds=S(d3.time.second,function(a){a.setTime(a.getTime()+1e3)},function(a){return a.getSeconds()}),d3.time.seconds.utc=d3.time.seconds,d3.time.minute=function(a){return new Date(~~(a/6e4)*6e4)},d3.time.minute.utc=d3.time.minute,d3.time.minutes=S(d3.time.minute,T,function(a){return a.getMinutes()}),d3.time.minutes.utc=S(d3.time.minute,T,function(a){return a.getUTCMinutes()}),d3.time.hour=function(a){var b=a.getTimezoneOffset()/60;return new Date((~~(a/36e5-b)+b)*36e5)},d3.time.hour.utc=function(a){return new Date(~~(a/36e5)*36e5)},d3.time.hours=S(d3.time.hour,U,function(a){return a.getHours()}),d3.time.hours.utc=S(d3.time.hour.utc,U,function(a){return a.getUTCHours()}),d3.time.day=function(a){return new Date(a.getFullYear(),a.getMonth(),a.getDate())},d3.time.day.utc=function(a){return new Date(~~(a/864e5)*864e5)},d3.time.days=S(d3.time.day,function(a){a.setDate(a.getDate()+1)},function(a){return a.getDate()-1}),d3.time.days.utc=S(d3.time.day.utc,function(a){a.setUTCDate(a.getUTCDate()+1)},function(a){return a.getUTCDate()-1}),d3.time.week=function(a){return(a=d3.time.day(a)).setDate(a.getDate()-a.getDay()),a},d3.time.week.utc=function(a){return(a=d3.time.day.utc(a)).setUTCDate(a.getUTCDate()-a.getUTCDay()),a},d3.time.weeks=S(d3.time.week,function(a){a.setDate(a.getDate()+7)},function(a){return~~((a-new Date(a.getFullYear(),0,1))/6048e5)}),d3.time.weeks.utc=S(d3.time.week.utc,function(a){a.setUTCDate(a.getUTCDate()+7)},function(a){return~~((a-Date.UTC(a.getUTCFullYear(),0,1))/6048e5)}),d3.time.month=function(a){return new Date(a.getFullYear(),a.getMonth(),1)},d3.time.month.utc=function(a){return new Date(Date.UTC(a.getUTCFullYear(),a.getUTCMonth(),1))},d3.time.months=S(d3.time.month,function(a){a.setMonth(a.getMonth()+1)},function(a){return a.getMonth()}),d3.time.months.utc=S(d3.time.month.utc,function(a){a.setUTCMonth(a.getUTCMonth()+1)},function(a){return a.getUTCMonth()}),d3.time.year=function(a){return new Date(a.getFullYear(),0,1)},d3.time.year.utc=function(a){return new Date(Date.UTC(a.getUTCFullYear(),0,1))},d3.time.years=S(d3.time.year,function(a){a.setFullYear(a.getFullYear()+1)},function(a){return a.getFullYear()}),d3.time.years.utc=S(d3.time.year.utc,function(a){a.setUTCFullYear(a.getUTCFullYear()+1)},function(a){return a.getUTCFullYear()});var Z=[1e3,5e3,15e3,3e4,6e4,3e5,9e5,18e5,36e5,108e5,216e5,432e5,864e5,1728e5,6048e5,1728e6,7776e6,31536e6],$=[[d3.time.seconds,1],[d3.time.seconds,5],[d3.time.seconds,15],[d3.time.seconds,30],[d3.time.minutes,1],[d3.time.minutes,5],[d3.time.minutes,15],[d3.time.minutes,30],[d3.time.hours,1],[d3.time.hours,3],[d3.time.hours,6],[d3.time.hours,12],[d3.time.days,1],[d3.time.days,2],[d3.time.weeks,1],[d3.time.months,1],[d3.time.months,3],[d3.time.years,1]],_=[[d3.time.format("%Y"),function(a){return!0}],[d3.time.format("%B"),function(a){return a.getMonth()}],[d3.time.format("%b %d"),function(a){return a.getDate()!=1}],[d3.time.format("%a %d"),function(a){return a.getDay()&&a.getDate()!=1}],[d3.time.format("%I %p"),function(a){return a.getHours()}],[d3.time.format("%I:%M"),function(a){return a.getMinutes()}],[d3.time.format(":%S"),function(a){return a.getSeconds()||a.getMilliseconds()}]],ba=Y(_);d3.time.scale=function(){return V(d3.scale.linear(),$,ba)};var bb=[[d3.time.seconds.utc,1],[d3.time.seconds.utc,5],[d3.time.seconds.utc,15],[d3.time.seconds.utc,30],[d3.time.minutes.utc,1],[d3.time.minutes.utc,5],[d3.time.minutes.utc,15],[d3.time.minutes.utc,30],[d3.time.hours.utc,1],[d3.time.hours.utc,3],[d3.time.hours.utc,6],[d3.time.hours.utc,12],[d3.time.days.utc,1],[d3.time.days.utc,2],[d3.time.weeks.utc,1],[d3.time.months.utc,1],[d3.time.months.utc,3],[d3.time.years.utc,1]],bc=[[d3.time.format.utc("%Y"),function(a){return!0}],[d3.time.format.utc("%B"),function(a){return a.getUTCMonth()}],[d3.time.format.utc("%b %d"),function(a){return a.getUTCDate()!=1}],[d3.time.format.utc("%a %d"),function(a){return a.getUTCDay()&&a.getUTCDate()!=1}],[d3.time.format.utc("%I %p"),function(a){return a.getUTCHours()}],[d3.time.format.utc("%I:%M"),function(a){return a.getUTCMinutes()}],[d3.time.format.utc(":%S"),function(a){return a.getUTCSeconds()||a.getUTCMilliseconds()}]],bd=Y(bc);d3.time.scale.utc=function(){return V(d3.scale.linear(),bb,bd)}})();science.js-1.9.3/package.json000066400000000000000000000010001256532472600160410ustar00rootroot00000000000000{ "name": "science", "version": "1.9.3", "description": "Scientific and statistical computing in JavaScript.", "keywords": [ "science", "statistics", "mathematics" ], "homepage": "https://github.com/jasondavies/science.js", "author": { "name": "Jason Davies", "url": "http://www.jasondavies.com/" }, "repository": { "type": "git", "url": "http://github.com/jasondavies/science.js.git" }, "devDependencies": { "uglify-js": "2.4.24", "vows": "0.6.0" } } science.js-1.9.3/science.v1.js000066400000000000000000001277431256532472600160760ustar00rootroot00000000000000(function(exports){ (function(exports){ science = {version: "1.9.3"}; // semver science.ascending = function(a, b) { return a - b; }; // Euler's constant. science.EULER = .5772156649015329; // Compute exp(x) - 1 accurately for small x. science.expm1 = function(x) { return (x < 1e-5 && x > -1e-5) ? x + .5 * x * x : Math.exp(x) - 1; }; science.functor = function(v) { return typeof v === "function" ? v : function() { return v; }; }; // Based on: // http://www.johndcook.com/blog/2010/06/02/whats-so-hard-about-finding-a-hypotenuse/ science.hypot = function(x, y) { x = Math.abs(x); y = Math.abs(y); var max, min; if (x > y) { max = x; min = y; } else { max = y; min = x; } var r = min / max; return max * Math.sqrt(1 + r * r); }; science.quadratic = function() { var complex = false; function quadratic(a, b, c) { var d = b * b - 4 * a * c; if (d > 0) { d = Math.sqrt(d) / (2 * a); return complex ? [{r: -b - d, i: 0}, {r: -b + d, i: 0}] : [-b - d, -b + d]; } else if (d === 0) { d = -b / (2 * a); return complex ? [{r: d, i: 0}] : [d]; } else { if (complex) { d = Math.sqrt(-d) / (2 * a); return [ {r: -b, i: -d}, {r: -b, i: d} ]; } return []; } } quadratic.complex = function(x) { if (!arguments.length) return complex; complex = x; return quadratic; }; return quadratic; }; // Constructs a multi-dimensional array filled with zeroes. science.zeroes = function(n) { var i = -1, a = []; if (arguments.length === 1) while (++i < n) a[i] = 0; else while (++i < n) a[i] = science.zeroes.apply( this, Array.prototype.slice.call(arguments, 1)); return a; }; })(this); (function(exports){ science.lin = {}; science.lin.decompose = function() { function decompose(A) { var n = A.length, // column dimension V = [], d = [], e = []; for (var i = 0; i < n; i++) { V[i] = []; d[i] = []; e[i] = []; } var symmetric = true; for (var j = 0; j < n; j++) { for (var i = 0; i < n; i++) { if (A[i][j] !== A[j][i]) { symmetric = false; break; } } } if (symmetric) { for (var i = 0; i < n; i++) V[i] = A[i].slice(); // Tridiagonalize. science_lin_decomposeTred2(d, e, V); // Diagonalize. science_lin_decomposeTql2(d, e, V); } else { var H = []; for (var i = 0; i < n; i++) H[i] = A[i].slice(); // Reduce to Hessenberg form. science_lin_decomposeOrthes(H, V); // Reduce Hessenberg to real Schur form. science_lin_decomposeHqr2(d, e, H, V); } var D = []; for (var i = 0; i < n; i++) { var row = D[i] = []; for (var j = 0; j < n; j++) row[j] = i === j ? d[i] : 0; D[i][e[i] > 0 ? i + 1 : i - 1] = e[i]; } return {D: D, V: V}; } return decompose; }; // Symmetric Householder reduction to tridiagonal form. function science_lin_decomposeTred2(d, e, V) { // This is derived from the Algol procedures tred2 by // Bowdler, Martin, Reinsch, and Wilkinson, Handbook for // Auto. Comp., Vol.ii-Linear Algebra, and the corresponding // Fortran subroutine in EISPACK. var n = V.length; for (var j = 0; j < n; j++) d[j] = V[n - 1][j]; // Householder reduction to tridiagonal form. for (var i = n - 1; i > 0; i--) { // Scale to avoid under/overflow. var scale = 0, h = 0; for (var k = 0; k < i; k++) scale += Math.abs(d[k]); if (scale === 0) { e[i] = d[i - 1]; for (var j = 0; j < i; j++) { d[j] = V[i - 1][j]; V[i][j] = 0; V[j][i] = 0; } } else { // Generate Householder vector. for (var k = 0; k < i; k++) { d[k] /= scale; h += d[k] * d[k]; } var f = d[i - 1]; var g = Math.sqrt(h); if (f > 0) g = -g; e[i] = scale * g; h = h - f * g; d[i - 1] = f - g; for (var j = 0; j < i; j++) e[j] = 0; // Apply similarity transformation to remaining columns. for (var j = 0; j < i; j++) { f = d[j]; V[j][i] = f; g = e[j] + V[j][j] * f; for (var k = j+1; k <= i - 1; k++) { g += V[k][j] * d[k]; e[k] += V[k][j] * f; } e[j] = g; } f = 0; for (var j = 0; j < i; j++) { e[j] /= h; f += e[j] * d[j]; } var hh = f / (h + h); for (var j = 0; j < i; j++) e[j] -= hh * d[j]; for (var j = 0; j < i; j++) { f = d[j]; g = e[j]; for (var k = j; k <= i - 1; k++) V[k][j] -= (f * e[k] + g * d[k]); d[j] = V[i - 1][j]; V[i][j] = 0; } } d[i] = h; } // Accumulate transformations. for (var i = 0; i < n - 1; i++) { V[n - 1][i] = V[i][i]; V[i][i] = 1.0; var h = d[i + 1]; if (h != 0) { for (var k = 0; k <= i; k++) d[k] = V[k][i + 1] / h; for (var j = 0; j <= i; j++) { var g = 0; for (var k = 0; k <= i; k++) g += V[k][i + 1] * V[k][j]; for (var k = 0; k <= i; k++) V[k][j] -= g * d[k]; } } for (var k = 0; k <= i; k++) V[k][i + 1] = 0; } for (var j = 0; j < n; j++) { d[j] = V[n - 1][j]; V[n - 1][j] = 0; } V[n - 1][n - 1] = 1; e[0] = 0; } // Symmetric tridiagonal QL algorithm. function science_lin_decomposeTql2(d, e, V) { // This is derived from the Algol procedures tql2, by // Bowdler, Martin, Reinsch, and Wilkinson, Handbook for // Auto. Comp., Vol.ii-Linear Algebra, and the corresponding // Fortran subroutine in EISPACK. var n = V.length; for (var i = 1; i < n; i++) e[i - 1] = e[i]; e[n - 1] = 0; var f = 0; var tst1 = 0; var eps = 1e-12; for (var l = 0; l < n; l++) { // Find small subdiagonal element tst1 = Math.max(tst1, Math.abs(d[l]) + Math.abs(e[l])); var m = l; while (m < n) { if (Math.abs(e[m]) <= eps*tst1) { break; } m++; } // If m == l, d[l] is an eigenvalue, // otherwise, iterate. if (m > l) { var iter = 0; do { iter++; // (Could check iteration count here.) // Compute implicit shift var g = d[l]; var p = (d[l + 1] - g) / (2 * e[l]); var r = science.hypot(p, 1); if (p < 0) r = -r; d[l] = e[l] / (p + r); d[l + 1] = e[l] * (p + r); var dl1 = d[l + 1]; var h = g - d[l]; for (var i = l+2; i < n; i++) d[i] -= h; f += h; // Implicit QL transformation. p = d[m]; var c = 1; var c2 = c; var c3 = c; var el1 = e[l + 1]; var s = 0; var s2 = 0; for (var i = m - 1; i >= l; i--) { c3 = c2; c2 = c; s2 = s; g = c * e[i]; h = c * p; r = science.hypot(p,e[i]); e[i + 1] = s * r; s = e[i] / r; c = p / r; p = c * d[i] - s * g; d[i + 1] = h + s * (c * g + s * d[i]); // Accumulate transformation. for (var k = 0; k < n; k++) { h = V[k][i + 1]; V[k][i + 1] = s * V[k][i] + c * h; V[k][i] = c * V[k][i] - s * h; } } p = -s * s2 * c3 * el1 * e[l] / dl1; e[l] = s * p; d[l] = c * p; // Check for convergence. } while (Math.abs(e[l]) > eps*tst1); } d[l] = d[l] + f; e[l] = 0; } // Sort eigenvalues and corresponding vectors. for (var i = 0; i < n - 1; i++) { var k = i; var p = d[i]; for (var j = i + 1; j < n; j++) { if (d[j] < p) { k = j; p = d[j]; } } if (k != i) { d[k] = d[i]; d[i] = p; for (var j = 0; j < n; j++) { p = V[j][i]; V[j][i] = V[j][k]; V[j][k] = p; } } } } // Nonsymmetric reduction to Hessenberg form. function science_lin_decomposeOrthes(H, V) { // This is derived from the Algol procedures orthes and ortran, // by Martin and Wilkinson, Handbook for Auto. Comp., // Vol.ii-Linear Algebra, and the corresponding // Fortran subroutines in EISPACK. var n = H.length; var ort = []; var low = 0; var high = n - 1; for (var m = low + 1; m < high; m++) { // Scale column. var scale = 0; for (var i = m; i <= high; i++) scale += Math.abs(H[i][m - 1]); if (scale !== 0) { // Compute Householder transformation. var h = 0; for (var i = high; i >= m; i--) { ort[i] = H[i][m - 1] / scale; h += ort[i] * ort[i]; } var g = Math.sqrt(h); if (ort[m] > 0) g = -g; h = h - ort[m] * g; ort[m] = ort[m] - g; // Apply Householder similarity transformation // H = (I-u*u'/h)*H*(I-u*u')/h) for (var j = m; j < n; j++) { var f = 0; for (var i = high; i >= m; i--) f += ort[i] * H[i][j]; f /= h; for (var i = m; i <= high; i++) H[i][j] -= f * ort[i]; } for (var i = 0; i <= high; i++) { var f = 0; for (var j = high; j >= m; j--) f += ort[j] * H[i][j]; f /= h; for (var j = m; j <= high; j++) H[i][j] -= f * ort[j]; } ort[m] = scale * ort[m]; H[m][m - 1] = scale * g; } } // Accumulate transformations (Algol's ortran). for (var i = 0; i < n; i++) { for (var j = 0; j < n; j++) V[i][j] = i === j ? 1 : 0; } for (var m = high-1; m >= low+1; m--) { if (H[m][m - 1] !== 0) { for (var i = m + 1; i <= high; i++) ort[i] = H[i][m - 1]; for (var j = m; j <= high; j++) { var g = 0; for (var i = m; i <= high; i++) g += ort[i] * V[i][j]; // Double division avoids possible underflow g = (g / ort[m]) / H[m][m - 1]; for (var i = m; i <= high; i++) V[i][j] += g * ort[i]; } } } } // Nonsymmetric reduction from Hessenberg to real Schur form. function science_lin_decomposeHqr2(d, e, H, V) { // This is derived from the Algol procedure hqr2, // by Martin and Wilkinson, Handbook for Auto. Comp., // Vol.ii-Linear Algebra, and the corresponding // Fortran subroutine in EISPACK. var nn = H.length, n = nn - 1, low = 0, high = nn - 1, eps = 1e-12, exshift = 0, p = 0, q = 0, r = 0, s = 0, z = 0, t, w, x, y; // Store roots isolated by balanc and compute matrix norm var norm = 0; for (var i = 0; i < nn; i++) { if (i < low || i > high) { d[i] = H[i][i]; e[i] = 0; } for (var j = Math.max(i - 1, 0); j < nn; j++) norm += Math.abs(H[i][j]); } // Outer loop over eigenvalue index var iter = 0; while (n >= low) { // Look for single small sub-diagonal element var l = n; while (l > low) { s = Math.abs(H[l - 1][l - 1]) + Math.abs(H[l][l]); if (s === 0) s = norm; if (Math.abs(H[l][l - 1]) < eps * s) break; l--; } // Check for convergence // One root found if (l === n) { H[n][n] = H[n][n] + exshift; d[n] = H[n][n]; e[n] = 0; n--; iter = 0; // Two roots found } else if (l === n - 1) { w = H[n][n - 1] * H[n - 1][n]; p = (H[n - 1][n - 1] - H[n][n]) / 2; q = p * p + w; z = Math.sqrt(Math.abs(q)); H[n][n] = H[n][n] + exshift; H[n - 1][n - 1] = H[n - 1][n - 1] + exshift; x = H[n][n]; // Real pair if (q >= 0) { z = p + (p >= 0 ? z : -z); d[n - 1] = x + z; d[n] = d[n - 1]; if (z !== 0) d[n] = x - w / z; e[n - 1] = 0; e[n] = 0; x = H[n][n - 1]; s = Math.abs(x) + Math.abs(z); p = x / s; q = z / s; r = Math.sqrt(p * p+q * q); p /= r; q /= r; // Row modification for (var j = n - 1; j < nn; j++) { z = H[n - 1][j]; H[n - 1][j] = q * z + p * H[n][j]; H[n][j] = q * H[n][j] - p * z; } // Column modification for (var i = 0; i <= n; i++) { z = H[i][n - 1]; H[i][n - 1] = q * z + p * H[i][n]; H[i][n] = q * H[i][n] - p * z; } // Accumulate transformations for (var i = low; i <= high; i++) { z = V[i][n - 1]; V[i][n - 1] = q * z + p * V[i][n]; V[i][n] = q * V[i][n] - p * z; } // Complex pair } else { d[n - 1] = x + p; d[n] = x + p; e[n - 1] = z; e[n] = -z; } n = n - 2; iter = 0; // No convergence yet } else { // Form shift x = H[n][n]; y = 0; w = 0; if (l < n) { y = H[n - 1][n - 1]; w = H[n][n - 1] * H[n - 1][n]; } // Wilkinson's original ad hoc shift if (iter == 10) { exshift += x; for (var i = low; i <= n; i++) { H[i][i] -= x; } s = Math.abs(H[n][n - 1]) + Math.abs(H[n - 1][n-2]); x = y = 0.75 * s; w = -0.4375 * s * s; } // MATLAB's new ad hoc shift if (iter == 30) { s = (y - x) / 2.0; s = s * s + w; if (s > 0) { s = Math.sqrt(s); if (y < x) { s = -s; } s = x - w / ((y - x) / 2.0 + s); for (var i = low; i <= n; i++) { H[i][i] -= s; } exshift += s; x = y = w = 0.964; } } iter++; // (Could check iteration count here.) // Look for two consecutive small sub-diagonal elements var m = n-2; while (m >= l) { z = H[m][m]; r = x - z; s = y - z; p = (r * s - w) / H[m + 1][m] + H[m][m + 1]; q = H[m + 1][m + 1] - z - r - s; r = H[m+2][m + 1]; s = Math.abs(p) + Math.abs(q) + Math.abs(r); p = p / s; q = q / s; r = r / s; if (m == l) break; if (Math.abs(H[m][m - 1]) * (Math.abs(q) + Math.abs(r)) < eps * (Math.abs(p) * (Math.abs(H[m - 1][m - 1]) + Math.abs(z) + Math.abs(H[m + 1][m + 1])))) { break; } m--; } for (var i = m+2; i <= n; i++) { H[i][i-2] = 0; if (i > m+2) H[i][i-3] = 0; } // Double QR step involving rows l:n and columns m:n for (var k = m; k <= n - 1; k++) { var notlast = (k != n - 1); if (k != m) { p = H[k][k - 1]; q = H[k + 1][k - 1]; r = (notlast ? H[k + 2][k - 1] : 0); x = Math.abs(p) + Math.abs(q) + Math.abs(r); if (x != 0) { p /= x; q /= x; r /= x; } } if (x == 0) break; s = Math.sqrt(p * p + q * q + r * r); if (p < 0) { s = -s; } if (s != 0) { if (k != m) H[k][k - 1] = -s * x; else if (l != m) H[k][k - 1] = -H[k][k - 1]; p += s; x = p / s; y = q / s; z = r / s; q /= p; r /= p; // Row modification for (var j = k; j < nn; j++) { p = H[k][j] + q * H[k + 1][j]; if (notlast) { p = p + r * H[k + 2][j]; H[k + 2][j] = H[k + 2][j] - p * z; } H[k][j] = H[k][j] - p * x; H[k + 1][j] = H[k + 1][j] - p * y; } // Column modification for (var i = 0; i <= Math.min(n, k + 3); i++) { p = x * H[i][k] + y * H[i][k + 1]; if (notlast) { p += z * H[i][k + 2]; H[i][k + 2] = H[i][k + 2] - p * r; } H[i][k] = H[i][k] - p; H[i][k + 1] = H[i][k + 1] - p * q; } // Accumulate transformations for (var i = low; i <= high; i++) { p = x * V[i][k] + y * V[i][k + 1]; if (notlast) { p = p + z * V[i][k + 2]; V[i][k + 2] = V[i][k + 2] - p * r; } V[i][k] = V[i][k] - p; V[i][k + 1] = V[i][k + 1] - p * q; } } // (s != 0) } // k loop } // check convergence } // while (n >= low) // Backsubstitute to find vectors of upper triangular form if (norm == 0) { return; } for (n = nn - 1; n >= 0; n--) { p = d[n]; q = e[n]; // Real vector if (q == 0) { var l = n; H[n][n] = 1.0; for (var i = n - 1; i >= 0; i--) { w = H[i][i] - p; r = 0; for (var j = l; j <= n; j++) { r = r + H[i][j] * H[j][n]; } if (e[i] < 0) { z = w; s = r; } else { l = i; if (e[i] === 0) { H[i][n] = -r / (w !== 0 ? w : eps * norm); } else { // Solve real equations x = H[i][i + 1]; y = H[i + 1][i]; q = (d[i] - p) * (d[i] - p) + e[i] * e[i]; t = (x * s - z * r) / q; H[i][n] = t; if (Math.abs(x) > Math.abs(z)) { H[i + 1][n] = (-r - w * t) / x; } else { H[i + 1][n] = (-s - y * t) / z; } } // Overflow control t = Math.abs(H[i][n]); if ((eps * t) * t > 1) { for (var j = i; j <= n; j++) H[j][n] = H[j][n] / t; } } } // Complex vector } else if (q < 0) { var l = n - 1; // Last vector component imaginary so matrix is triangular if (Math.abs(H[n][n - 1]) > Math.abs(H[n - 1][n])) { H[n - 1][n - 1] = q / H[n][n - 1]; H[n - 1][n] = -(H[n][n] - p) / H[n][n - 1]; } else { var zz = science_lin_decomposeCdiv(0, -H[n - 1][n], H[n - 1][n - 1] - p, q); H[n - 1][n - 1] = zz[0]; H[n - 1][n] = zz[1]; } H[n][n - 1] = 0; H[n][n] = 1; for (var i = n-2; i >= 0; i--) { var ra = 0, sa = 0, vr, vi; for (var j = l; j <= n; j++) { ra = ra + H[i][j] * H[j][n - 1]; sa = sa + H[i][j] * H[j][n]; } w = H[i][i] - p; if (e[i] < 0) { z = w; r = ra; s = sa; } else { l = i; if (e[i] == 0) { var zz = science_lin_decomposeCdiv(-ra,-sa,w,q); H[i][n - 1] = zz[0]; H[i][n] = zz[1]; } else { // Solve complex equations x = H[i][i + 1]; y = H[i + 1][i]; vr = (d[i] - p) * (d[i] - p) + e[i] * e[i] - q * q; vi = (d[i] - p) * 2.0 * q; if (vr == 0 & vi == 0) { vr = eps * norm * (Math.abs(w) + Math.abs(q) + Math.abs(x) + Math.abs(y) + Math.abs(z)); } var zz = science_lin_decomposeCdiv(x*r-z*ra+q*sa,x*s-z*sa-q*ra,vr,vi); H[i][n - 1] = zz[0]; H[i][n] = zz[1]; if (Math.abs(x) > (Math.abs(z) + Math.abs(q))) { H[i + 1][n - 1] = (-ra - w * H[i][n - 1] + q * H[i][n]) / x; H[i + 1][n] = (-sa - w * H[i][n] - q * H[i][n - 1]) / x; } else { var zz = science_lin_decomposeCdiv(-r-y*H[i][n - 1],-s-y*H[i][n],z,q); H[i + 1][n - 1] = zz[0]; H[i + 1][n] = zz[1]; } } // Overflow control t = Math.max(Math.abs(H[i][n - 1]),Math.abs(H[i][n])); if ((eps * t) * t > 1) { for (var j = i; j <= n; j++) { H[j][n - 1] = H[j][n - 1] / t; H[j][n] = H[j][n] / t; } } } } } } // Vectors of isolated roots for (var i = 0; i < nn; i++) { if (i < low || i > high) { for (var j = i; j < nn; j++) V[i][j] = H[i][j]; } } // Back transformation to get eigenvectors of original matrix for (var j = nn - 1; j >= low; j--) { for (var i = low; i <= high; i++) { z = 0; for (var k = low; k <= Math.min(j, high); k++) z += V[i][k] * H[k][j]; V[i][j] = z; } } } // Complex scalar division. function science_lin_decomposeCdiv(xr, xi, yr, yi) { if (Math.abs(yr) > Math.abs(yi)) { var r = yi / yr, d = yr + r * yi; return [(xr + r * xi) / d, (xi - r * xr) / d]; } else { var r = yr / yi, d = yi + r * yr; return [(r * xr + xi) / d, (r * xi - xr) / d]; } } science.lin.cross = function(a, b) { // TODO how to handle non-3D vectors? // TODO handle 7D vectors? return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ]; }; science.lin.dot = function(a, b) { var s = 0, i = -1, n = Math.min(a.length, b.length); while (++i < n) s += a[i] * b[i]; return s; }; science.lin.length = function(p) { return Math.sqrt(science.lin.dot(p, p)); }; science.lin.normalize = function(p) { var length = science.lin.length(p); return p.map(function(d) { return d / length; }); }; // 4x4 matrix determinant. science.lin.determinant = function(matrix) { var m = matrix[0].concat(matrix[1]).concat(matrix[2]).concat(matrix[3]); return ( m[12] * m[9] * m[6] * m[3] - m[8] * m[13] * m[6] * m[3] - m[12] * m[5] * m[10] * m[3] + m[4] * m[13] * m[10] * m[3] + m[8] * m[5] * m[14] * m[3] - m[4] * m[9] * m[14] * m[3] - m[12] * m[9] * m[2] * m[7] + m[8] * m[13] * m[2] * m[7] + m[12] * m[1] * m[10] * m[7] - m[0] * m[13] * m[10] * m[7] - m[8] * m[1] * m[14] * m[7] + m[0] * m[9] * m[14] * m[7] + m[12] * m[5] * m[2] * m[11] - m[4] * m[13] * m[2] * m[11] - m[12] * m[1] * m[6] * m[11] + m[0] * m[13] * m[6] * m[11] + m[4] * m[1] * m[14] * m[11] - m[0] * m[5] * m[14] * m[11] - m[8] * m[5] * m[2] * m[15] + m[4] * m[9] * m[2] * m[15] + m[8] * m[1] * m[6] * m[15] - m[0] * m[9] * m[6] * m[15] - m[4] * m[1] * m[10] * m[15] + m[0] * m[5] * m[10] * m[15]); }; // Performs in-place Gauss-Jordan elimination. // // Based on Jarno Elonen's Python version (public domain): // http://elonen.iki.fi/code/misc-notes/python-gaussj/index.html science.lin.gaussjordan = function(m, eps) { if (!eps) eps = 1e-10; var h = m.length, w = m[0].length, y = -1, y2, x; while (++y < h) { var maxrow = y; // Find max pivot. y2 = y; while (++y2 < h) { if (Math.abs(m[y2][y]) > Math.abs(m[maxrow][y])) maxrow = y2; } // Swap. var tmp = m[y]; m[y] = m[maxrow]; m[maxrow] = tmp; // Singular? if (Math.abs(m[y][y]) <= eps) return false; // Eliminate column y. y2 = y; while (++y2 < h) { var c = m[y2][y] / m[y][y]; x = y - 1; while (++x < w) { m[y2][x] -= m[y][x] * c; } } } // Backsubstitute. y = h; while (--y >= 0) { var c = m[y][y]; y2 = -1; while (++y2 < y) { x = w; while (--x >= y) { m[y2][x] -= m[y][x] * m[y2][y] / c; } } m[y][y] /= c; // Normalize row y. x = h - 1; while (++x < w) { m[y][x] /= c; } } return true; }; // Find matrix inverse using Gauss-Jordan. science.lin.inverse = function(m) { var n = m.length, i = -1; // Check if the matrix is square. if (n !== m[0].length) return; // Augment with identity matrix I to get AI. m = m.map(function(row, i) { var identity = new Array(n), j = -1; while (++j < n) identity[j] = i === j ? 1 : 0; return row.concat(identity); }); // Compute IA^-1. science.lin.gaussjordan(m); // Remove identity matrix I to get A^-1. while (++i < n) { m[i] = m[i].slice(n); } return m; }; science.lin.multiply = function(a, b) { var m = a.length, n = b[0].length, p = b.length, i = -1, j, k; if (p !== a[0].length) throw {"error": "columns(a) != rows(b); " + a[0].length + " != " + p}; var ab = new Array(m); while (++i < m) { ab[i] = new Array(n); j = -1; while(++j < n) { var s = 0; k = -1; while (++k < p) s += a[i][k] * b[k][j]; ab[i][j] = s; } } return ab; }; science.lin.transpose = function(a) { var m = a.length, n = a[0].length, i = -1, j, b = new Array(n); while (++i < n) { b[i] = new Array(m); j = -1; while (++j < m) b[i][j] = a[j][i]; } return b; }; /** * Solves tridiagonal systems of linear equations. * * Source: http://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm * * @param {number[]} a * @param {number[]} b * @param {number[]} c * @param {number[]} d * @param {number[]} x * @param {number} n */ science.lin.tridag = function(a, b, c, d, x, n) { var i, m; for (i = 1; i < n; i++) { m = a[i] / b[i - 1]; b[i] -= m * c[i - 1]; d[i] -= m * d[i - 1]; } x[n - 1] = d[n - 1] / b[n - 1]; for (i = n - 2; i >= 0; i--) { x[i] = (d[i] - c[i] * x[i + 1]) / b[i]; } }; })(this); (function(exports){ science.stats = {}; // Bandwidth selectors for Gaussian kernels. // Based on R's implementations in `stats.bw`. science.stats.bandwidth = { // Silverman, B. W. (1986) Density Estimation. London: Chapman and Hall. nrd0: function(x) { var hi = Math.sqrt(science.stats.variance(x)); if (!(lo = Math.min(hi, science.stats.iqr(x) / 1.34))) (lo = hi) || (lo = Math.abs(x[1])) || (lo = 1); return .9 * lo * Math.pow(x.length, -.2); }, // Scott, D. W. (1992) Multivariate Density Estimation: Theory, Practice, and // Visualization. Wiley. nrd: function(x) { var h = science.stats.iqr(x) / 1.34; return 1.06 * Math.min(Math.sqrt(science.stats.variance(x)), h) * Math.pow(x.length, -1/5); } }; science.stats.distance = { euclidean: function(a, b) { var n = a.length, i = -1, s = 0, x; while (++i < n) { x = a[i] - b[i]; s += x * x; } return Math.sqrt(s); }, manhattan: function(a, b) { var n = a.length, i = -1, s = 0; while (++i < n) s += Math.abs(a[i] - b[i]); return s; }, minkowski: function(p) { return function(a, b) { var n = a.length, i = -1, s = 0; while (++i < n) s += Math.pow(Math.abs(a[i] - b[i]), p); return Math.pow(s, 1 / p); }; }, chebyshev: function(a, b) { var n = a.length, i = -1, max = 0, x; while (++i < n) { x = Math.abs(a[i] - b[i]); if (x > max) max = x; } return max; }, hamming: function(a, b) { var n = a.length, i = -1, d = 0; while (++i < n) if (a[i] !== b[i]) d++; return d; }, jaccard: function(a, b) { var n = a.length, i = -1, s = 0; while (++i < n) if (a[i] === b[i]) s++; return s / n; }, braycurtis: function(a, b) { var n = a.length, i = -1, s0 = 0, s1 = 0, ai, bi; while (++i < n) { ai = a[i]; bi = b[i]; s0 += Math.abs(ai - bi); s1 += Math.abs(ai + bi); } return s0 / s1; } }; // Based on implementation in http://picomath.org/. science.stats.erf = function(x) { var a1 = 0.254829592, a2 = -0.284496736, a3 = 1.421413741, a4 = -1.453152027, a5 = 1.061405429, p = 0.3275911; // Save the sign of x var sign = x < 0 ? -1 : 1; if (x < 0) { sign = -1; x = -x; } // A&S formula 7.1.26 var t = 1 / (1 + p * x); return sign * ( 1 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * Math.exp(-x * x)); }; science.stats.phi = function(x) { return .5 * (1 + science.stats.erf(x / Math.SQRT2)); }; // See . science.stats.kernel = { uniform: function(u) { if (u <= 1 && u >= -1) return .5; return 0; }, triangular: function(u) { if (u <= 1 && u >= -1) return 1 - Math.abs(u); return 0; }, epanechnikov: function(u) { if (u <= 1 && u >= -1) return .75 * (1 - u * u); return 0; }, quartic: function(u) { if (u <= 1 && u >= -1) { var tmp = 1 - u * u; return (15 / 16) * tmp * tmp; } return 0; }, triweight: function(u) { if (u <= 1 && u >= -1) { var tmp = 1 - u * u; return (35 / 32) * tmp * tmp * tmp; } return 0; }, gaussian: function(u) { return 1 / Math.sqrt(2 * Math.PI) * Math.exp(-.5 * u * u); }, cosine: function(u) { if (u <= 1 && u >= -1) return Math.PI / 4 * Math.cos(Math.PI / 2 * u); return 0; } }; // http://exploringdata.net/den_trac.htm science.stats.kde = function() { var kernel = science.stats.kernel.gaussian, sample = [], bandwidth = science.stats.bandwidth.nrd; function kde(points, i) { var bw = bandwidth.call(this, sample); return points.map(function(x) { var i = -1, y = 0, n = sample.length; while (++i < n) { y += kernel((x - sample[i]) / bw); } return [x, y / bw / n]; }); } kde.kernel = function(x) { if (!arguments.length) return kernel; kernel = x; return kde; }; kde.sample = function(x) { if (!arguments.length) return sample; sample = x; return kde; }; kde.bandwidth = function(x) { if (!arguments.length) return bandwidth; bandwidth = science.functor(x); return kde; }; return kde; }; // Based on figue implementation by Jean-Yves Delort. // http://code.google.com/p/figue/ science.stats.kmeans = function() { var distance = science.stats.distance.euclidean, maxIterations = 1000, k = 1; function kmeans(vectors) { var n = vectors.length, assignments = [], clusterSizes = [], repeat = 1, iterations = 0, centroids = science_stats_kmeansRandom(k, vectors), newCentroids, i, j, x, d, min, best; while (repeat && iterations < maxIterations) { // Assignment step. j = -1; while (++j < k) { clusterSizes[j] = 0; } i = -1; while (++i < n) { x = vectors[i]; min = Infinity; j = -1; while (++j < k) { d = distance.call(this, centroids[j], x); if (d < min) { min = d; best = j; } } clusterSizes[assignments[i] = best]++; } // Update centroids step. newCentroids = []; i = -1; while (++i < n) { x = assignments[i]; d = newCentroids[x]; if (d == null) newCentroids[x] = vectors[i].slice(); else { j = -1; while (++j < d.length) { d[j] += vectors[i][j]; } } } j = -1; while (++j < k) { x = newCentroids[j]; d = 1 / clusterSizes[j]; i = -1; while (++i < x.length) x[i] *= d; } // Check convergence. repeat = 0; j = -1; while (++j < k) { if (!science_stats_kmeansCompare(newCentroids[j], centroids[j])) { repeat = 1; break; } } centroids = newCentroids; iterations++; } return {assignments: assignments, centroids: centroids}; } kmeans.k = function(x) { if (!arguments.length) return k; k = x; return kmeans; }; kmeans.distance = function(x) { if (!arguments.length) return distance; distance = x; return kmeans; }; return kmeans; }; function science_stats_kmeansCompare(a, b) { if (!a || !b || a.length !== b.length) return false; var n = a.length, i = -1; while (++i < n) if (a[i] !== b[i]) return false; return true; } // Returns an array of k distinct vectors randomly selected from the input // array of vectors. Returns null if k > n or if there are less than k distinct // objects in vectors. function science_stats_kmeansRandom(k, vectors) { var n = vectors.length; if (k > n) return null; var selected_vectors = []; var selected_indices = []; var tested_indices = {}; var tested = 0; var selected = 0; var i, vector, select; while (selected < k) { if (tested === n) return null; var random_index = Math.floor(Math.random() * n); if (random_index in tested_indices) continue; tested_indices[random_index] = 1; tested++; vector = vectors[random_index]; select = true; for (i = 0; i < selected; i++) { if (science_stats_kmeansCompare(vector, selected_vectors[i])) { select = false; break; } } if (select) { selected_vectors[selected] = vector; selected_indices[selected] = random_index; selected++; } } return selected_vectors; } science.stats.hcluster = function() { var distance = science.stats.distance.euclidean, linkage = "single"; // single, complete or average function hcluster(vectors) { var n = vectors.length, dMin = [], cSize = [], distMatrix = [], clusters = [], c1, c2, c1Cluster, c2Cluster, p, root, i, j; // Initialise distance matrix and vector of closest clusters. i = -1; while (++i < n) { dMin[i] = 0; distMatrix[i] = []; j = -1; while (++j < n) { distMatrix[i][j] = i === j ? Infinity : distance(vectors[i] , vectors[j]); if (distMatrix[i][dMin[i]] > distMatrix[i][j]) dMin[i] = j; } } // create leaves of the tree i = -1; while (++i < n) { clusters[i] = []; clusters[i][0] = { left: null, right: null, dist: 0, centroid: vectors[i], size: 1, depth: 0 }; cSize[i] = 1; } // Main loop for (p = 0; p < n-1; p++) { // find the closest pair of clusters c1 = 0; for (i = 0; i < n; i++) { if (distMatrix[i][dMin[i]] < distMatrix[c1][dMin[c1]]) c1 = i; } c2 = dMin[c1]; // create node to store cluster info c1Cluster = clusters[c1][0]; c2Cluster = clusters[c2][0]; var newCluster = { left: c1Cluster, right: c2Cluster, dist: distMatrix[c1][c2], centroid: calculateCentroid(c1Cluster.size, c1Cluster.centroid, c2Cluster.size, c2Cluster.centroid), size: c1Cluster.size + c2Cluster.size, depth: 1 + Math.max(c1Cluster.depth, c2Cluster.depth) }; clusters[c1].splice(0, 0, newCluster); cSize[c1] += cSize[c2]; // overwrite row c1 with respect to the linkage type for (j = 0; j < n; j++) { switch (linkage) { case "single": if (distMatrix[c1][j] > distMatrix[c2][j]) distMatrix[j][c1] = distMatrix[c1][j] = distMatrix[c2][j]; break; case "complete": if (distMatrix[c1][j] < distMatrix[c2][j]) distMatrix[j][c1] = distMatrix[c1][j] = distMatrix[c2][j]; break; case "average": distMatrix[j][c1] = distMatrix[c1][j] = (cSize[c1] * distMatrix[c1][j] + cSize[c2] * distMatrix[c2][j]) / (cSize[c1] + cSize[j]); break; } } distMatrix[c1][c1] = Infinity; // infinity ­out old row c2 and column c2 for (i = 0; i < n; i++) distMatrix[i][c2] = distMatrix[c2][i] = Infinity; // update dmin and replace ones that previous pointed to c2 to point to c1 for (j = 0; j < n; j++) { if (dMin[j] == c2) dMin[j] = c1; if (distMatrix[c1][j] < distMatrix[c1][dMin[c1]]) dMin[c1] = j; } // keep track of the last added cluster root = newCluster; } return root; } hcluster.distance = function(x) { if (!arguments.length) return distance; distance = x; return hcluster; }; return hcluster; }; function calculateCentroid(c1Size, c1Centroid, c2Size, c2Centroid) { var newCentroid = [], newSize = c1Size + c2Size, n = c1Centroid.length, i = -1; while (++i < n) { newCentroid[i] = (c1Size * c1Centroid[i] + c2Size * c2Centroid[i]) / newSize; } return newCentroid; } science.stats.iqr = function(x) { var quartiles = science.stats.quantiles(x, [.25, .75]); return quartiles[1] - quartiles[0]; }; // Based on org.apache.commons.math.analysis.interpolation.LoessInterpolator // from http://commons.apache.org/math/ science.stats.loess = function() { var bandwidth = .3, robustnessIters = 2, accuracy = 1e-12; function smooth(xval, yval, weights) { var n = xval.length, i; if (n !== yval.length) throw {error: "Mismatched array lengths"}; if (n == 0) throw {error: "At least one point required."}; if (arguments.length < 3) { weights = []; i = -1; while (++i < n) weights[i] = 1; } science_stats_loessFiniteReal(xval); science_stats_loessFiniteReal(yval); science_stats_loessFiniteReal(weights); science_stats_loessStrictlyIncreasing(xval); if (n == 1) return [yval[0]]; if (n == 2) return [yval[0], yval[1]]; var bandwidthInPoints = Math.floor(bandwidth * n); if (bandwidthInPoints < 2) throw {error: "Bandwidth too small."}; var res = [], residuals = [], robustnessWeights = []; // Do an initial fit and 'robustnessIters' robustness iterations. // This is equivalent to doing 'robustnessIters+1' robustness iterations // starting with all robustness weights set to 1. i = -1; while (++i < n) { res[i] = 0; residuals[i] = 0; robustnessWeights[i] = 1; } var iter = -1; while (++iter <= robustnessIters) { var bandwidthInterval = [0, bandwidthInPoints - 1]; // At each x, compute a local weighted linear regression var x; i = -1; while (++i < n) { x = xval[i]; // Find out the interval of source points on which // a regression is to be made. if (i > 0) { science_stats_loessUpdateBandwidthInterval(xval, weights, i, bandwidthInterval); } var ileft = bandwidthInterval[0], iright = bandwidthInterval[1]; // Compute the point of the bandwidth interval that is // farthest from x var edge = (xval[i] - xval[ileft]) > (xval[iright] - xval[i]) ? ileft : iright; // Compute a least-squares linear fit weighted by // the product of robustness weights and the tricube // weight function. // See http://en.wikipedia.org/wiki/Linear_regression // (section "Univariate linear case") // and http://en.wikipedia.org/wiki/Weighted_least_squares // (section "Weighted least squares") var sumWeights = 0, sumX = 0, sumXSquared = 0, sumY = 0, sumXY = 0, denom = Math.abs(1 / (xval[edge] - x)); for (var k = ileft; k <= iright; ++k) { var xk = xval[k], yk = yval[k], dist = k < i ? x - xk : xk - x, w = science_stats_loessTricube(dist * denom) * robustnessWeights[k] * weights[k], xkw = xk * w; sumWeights += w; sumX += xkw; sumXSquared += xk * xkw; sumY += yk * w; sumXY += yk * xkw; } var meanX = sumX / sumWeights, meanY = sumY / sumWeights, meanXY = sumXY / sumWeights, meanXSquared = sumXSquared / sumWeights; var beta = (Math.sqrt(Math.abs(meanXSquared - meanX * meanX)) < accuracy) ? 0 : ((meanXY - meanX * meanY) / (meanXSquared - meanX * meanX)); var alpha = meanY - beta * meanX; res[i] = beta * x + alpha; residuals[i] = Math.abs(yval[i] - res[i]); } // No need to recompute the robustness weights at the last // iteration, they won't be needed anymore if (iter === robustnessIters) { break; } // Recompute the robustness weights. // Find the median residual. var medianResidual = science.stats.median(residuals); if (Math.abs(medianResidual) < accuracy) break; var arg, w; i = -1; while (++i < n) { arg = residuals[i] / (6 * medianResidual); robustnessWeights[i] = (arg >= 1) ? 0 : ((w = 1 - arg * arg) * w); } } return res; } smooth.bandwidth = function(x) { if (!arguments.length) return x; bandwidth = x; return smooth; }; smooth.robustnessIterations = function(x) { if (!arguments.length) return x; robustnessIters = x; return smooth; }; smooth.accuracy = function(x) { if (!arguments.length) return x; accuracy = x; return smooth; }; return smooth; }; function science_stats_loessFiniteReal(values) { var n = values.length, i = -1; while (++i < n) if (!isFinite(values[i])) return false; return true; } function science_stats_loessStrictlyIncreasing(xval) { var n = xval.length, i = 0; while (++i < n) if (xval[i - 1] >= xval[i]) return false; return true; } // Compute the tricube weight function. // http://en.wikipedia.org/wiki/Local_regression#Weight_function function science_stats_loessTricube(x) { return (x = 1 - x * x * x) * x * x; } // Given an index interval into xval that embraces a certain number of // points closest to xval[i-1], update the interval so that it embraces // the same number of points closest to xval[i], ignoring zero weights. function science_stats_loessUpdateBandwidthInterval( xval, weights, i, bandwidthInterval) { var left = bandwidthInterval[0], right = bandwidthInterval[1]; // The right edge should be adjusted if the next point to the right // is closer to xval[i] than the leftmost point of the current interval var nextRight = science_stats_loessNextNonzero(weights, right); if ((nextRight < xval.length) && (xval[nextRight] - xval[i]) < (xval[i] - xval[left])) { var nextLeft = science_stats_loessNextNonzero(weights, left); bandwidthInterval[0] = nextLeft; bandwidthInterval[1] = nextRight; } } function science_stats_loessNextNonzero(weights, i) { var j = i + 1; while (j < weights.length && weights[j] === 0) j++; return j; } // Welford's algorithm. science.stats.mean = function(x) { var n = x.length; if (n === 0) return NaN; var m = 0, i = -1; while (++i < n) m += (x[i] - m) / (i + 1); return m; }; science.stats.median = function(x) { return science.stats.quantiles(x, [.5])[0]; }; science.stats.mode = function(x) { var counts = {}, mode = [], max = 0, n = x.length, i = -1, d, k; while (++i < n) { k = counts.hasOwnProperty(d = x[i]) ? ++counts[d] : counts[d] = 1; if (k === max) mode.push(d); else if (k > max) { max = k; mode = [d]; } } if (mode.length === 1) return mode[0]; }; // Uses R's quantile algorithm type=7. science.stats.quantiles = function(d, quantiles) { d = d.slice().sort(science.ascending); var n_1 = d.length - 1; return quantiles.map(function(q) { if (q === 0) return d[0]; else if (q === 1) return d[n_1]; var index = 1 + q * n_1, lo = Math.floor(index), h = index - lo, a = d[lo - 1]; return h === 0 ? a : a + h * (d[lo] - a); }); }; // Unbiased estimate of a sample's variance. // Also known as the sample variance, where the denominator is n - 1. science.stats.variance = function(x) { var n = x.length; if (n < 1) return NaN; if (n === 1) return 0; var mean = science.stats.mean(x), i = -1, s = 0; while (++i < n) { var v = x[i] - mean; s += v * v; } return s / (n - 1); }; science.stats.distribution = { }; // From http://www.colingodsey.com/javascript-gaussian-random-number-generator/ // Uses the Box-Muller Transform. science.stats.distribution.gaussian = function() { var random = Math.random, mean = 0, sigma = 1, variance = 1; function gaussian() { var x1, x2, rad, y1; do { x1 = 2 * random() - 1; x2 = 2 * random() - 1; rad = x1 * x1 + x2 * x2; } while (rad >= 1 || rad === 0); return mean + sigma * x1 * Math.sqrt(-2 * Math.log(rad) / rad); } gaussian.pdf = function(x) { x = (x - mean) / sigma; return science_stats_distribution_gaussianConstant * Math.exp(-.5 * x * x) / sigma; }; gaussian.cdf = function(x) { x = (x - mean) / sigma; return .5 * (1 + science.stats.erf(x / Math.SQRT2)); }; gaussian.mean = function(x) { if (!arguments.length) return mean; mean = +x; return gaussian; }; gaussian.variance = function(x) { if (!arguments.length) return variance; sigma = Math.sqrt(variance = +x); return gaussian; }; gaussian.random = function(x) { if (!arguments.length) return random; random = x; return gaussian; }; return gaussian; }; science_stats_distribution_gaussianConstant = 1 / Math.sqrt(2 * Math.PI); })(this); })(this); science.js-1.9.3/science.v1.min.js000066400000000000000000000551401256532472600166470ustar00rootroot00000000000000(function(exports){(function(exports){science={version:"1.9.3"};science.ascending=function(a,b){return a-b};science.EULER=.5772156649015329;science.expm1=function(x){return x<1e-5&&x>-1e-5?x+.5*x*x:Math.exp(x)-1};science.functor=function(v){return typeof v==="function"?v:function(){return v}};science.hypot=function(x,y){x=Math.abs(x);y=Math.abs(y);var max,min;if(x>y){max=x;min=y}else{max=y;min=x}var r=min/max;return max*Math.sqrt(1+r*r)};science.quadratic=function(){var complex=false;function quadratic(a,b,c){var d=b*b-4*a*c;if(d>0){d=Math.sqrt(d)/(2*a);return complex?[{r:-b-d,i:0},{r:-b+d,i:0}]:[-b-d,-b+d]}else if(d===0){d=-b/(2*a);return complex?[{r:d,i:0}]:[d]}else{if(complex){d=Math.sqrt(-d)/(2*a);return[{r:-b,i:-d},{r:-b,i:d}]}return[]}}quadratic.complex=function(x){if(!arguments.length)return complex;complex=x;return quadratic};return quadratic};science.zeroes=function(n){var i=-1,a=[];if(arguments.length===1)while(++i0?i+1:i-1]=e[i]}return{D:D,V:V}}return decompose};function science_lin_decomposeTred2(d,e,V){var n=V.length;for(var j=0;j0;i--){var scale=0,h=0;for(var k=0;k0)g=-g;e[i]=scale*g;h=h-f*g;d[i-1]=f-g;for(var j=0;jl){var iter=0;do{iter++;var g=d[l];var p=(d[l+1]-g)/(2*e[l]);var r=science.hypot(p,1);if(p<0)r=-r;d[l]=e[l]/(p+r);d[l+1]=e[l]*(p+r);var dl1=d[l+1];var h=g-d[l];for(var i=l+2;i=l;i--){c3=c2;c2=c;s2=s;g=c*e[i];h=c*p;r=science.hypot(p,e[i]);e[i+1]=s*r;s=e[i]/r;c=p/r;p=c*d[i]-s*g;d[i+1]=h+s*(c*g+s*d[i]);for(var k=0;keps*tst1)}d[l]=d[l]+f;e[l]=0}for(var i=0;i=m;i--){ort[i]=H[i][m-1]/scale;h+=ort[i]*ort[i]}var g=Math.sqrt(h);if(ort[m]>0)g=-g;h=h-ort[m]*g;ort[m]=ort[m]-g;for(var j=m;j=m;i--)f+=ort[i]*H[i][j];f/=h;for(var i=m;i<=high;i++)H[i][j]-=f*ort[i]}for(var i=0;i<=high;i++){var f=0;for(var j=high;j>=m;j--)f+=ort[j]*H[i][j];f/=h;for(var j=m;j<=high;j++)H[i][j]-=f*ort[j]}ort[m]=scale*ort[m];H[m][m-1]=scale*g}}for(var i=0;i=low+1;m--){if(H[m][m-1]!==0){for(var i=m+1;i<=high;i++)ort[i]=H[i][m-1];for(var j=m;j<=high;j++){var g=0;for(var i=m;i<=high;i++)g+=ort[i]*V[i][j];g=g/ort[m]/H[m][m-1];for(var i=m;i<=high;i++)V[i][j]+=g*ort[i]}}}}function science_lin_decomposeHqr2(d,e,H,V){var nn=H.length,n=nn-1,low=0,high=nn-1,eps=1e-12,exshift=0,p=0,q=0,r=0,s=0,z=0,t,w,x,y;var norm=0;for(var i=0;ihigh){d[i]=H[i][i];e[i]=0}for(var j=Math.max(i-1,0);j=low){var l=n;while(l>low){s=Math.abs(H[l-1][l-1])+Math.abs(H[l][l]);if(s===0)s=norm;if(Math.abs(H[l][l-1])=0){z=p+(p>=0?z:-z);d[n-1]=x+z;d[n]=d[n-1];if(z!==0)d[n]=x-w/z;e[n-1]=0;e[n]=0;x=H[n][n-1];s=Math.abs(x)+Math.abs(z);p=x/s;q=z/s;r=Math.sqrt(p*p+q*q);p/=r;q/=r;for(var j=n-1;j0){s=Math.sqrt(s);if(y=l){z=H[m][m];r=x-z;s=y-z;p=(r*s-w)/H[m+1][m]+H[m][m+1];q=H[m+1][m+1]-z-r-s;r=H[m+2][m+1];s=Math.abs(p)+Math.abs(q)+Math.abs(r);p=p/s;q=q/s;r=r/s;if(m==l)break;if(Math.abs(H[m][m-1])*(Math.abs(q)+Math.abs(r))m+2)H[i][i-3]=0}for(var k=m;k<=n-1;k++){var notlast=k!=n-1;if(k!=m){p=H[k][k-1];q=H[k+1][k-1];r=notlast?H[k+2][k-1]:0;x=Math.abs(p)+Math.abs(q)+Math.abs(r);if(x!=0){p/=x;q/=x;r/=x}}if(x==0)break;s=Math.sqrt(p*p+q*q+r*r);if(p<0){s=-s}if(s!=0){if(k!=m)H[k][k-1]=-s*x;else if(l!=m)H[k][k-1]=-H[k][k-1];p+=s;x=p/s;y=q/s;z=r/s;q/=p;r/=p;for(var j=k;j=0;n--){p=d[n];q=e[n];if(q==0){var l=n;H[n][n]=1;for(var i=n-1;i>=0;i--){w=H[i][i]-p;r=0;for(var j=l;j<=n;j++){r=r+H[i][j]*H[j][n]}if(e[i]<0){z=w;s=r}else{l=i;if(e[i]===0){H[i][n]=-r/(w!==0?w:eps*norm)}else{x=H[i][i+1];y=H[i+1][i];q=(d[i]-p)*(d[i]-p)+e[i]*e[i];t=(x*s-z*r)/q;H[i][n]=t;if(Math.abs(x)>Math.abs(z)){H[i+1][n]=(-r-w*t)/x}else{H[i+1][n]=(-s-y*t)/z}}t=Math.abs(H[i][n]);if(eps*t*t>1){for(var j=i;j<=n;j++)H[j][n]=H[j][n]/t}}}}else if(q<0){var l=n-1;if(Math.abs(H[n][n-1])>Math.abs(H[n-1][n])){H[n-1][n-1]=q/H[n][n-1];H[n-1][n]=-(H[n][n]-p)/H[n][n-1]}else{var zz=science_lin_decomposeCdiv(0,-H[n-1][n],H[n-1][n-1]-p,q);H[n-1][n-1]=zz[0];H[n-1][n]=zz[1]}H[n][n-1]=0;H[n][n]=1;for(var i=n-2;i>=0;i--){var ra=0,sa=0,vr,vi;for(var j=l;j<=n;j++){ra=ra+H[i][j]*H[j][n-1];sa=sa+H[i][j]*H[j][n]}w=H[i][i]-p;if(e[i]<0){z=w;r=ra;s=sa}else{l=i;if(e[i]==0){var zz=science_lin_decomposeCdiv(-ra,-sa,w,q);H[i][n-1]=zz[0];H[i][n]=zz[1]}else{x=H[i][i+1];y=H[i+1][i];vr=(d[i]-p)*(d[i]-p)+e[i]*e[i]-q*q;vi=(d[i]-p)*2*q;if(vr==0&vi==0){vr=eps*norm*(Math.abs(w)+Math.abs(q)+Math.abs(x)+Math.abs(y)+Math.abs(z))}var zz=science_lin_decomposeCdiv(x*r-z*ra+q*sa,x*s-z*sa-q*ra,vr,vi);H[i][n-1]=zz[0];H[i][n]=zz[1];if(Math.abs(x)>Math.abs(z)+Math.abs(q)){H[i+1][n-1]=(-ra-w*H[i][n-1]+q*H[i][n])/x;H[i+1][n]=(-sa-w*H[i][n]-q*H[i][n-1])/x}else{var zz=science_lin_decomposeCdiv(-r-y*H[i][n-1],-s-y*H[i][n],z,q);H[i+1][n-1]=zz[0];H[i+1][n]=zz[1]}}t=Math.max(Math.abs(H[i][n-1]),Math.abs(H[i][n]));if(eps*t*t>1){for(var j=i;j<=n;j++){H[j][n-1]=H[j][n-1]/t;H[j][n]=H[j][n]/t}}}}}}for(var i=0;ihigh){for(var j=i;j=low;j--){for(var i=low;i<=high;i++){z=0;for(var k=low;k<=Math.min(j,high);k++)z+=V[i][k]*H[k][j];V[i][j]=z}}}function science_lin_decomposeCdiv(xr,xi,yr,yi){if(Math.abs(yr)>Math.abs(yi)){var r=yi/yr,d=yr+r*yi;return[(xr+r*xi)/d,(xi-r*xr)/d]}else{var r=yr/yi,d=yi+r*yr;return[(r*xr+xi)/d,(r*xi-xr)/d]}}science.lin.cross=function(a,b){return[a[1]*b[2]-a[2]*b[1],a[2]*b[0]-a[0]*b[2],a[0]*b[1]-a[1]*b[0]]};science.lin.dot=function(a,b){var s=0,i=-1,n=Math.min(a.length,b.length);while(++iMath.abs(m[maxrow][y]))maxrow=y2}var tmp=m[y];m[y]=m[maxrow];m[maxrow]=tmp;if(Math.abs(m[y][y])<=eps)return false;y2=y;while(++y2=0){var c=m[y][y];y2=-1;while(++y2=y){m[y2][x]-=m[y][x]*m[y2][y]/c}}m[y][y]/=c;x=h-1;while(++xdistMatrix[i][j])dMin[i]=j}}i=-1;while(++idistMatrix[c2][j])distMatrix[j][c1]=distMatrix[c1][j]=distMatrix[c2][j];break;case"complete":if(distMatrix[c1][j]0){science_stats_loessUpdateBandwidthInterval(xval,weights,i,bandwidthInterval)}var ileft=bandwidthInterval[0],iright=bandwidthInterval[1];var edge=xval[i]-xval[ileft]>xval[iright]-xval[i]?ileft:iright;var sumWeights=0,sumX=0,sumXSquared=0,sumY=0,sumXY=0,denom=Math.abs(1/(xval[edge]-x));for(var k=ileft;k<=iright;++k){var xk=xval[k],yk=yval[k],dist=k=1?0:(w=1-arg*arg)*w}}return res}smooth.bandwidth=function(x){if(!arguments.length)return x;bandwidth=x;return smooth};smooth.robustnessIterations=function(x){if(!arguments.length)return x;robustnessIters=x;return smooth};smooth.accuracy=function(x){if(!arguments.length)return x;accuracy=x;return smooth};return smooth};function science_stats_loessFiniteReal(values){var n=values.length,i=-1;while(++i=xval[i])return false;return true}function science_stats_loessTricube(x){return(x=1-x*x*x)*x*x}function science_stats_loessUpdateBandwidthInterval(xval,weights,i,bandwidthInterval){var left=bandwidthInterval[0],right=bandwidthInterval[1];var nextRight=science_stats_loessNextNonzero(weights,right);if(nextRightmax){max=k;mode=[d]}}if(mode.length===1)return mode[0]};science.stats.quantiles=function(d,quantiles){d=d.slice().sort(science.ascending);var n_1=d.length-1;return quantiles.map(function(q){if(q===0)return d[0];else if(q===1)return d[n_1];var index=1+q*n_1,lo=Math.floor(index),h=index-lo,a=d[lo-1];return h===0?a:a+h*(d[lo]-a)})};science.stats.variance=function(x){var n=x.length;if(n<1)return NaN;if(n===1)return 0;var mean=science.stats.mean(x),i=-1,s=0;while(++i=1||rad===0);return mean+sigma*x1*Math.sqrt(-2*Math.log(rad)/rad)}gaussian.pdf=function(x){x=(x-mean)/sigma;return science_stats_distribution_gaussianConstant*Math.exp(-.5*x*x)/sigma};gaussian.cdf=function(x){x=(x-mean)/sigma;return.5*(1+science.stats.erf(x/Math.SQRT2))};gaussian.mean=function(x){if(!arguments.length)return mean;mean=+x;return gaussian};gaussian.variance=function(x){if(!arguments.length)return variance;sigma=Math.sqrt(variance=+x);return gaussian};gaussian.random=function(x){if(!arguments.length)return random;random=x;return gaussian};return gaussian};science_stats_distribution_gaussianConstant=1/Math.sqrt(2*Math.PI)})(this)})(this); science.js-1.9.3/src/000077500000000000000000000000001256532472600143535ustar00rootroot00000000000000science.js-1.9.3/src/core/000077500000000000000000000000001256532472600153035ustar00rootroot00000000000000science.js-1.9.3/src/core/ascending.js000066400000000000000000000000701256532472600175710ustar00rootroot00000000000000science.ascending = function(a, b) { return a - b; }; science.js-1.9.3/src/core/constants.js000066400000000000000000000000701256532472600176520ustar00rootroot00000000000000// Euler's constant. science.EULER = .5772156649015329; science.js-1.9.3/src/core/core.js000066400000000000000000000000501256532472600165640ustar00rootroot00000000000000science = {version: "1.9.3"}; // semver science.js-1.9.3/src/core/expm1.js000066400000000000000000000002241256532472600166710ustar00rootroot00000000000000// Compute exp(x) - 1 accurately for small x. science.expm1 = function(x) { return (x < 1e-5 && x > -1e-5) ? x + .5 * x * x : Math.exp(x) - 1; }; science.js-1.9.3/src/core/functor.js000066400000000000000000000001441256532472600173200ustar00rootroot00000000000000science.functor = function(v) { return typeof v === "function" ? v : function() { return v; }; }; science.js-1.9.3/src/core/hypot.js000066400000000000000000000005031256532472600170020ustar00rootroot00000000000000// Based on: // http://www.johndcook.com/blog/2010/06/02/whats-so-hard-about-finding-a-hypotenuse/ science.hypot = function(x, y) { x = Math.abs(x); y = Math.abs(y); var max, min; if (x > y) { max = x; min = y; } else { max = y; min = x; } var r = min / max; return max * Math.sqrt(1 + r * r); }; science.js-1.9.3/src/core/quadratic.js000066400000000000000000000012701256532472600176160ustar00rootroot00000000000000science.quadratic = function() { var complex = false; function quadratic(a, b, c) { var d = b * b - 4 * a * c; if (d > 0) { d = Math.sqrt(d) / (2 * a); return complex ? [{r: -b - d, i: 0}, {r: -b + d, i: 0}] : [-b - d, -b + d]; } else if (d === 0) { d = -b / (2 * a); return complex ? [{r: d, i: 0}] : [d]; } else { if (complex) { d = Math.sqrt(-d) / (2 * a); return [ {r: -b, i: -d}, {r: -b, i: d} ]; } return []; } } quadratic.complex = function(x) { if (!arguments.length) return complex; complex = x; return quadratic; }; return quadratic; }; science.js-1.9.3/src/core/zeroes.js000066400000000000000000000004771256532472600171600ustar00rootroot00000000000000// Constructs a multi-dimensional array filled with zeroes. science.zeroes = function(n) { var i = -1, a = []; if (arguments.length === 1) while (++i < n) a[i] = 0; else while (++i < n) a[i] = science.zeroes.apply( this, Array.prototype.slice.call(arguments, 1)); return a; }; science.js-1.9.3/src/lin/000077500000000000000000000000001256532472600151355ustar00rootroot00000000000000science.js-1.9.3/src/lin/cross.js000066400000000000000000000003311256532472600166210ustar00rootroot00000000000000science.lin.cross = function(a, b) { // TODO how to handle non-3D vectors? // TODO handle 7D vectors? return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0] ]; }; science.js-1.9.3/src/lin/decompose.js000066400000000000000000000443441256532472600174620ustar00rootroot00000000000000science.lin.decompose = function() { function decompose(A) { var n = A.length, // column dimension V = [], d = [], e = []; for (var i = 0; i < n; i++) { V[i] = []; d[i] = []; e[i] = []; } var symmetric = true; for (var j = 0; j < n; j++) { for (var i = 0; i < n; i++) { if (A[i][j] !== A[j][i]) { symmetric = false; break; } } } if (symmetric) { for (var i = 0; i < n; i++) V[i] = A[i].slice(); // Tridiagonalize. science_lin_decomposeTred2(d, e, V); // Diagonalize. science_lin_decomposeTql2(d, e, V); } else { var H = []; for (var i = 0; i < n; i++) H[i] = A[i].slice(); // Reduce to Hessenberg form. science_lin_decomposeOrthes(H, V); // Reduce Hessenberg to real Schur form. science_lin_decomposeHqr2(d, e, H, V); } var D = []; for (var i = 0; i < n; i++) { var row = D[i] = []; for (var j = 0; j < n; j++) row[j] = i === j ? d[i] : 0; D[i][e[i] > 0 ? i + 1 : i - 1] = e[i]; } return {D: D, V: V}; } return decompose; }; // Symmetric Householder reduction to tridiagonal form. function science_lin_decomposeTred2(d, e, V) { // This is derived from the Algol procedures tred2 by // Bowdler, Martin, Reinsch, and Wilkinson, Handbook for // Auto. Comp., Vol.ii-Linear Algebra, and the corresponding // Fortran subroutine in EISPACK. var n = V.length; for (var j = 0; j < n; j++) d[j] = V[n - 1][j]; // Householder reduction to tridiagonal form. for (var i = n - 1; i > 0; i--) { // Scale to avoid under/overflow. var scale = 0, h = 0; for (var k = 0; k < i; k++) scale += Math.abs(d[k]); if (scale === 0) { e[i] = d[i - 1]; for (var j = 0; j < i; j++) { d[j] = V[i - 1][j]; V[i][j] = 0; V[j][i] = 0; } } else { // Generate Householder vector. for (var k = 0; k < i; k++) { d[k] /= scale; h += d[k] * d[k]; } var f = d[i - 1]; var g = Math.sqrt(h); if (f > 0) g = -g; e[i] = scale * g; h = h - f * g; d[i - 1] = f - g; for (var j = 0; j < i; j++) e[j] = 0; // Apply similarity transformation to remaining columns. for (var j = 0; j < i; j++) { f = d[j]; V[j][i] = f; g = e[j] + V[j][j] * f; for (var k = j+1; k <= i - 1; k++) { g += V[k][j] * d[k]; e[k] += V[k][j] * f; } e[j] = g; } f = 0; for (var j = 0; j < i; j++) { e[j] /= h; f += e[j] * d[j]; } var hh = f / (h + h); for (var j = 0; j < i; j++) e[j] -= hh * d[j]; for (var j = 0; j < i; j++) { f = d[j]; g = e[j]; for (var k = j; k <= i - 1; k++) V[k][j] -= (f * e[k] + g * d[k]); d[j] = V[i - 1][j]; V[i][j] = 0; } } d[i] = h; } // Accumulate transformations. for (var i = 0; i < n - 1; i++) { V[n - 1][i] = V[i][i]; V[i][i] = 1.0; var h = d[i + 1]; if (h != 0) { for (var k = 0; k <= i; k++) d[k] = V[k][i + 1] / h; for (var j = 0; j <= i; j++) { var g = 0; for (var k = 0; k <= i; k++) g += V[k][i + 1] * V[k][j]; for (var k = 0; k <= i; k++) V[k][j] -= g * d[k]; } } for (var k = 0; k <= i; k++) V[k][i + 1] = 0; } for (var j = 0; j < n; j++) { d[j] = V[n - 1][j]; V[n - 1][j] = 0; } V[n - 1][n - 1] = 1; e[0] = 0; } // Symmetric tridiagonal QL algorithm. function science_lin_decomposeTql2(d, e, V) { // This is derived from the Algol procedures tql2, by // Bowdler, Martin, Reinsch, and Wilkinson, Handbook for // Auto. Comp., Vol.ii-Linear Algebra, and the corresponding // Fortran subroutine in EISPACK. var n = V.length; for (var i = 1; i < n; i++) e[i - 1] = e[i]; e[n - 1] = 0; var f = 0; var tst1 = 0; var eps = 1e-12; for (var l = 0; l < n; l++) { // Find small subdiagonal element tst1 = Math.max(tst1, Math.abs(d[l]) + Math.abs(e[l])); var m = l; while (m < n) { if (Math.abs(e[m]) <= eps*tst1) { break; } m++; } // If m == l, d[l] is an eigenvalue, // otherwise, iterate. if (m > l) { var iter = 0; do { iter++; // (Could check iteration count here.) // Compute implicit shift var g = d[l]; var p = (d[l + 1] - g) / (2 * e[l]); var r = science.hypot(p, 1); if (p < 0) r = -r; d[l] = e[l] / (p + r); d[l + 1] = e[l] * (p + r); var dl1 = d[l + 1]; var h = g - d[l]; for (var i = l+2; i < n; i++) d[i] -= h; f += h; // Implicit QL transformation. p = d[m]; var c = 1; var c2 = c; var c3 = c; var el1 = e[l + 1]; var s = 0; var s2 = 0; for (var i = m - 1; i >= l; i--) { c3 = c2; c2 = c; s2 = s; g = c * e[i]; h = c * p; r = science.hypot(p,e[i]); e[i + 1] = s * r; s = e[i] / r; c = p / r; p = c * d[i] - s * g; d[i + 1] = h + s * (c * g + s * d[i]); // Accumulate transformation. for (var k = 0; k < n; k++) { h = V[k][i + 1]; V[k][i + 1] = s * V[k][i] + c * h; V[k][i] = c * V[k][i] - s * h; } } p = -s * s2 * c3 * el1 * e[l] / dl1; e[l] = s * p; d[l] = c * p; // Check for convergence. } while (Math.abs(e[l]) > eps*tst1); } d[l] = d[l] + f; e[l] = 0; } // Sort eigenvalues and corresponding vectors. for (var i = 0; i < n - 1; i++) { var k = i; var p = d[i]; for (var j = i + 1; j < n; j++) { if (d[j] < p) { k = j; p = d[j]; } } if (k != i) { d[k] = d[i]; d[i] = p; for (var j = 0; j < n; j++) { p = V[j][i]; V[j][i] = V[j][k]; V[j][k] = p; } } } } // Nonsymmetric reduction to Hessenberg form. function science_lin_decomposeOrthes(H, V) { // This is derived from the Algol procedures orthes and ortran, // by Martin and Wilkinson, Handbook for Auto. Comp., // Vol.ii-Linear Algebra, and the corresponding // Fortran subroutines in EISPACK. var n = H.length; var ort = []; var low = 0; var high = n - 1; for (var m = low + 1; m < high; m++) { // Scale column. var scale = 0; for (var i = m; i <= high; i++) scale += Math.abs(H[i][m - 1]); if (scale !== 0) { // Compute Householder transformation. var h = 0; for (var i = high; i >= m; i--) { ort[i] = H[i][m - 1] / scale; h += ort[i] * ort[i]; } var g = Math.sqrt(h); if (ort[m] > 0) g = -g; h = h - ort[m] * g; ort[m] = ort[m] - g; // Apply Householder similarity transformation // H = (I-u*u'/h)*H*(I-u*u')/h) for (var j = m; j < n; j++) { var f = 0; for (var i = high; i >= m; i--) f += ort[i] * H[i][j]; f /= h; for (var i = m; i <= high; i++) H[i][j] -= f * ort[i]; } for (var i = 0; i <= high; i++) { var f = 0; for (var j = high; j >= m; j--) f += ort[j] * H[i][j]; f /= h; for (var j = m; j <= high; j++) H[i][j] -= f * ort[j]; } ort[m] = scale * ort[m]; H[m][m - 1] = scale * g; } } // Accumulate transformations (Algol's ortran). for (var i = 0; i < n; i++) { for (var j = 0; j < n; j++) V[i][j] = i === j ? 1 : 0; } for (var m = high-1; m >= low+1; m--) { if (H[m][m - 1] !== 0) { for (var i = m + 1; i <= high; i++) ort[i] = H[i][m - 1]; for (var j = m; j <= high; j++) { var g = 0; for (var i = m; i <= high; i++) g += ort[i] * V[i][j]; // Double division avoids possible underflow g = (g / ort[m]) / H[m][m - 1]; for (var i = m; i <= high; i++) V[i][j] += g * ort[i]; } } } } // Nonsymmetric reduction from Hessenberg to real Schur form. function science_lin_decomposeHqr2(d, e, H, V) { // This is derived from the Algol procedure hqr2, // by Martin and Wilkinson, Handbook for Auto. Comp., // Vol.ii-Linear Algebra, and the corresponding // Fortran subroutine in EISPACK. var nn = H.length, n = nn - 1, low = 0, high = nn - 1, eps = 1e-12, exshift = 0, p = 0, q = 0, r = 0, s = 0, z = 0, t, w, x, y; // Store roots isolated by balanc and compute matrix norm var norm = 0; for (var i = 0; i < nn; i++) { if (i < low || i > high) { d[i] = H[i][i]; e[i] = 0; } for (var j = Math.max(i - 1, 0); j < nn; j++) norm += Math.abs(H[i][j]); } // Outer loop over eigenvalue index var iter = 0; while (n >= low) { // Look for single small sub-diagonal element var l = n; while (l > low) { s = Math.abs(H[l - 1][l - 1]) + Math.abs(H[l][l]); if (s === 0) s = norm; if (Math.abs(H[l][l - 1]) < eps * s) break; l--; } // Check for convergence // One root found if (l === n) { H[n][n] = H[n][n] + exshift; d[n] = H[n][n]; e[n] = 0; n--; iter = 0; // Two roots found } else if (l === n - 1) { w = H[n][n - 1] * H[n - 1][n]; p = (H[n - 1][n - 1] - H[n][n]) / 2; q = p * p + w; z = Math.sqrt(Math.abs(q)); H[n][n] = H[n][n] + exshift; H[n - 1][n - 1] = H[n - 1][n - 1] + exshift; x = H[n][n]; // Real pair if (q >= 0) { z = p + (p >= 0 ? z : -z); d[n - 1] = x + z; d[n] = d[n - 1]; if (z !== 0) d[n] = x - w / z; e[n - 1] = 0; e[n] = 0; x = H[n][n - 1]; s = Math.abs(x) + Math.abs(z); p = x / s; q = z / s; r = Math.sqrt(p * p+q * q); p /= r; q /= r; // Row modification for (var j = n - 1; j < nn; j++) { z = H[n - 1][j]; H[n - 1][j] = q * z + p * H[n][j]; H[n][j] = q * H[n][j] - p * z; } // Column modification for (var i = 0; i <= n; i++) { z = H[i][n - 1]; H[i][n - 1] = q * z + p * H[i][n]; H[i][n] = q * H[i][n] - p * z; } // Accumulate transformations for (var i = low; i <= high; i++) { z = V[i][n - 1]; V[i][n - 1] = q * z + p * V[i][n]; V[i][n] = q * V[i][n] - p * z; } // Complex pair } else { d[n - 1] = x + p; d[n] = x + p; e[n - 1] = z; e[n] = -z; } n = n - 2; iter = 0; // No convergence yet } else { // Form shift x = H[n][n]; y = 0; w = 0; if (l < n) { y = H[n - 1][n - 1]; w = H[n][n - 1] * H[n - 1][n]; } // Wilkinson's original ad hoc shift if (iter == 10) { exshift += x; for (var i = low; i <= n; i++) { H[i][i] -= x; } s = Math.abs(H[n][n - 1]) + Math.abs(H[n - 1][n-2]); x = y = 0.75 * s; w = -0.4375 * s * s; } // MATLAB's new ad hoc shift if (iter == 30) { s = (y - x) / 2.0; s = s * s + w; if (s > 0) { s = Math.sqrt(s); if (y < x) { s = -s; } s = x - w / ((y - x) / 2.0 + s); for (var i = low; i <= n; i++) { H[i][i] -= s; } exshift += s; x = y = w = 0.964; } } iter++; // (Could check iteration count here.) // Look for two consecutive small sub-diagonal elements var m = n-2; while (m >= l) { z = H[m][m]; r = x - z; s = y - z; p = (r * s - w) / H[m + 1][m] + H[m][m + 1]; q = H[m + 1][m + 1] - z - r - s; r = H[m+2][m + 1]; s = Math.abs(p) + Math.abs(q) + Math.abs(r); p = p / s; q = q / s; r = r / s; if (m == l) break; if (Math.abs(H[m][m - 1]) * (Math.abs(q) + Math.abs(r)) < eps * (Math.abs(p) * (Math.abs(H[m - 1][m - 1]) + Math.abs(z) + Math.abs(H[m + 1][m + 1])))) { break; } m--; } for (var i = m+2; i <= n; i++) { H[i][i-2] = 0; if (i > m+2) H[i][i-3] = 0; } // Double QR step involving rows l:n and columns m:n for (var k = m; k <= n - 1; k++) { var notlast = (k != n - 1); if (k != m) { p = H[k][k - 1]; q = H[k + 1][k - 1]; r = (notlast ? H[k + 2][k - 1] : 0); x = Math.abs(p) + Math.abs(q) + Math.abs(r); if (x != 0) { p /= x; q /= x; r /= x; } } if (x == 0) break; s = Math.sqrt(p * p + q * q + r * r); if (p < 0) { s = -s; } if (s != 0) { if (k != m) H[k][k - 1] = -s * x; else if (l != m) H[k][k - 1] = -H[k][k - 1]; p += s; x = p / s; y = q / s; z = r / s; q /= p; r /= p; // Row modification for (var j = k; j < nn; j++) { p = H[k][j] + q * H[k + 1][j]; if (notlast) { p = p + r * H[k + 2][j]; H[k + 2][j] = H[k + 2][j] - p * z; } H[k][j] = H[k][j] - p * x; H[k + 1][j] = H[k + 1][j] - p * y; } // Column modification for (var i = 0; i <= Math.min(n, k + 3); i++) { p = x * H[i][k] + y * H[i][k + 1]; if (notlast) { p += z * H[i][k + 2]; H[i][k + 2] = H[i][k + 2] - p * r; } H[i][k] = H[i][k] - p; H[i][k + 1] = H[i][k + 1] - p * q; } // Accumulate transformations for (var i = low; i <= high; i++) { p = x * V[i][k] + y * V[i][k + 1]; if (notlast) { p = p + z * V[i][k + 2]; V[i][k + 2] = V[i][k + 2] - p * r; } V[i][k] = V[i][k] - p; V[i][k + 1] = V[i][k + 1] - p * q; } } // (s != 0) } // k loop } // check convergence } // while (n >= low) // Backsubstitute to find vectors of upper triangular form if (norm == 0) { return; } for (n = nn - 1; n >= 0; n--) { p = d[n]; q = e[n]; // Real vector if (q == 0) { var l = n; H[n][n] = 1.0; for (var i = n - 1; i >= 0; i--) { w = H[i][i] - p; r = 0; for (var j = l; j <= n; j++) { r = r + H[i][j] * H[j][n]; } if (e[i] < 0) { z = w; s = r; } else { l = i; if (e[i] === 0) { H[i][n] = -r / (w !== 0 ? w : eps * norm); } else { // Solve real equations x = H[i][i + 1]; y = H[i + 1][i]; q = (d[i] - p) * (d[i] - p) + e[i] * e[i]; t = (x * s - z * r) / q; H[i][n] = t; if (Math.abs(x) > Math.abs(z)) { H[i + 1][n] = (-r - w * t) / x; } else { H[i + 1][n] = (-s - y * t) / z; } } // Overflow control t = Math.abs(H[i][n]); if ((eps * t) * t > 1) { for (var j = i; j <= n; j++) H[j][n] = H[j][n] / t; } } } // Complex vector } else if (q < 0) { var l = n - 1; // Last vector component imaginary so matrix is triangular if (Math.abs(H[n][n - 1]) > Math.abs(H[n - 1][n])) { H[n - 1][n - 1] = q / H[n][n - 1]; H[n - 1][n] = -(H[n][n] - p) / H[n][n - 1]; } else { var zz = science_lin_decomposeCdiv(0, -H[n - 1][n], H[n - 1][n - 1] - p, q); H[n - 1][n - 1] = zz[0]; H[n - 1][n] = zz[1]; } H[n][n - 1] = 0; H[n][n] = 1; for (var i = n-2; i >= 0; i--) { var ra = 0, sa = 0, vr, vi; for (var j = l; j <= n; j++) { ra = ra + H[i][j] * H[j][n - 1]; sa = sa + H[i][j] * H[j][n]; } w = H[i][i] - p; if (e[i] < 0) { z = w; r = ra; s = sa; } else { l = i; if (e[i] == 0) { var zz = science_lin_decomposeCdiv(-ra,-sa,w,q); H[i][n - 1] = zz[0]; H[i][n] = zz[1]; } else { // Solve complex equations x = H[i][i + 1]; y = H[i + 1][i]; vr = (d[i] - p) * (d[i] - p) + e[i] * e[i] - q * q; vi = (d[i] - p) * 2.0 * q; if (vr == 0 & vi == 0) { vr = eps * norm * (Math.abs(w) + Math.abs(q) + Math.abs(x) + Math.abs(y) + Math.abs(z)); } var zz = science_lin_decomposeCdiv(x*r-z*ra+q*sa,x*s-z*sa-q*ra,vr,vi); H[i][n - 1] = zz[0]; H[i][n] = zz[1]; if (Math.abs(x) > (Math.abs(z) + Math.abs(q))) { H[i + 1][n - 1] = (-ra - w * H[i][n - 1] + q * H[i][n]) / x; H[i + 1][n] = (-sa - w * H[i][n] - q * H[i][n - 1]) / x; } else { var zz = science_lin_decomposeCdiv(-r-y*H[i][n - 1],-s-y*H[i][n],z,q); H[i + 1][n - 1] = zz[0]; H[i + 1][n] = zz[1]; } } // Overflow control t = Math.max(Math.abs(H[i][n - 1]),Math.abs(H[i][n])); if ((eps * t) * t > 1) { for (var j = i; j <= n; j++) { H[j][n - 1] = H[j][n - 1] / t; H[j][n] = H[j][n] / t; } } } } } } // Vectors of isolated roots for (var i = 0; i < nn; i++) { if (i < low || i > high) { for (var j = i; j < nn; j++) V[i][j] = H[i][j]; } } // Back transformation to get eigenvectors of original matrix for (var j = nn - 1; j >= low; j--) { for (var i = low; i <= high; i++) { z = 0; for (var k = low; k <= Math.min(j, high); k++) z += V[i][k] * H[k][j]; V[i][j] = z; } } } // Complex scalar division. function science_lin_decomposeCdiv(xr, xi, yr, yi) { if (Math.abs(yr) > Math.abs(yi)) { var r = yi / yr, d = yr + r * yi; return [(xr + r * xi) / d, (xi - r * xr) / d]; } else { var r = yr / yi, d = yi + r * yr; return [(r * xr + xi) / d, (r * xi - xr) / d]; } } science.js-1.9.3/src/lin/determinant.js000066400000000000000000000017051256532472600200100ustar00rootroot00000000000000// 4x4 matrix determinant. science.lin.determinant = function(matrix) { var m = matrix[0].concat(matrix[1]).concat(matrix[2]).concat(matrix[3]); return ( m[12] * m[9] * m[6] * m[3] - m[8] * m[13] * m[6] * m[3] - m[12] * m[5] * m[10] * m[3] + m[4] * m[13] * m[10] * m[3] + m[8] * m[5] * m[14] * m[3] - m[4] * m[9] * m[14] * m[3] - m[12] * m[9] * m[2] * m[7] + m[8] * m[13] * m[2] * m[7] + m[12] * m[1] * m[10] * m[7] - m[0] * m[13] * m[10] * m[7] - m[8] * m[1] * m[14] * m[7] + m[0] * m[9] * m[14] * m[7] + m[12] * m[5] * m[2] * m[11] - m[4] * m[13] * m[2] * m[11] - m[12] * m[1] * m[6] * m[11] + m[0] * m[13] * m[6] * m[11] + m[4] * m[1] * m[14] * m[11] - m[0] * m[5] * m[14] * m[11] - m[8] * m[5] * m[2] * m[15] + m[4] * m[9] * m[2] * m[15] + m[8] * m[1] * m[6] * m[15] - m[0] * m[9] * m[6] * m[15] - m[4] * m[1] * m[10] * m[15] + m[0] * m[5] * m[10] * m[15]); }; science.js-1.9.3/src/lin/dot.js000066400000000000000000000002311256532472600162550ustar00rootroot00000000000000science.lin.dot = function(a, b) { var s = 0, i = -1, n = Math.min(a.length, b.length); while (++i < n) s += a[i] * b[i]; return s; }; science.js-1.9.3/src/lin/gaussjordan.js000066400000000000000000000021621256532472600200140ustar00rootroot00000000000000// Performs in-place Gauss-Jordan elimination. // // Based on Jarno Elonen's Python version (public domain): // http://elonen.iki.fi/code/misc-notes/python-gaussj/index.html science.lin.gaussjordan = function(m, eps) { if (!eps) eps = 1e-10; var h = m.length, w = m[0].length, y = -1, y2, x; while (++y < h) { var maxrow = y; // Find max pivot. y2 = y; while (++y2 < h) { if (Math.abs(m[y2][y]) > Math.abs(m[maxrow][y])) maxrow = y2; } // Swap. var tmp = m[y]; m[y] = m[maxrow]; m[maxrow] = tmp; // Singular? if (Math.abs(m[y][y]) <= eps) return false; // Eliminate column y. y2 = y; while (++y2 < h) { var c = m[y2][y] / m[y][y]; x = y - 1; while (++x < w) { m[y2][x] -= m[y][x] * c; } } } // Backsubstitute. y = h; while (--y >= 0) { var c = m[y][y]; y2 = -1; while (++y2 < y) { x = w; while (--x >= y) { m[y2][x] -= m[y][x] * m[y2][y] / c; } } m[y][y] /= c; // Normalize row y. x = h - 1; while (++x < w) { m[y][x] /= c; } } return true; }; science.js-1.9.3/src/lin/inverse.js000066400000000000000000000010621256532472600171450ustar00rootroot00000000000000// Find matrix inverse using Gauss-Jordan. science.lin.inverse = function(m) { var n = m.length, i = -1; // Check if the matrix is square. if (n !== m[0].length) return; // Augment with identity matrix I to get AI. m = m.map(function(row, i) { var identity = new Array(n), j = -1; while (++j < n) identity[j] = i === j ? 1 : 0; return row.concat(identity); }); // Compute IA^-1. science.lin.gaussjordan(m); // Remove identity matrix I to get A^-1. while (++i < n) { m[i] = m[i].slice(n); } return m; }; science.js-1.9.3/src/lin/length.js000066400000000000000000000001211256532472600167460ustar00rootroot00000000000000science.lin.length = function(p) { return Math.sqrt(science.lin.dot(p, p)); }; science.js-1.9.3/src/lin/lin.js000066400000000000000000000000221256532472600162470ustar00rootroot00000000000000science.lin = {}; science.js-1.9.3/src/lin/multiply.js000066400000000000000000000007001256532472600173470ustar00rootroot00000000000000science.lin.multiply = function(a, b) { var m = a.length, n = b[0].length, p = b.length, i = -1, j, k; if (p !== a[0].length) throw {"error": "columns(a) != rows(b); " + a[0].length + " != " + p}; var ab = new Array(m); while (++i < m) { ab[i] = new Array(n); j = -1; while(++j < n) { var s = 0; k = -1; while (++k < p) s += a[i][k] * b[k][j]; ab[i][j] = s; } } return ab; }; science.js-1.9.3/src/lin/normalize.js000066400000000000000000000002031256532472600174660ustar00rootroot00000000000000science.lin.normalize = function(p) { var length = science.lin.length(p); return p.map(function(d) { return d / length; }); }; science.js-1.9.3/src/lin/transpose.js000066400000000000000000000003571256532472600175160ustar00rootroot00000000000000science.lin.transpose = function(a) { var m = a.length, n = a[0].length, i = -1, j, b = new Array(n); while (++i < n) { b[i] = new Array(m); j = -1; while (++j < m) b[i][j] = a[j][i]; } return b; }; science.js-1.9.3/src/lin/tridag.js000066400000000000000000000010651256532472600167470ustar00rootroot00000000000000/** * Solves tridiagonal systems of linear equations. * * Source: http://en.wikipedia.org/wiki/Tridiagonal_matrix_algorithm * * @param {number[]} a * @param {number[]} b * @param {number[]} c * @param {number[]} d * @param {number[]} x * @param {number} n */ science.lin.tridag = function(a, b, c, d, x, n) { var i, m; for (i = 1; i < n; i++) { m = a[i] / b[i - 1]; b[i] -= m * c[i - 1]; d[i] -= m * d[i - 1]; } x[n - 1] = d[n - 1] / b[n - 1]; for (i = n - 2; i >= 0; i--) { x[i] = (d[i] - c[i] * x[i + 1]) / b[i]; } }; science.js-1.9.3/src/package.js000066400000000000000000000010501256532472600163000ustar00rootroot00000000000000require("./core/core"); require("util").puts(JSON.stringify({ "name": "science", "version": science.version, "description": "Scientific and statistical computing in JavaScript.", "keywords": ["science", "statistics", "mathematics"], "homepage": "https://github.com/jasondavies/science.js", "author": {"name": "Jason Davies", "url": "http://www.jasondavies.com/"}, "repository": {"type": "git", "url": "http://github.com/jasondavies/science.js.git"}, "devDependencies": { "uglify-js": "1.2.6", "vows": "0.6.0" } }, null, 2)); science.js-1.9.3/src/stats/000077500000000000000000000000001256532472600155115ustar00rootroot00000000000000science.js-1.9.3/src/stats/bandwidth.js000066400000000000000000000013101256532472600200060ustar00rootroot00000000000000// Bandwidth selectors for Gaussian kernels. // Based on R's implementations in `stats.bw`. science.stats.bandwidth = { // Silverman, B. W. (1986) Density Estimation. London: Chapman and Hall. nrd0: function(x) { var hi = Math.sqrt(science.stats.variance(x)); if (!(lo = Math.min(hi, science.stats.iqr(x) / 1.34))) (lo = hi) || (lo = Math.abs(x[1])) || (lo = 1); return .9 * lo * Math.pow(x.length, -.2); }, // Scott, D. W. (1992) Multivariate Density Estimation: Theory, Practice, and // Visualization. Wiley. nrd: function(x) { var h = science.stats.iqr(x) / 1.34; return 1.06 * Math.min(Math.sqrt(science.stats.variance(x)), h) * Math.pow(x.length, -1/5); } }; science.js-1.9.3/src/stats/distance.js000066400000000000000000000025261256532472600176460ustar00rootroot00000000000000science.stats.distance = { euclidean: function(a, b) { var n = a.length, i = -1, s = 0, x; while (++i < n) { x = a[i] - b[i]; s += x * x; } return Math.sqrt(s); }, manhattan: function(a, b) { var n = a.length, i = -1, s = 0; while (++i < n) s += Math.abs(a[i] - b[i]); return s; }, minkowski: function(p) { return function(a, b) { var n = a.length, i = -1, s = 0; while (++i < n) s += Math.pow(Math.abs(a[i] - b[i]), p); return Math.pow(s, 1 / p); }; }, chebyshev: function(a, b) { var n = a.length, i = -1, max = 0, x; while (++i < n) { x = Math.abs(a[i] - b[i]); if (x > max) max = x; } return max; }, hamming: function(a, b) { var n = a.length, i = -1, d = 0; while (++i < n) if (a[i] !== b[i]) d++; return d; }, jaccard: function(a, b) { var n = a.length, i = -1, s = 0; while (++i < n) if (a[i] === b[i]) s++; return s / n; }, braycurtis: function(a, b) { var n = a.length, i = -1, s0 = 0, s1 = 0, ai, bi; while (++i < n) { ai = a[i]; bi = b[i]; s0 += Math.abs(ai - bi); s1 += Math.abs(ai + bi); } return s0 / s1; } }; science.js-1.9.3/src/stats/distribution.js000066400000000000000000000000421256532472600205620ustar00rootroot00000000000000science.stats.distribution = { }; science.js-1.9.3/src/stats/distribution/000077500000000000000000000000001256532472600202305ustar00rootroot00000000000000science.js-1.9.3/src/stats/distribution/gaussian.js000066400000000000000000000024001256532472600223740ustar00rootroot00000000000000// From http://www.colingodsey.com/javascript-gaussian-random-number-generator/ // Uses the Box-Muller Transform. science.stats.distribution.gaussian = function() { var random = Math.random, mean = 0, sigma = 1, variance = 1; function gaussian() { var x1, x2, rad, y1; do { x1 = 2 * random() - 1; x2 = 2 * random() - 1; rad = x1 * x1 + x2 * x2; } while (rad >= 1 || rad === 0); return mean + sigma * x1 * Math.sqrt(-2 * Math.log(rad) / rad); } gaussian.pdf = function(x) { x = (x - mean) / sigma; return science_stats_distribution_gaussianConstant * Math.exp(-.5 * x * x) / sigma; }; gaussian.cdf = function(x) { x = (x - mean) / sigma; return .5 * (1 + science.stats.erf(x / Math.SQRT2)); }; gaussian.mean = function(x) { if (!arguments.length) return mean; mean = +x; return gaussian; }; gaussian.variance = function(x) { if (!arguments.length) return variance; sigma = Math.sqrt(variance = +x); return gaussian; }; gaussian.random = function(x) { if (!arguments.length) return random; random = x; return gaussian; }; return gaussian; }; science_stats_distribution_gaussianConstant = 1 / Math.sqrt(2 * Math.PI); science.js-1.9.3/src/stats/erf.js000066400000000000000000000007551256532472600166320ustar00rootroot00000000000000// Based on implementation in http://picomath.org/. science.stats.erf = function(x) { var a1 = 0.254829592, a2 = -0.284496736, a3 = 1.421413741, a4 = -1.453152027, a5 = 1.061405429, p = 0.3275911; // Save the sign of x var sign = x < 0 ? -1 : 1; if (x < 0) { sign = -1; x = -x; } // A&S formula 7.1.26 var t = 1 / (1 + p * x); return sign * ( 1 - (((((a5 * t + a4) * t) + a3) * t + a2) * t + a1) * t * Math.exp(-x * x)); }; science.js-1.9.3/src/stats/hcluster.js000066400000000000000000000065301256532472600177040ustar00rootroot00000000000000science.stats.hcluster = function() { var distance = science.stats.distance.euclidean, linkage = "single"; // single, complete or average function hcluster(vectors) { var n = vectors.length, dMin = [], cSize = [], distMatrix = [], clusters = [], c1, c2, c1Cluster, c2Cluster, p, root, i, j; // Initialise distance matrix and vector of closest clusters. i = -1; while (++i < n) { dMin[i] = 0; distMatrix[i] = []; j = -1; while (++j < n) { distMatrix[i][j] = i === j ? Infinity : distance(vectors[i] , vectors[j]); if (distMatrix[i][dMin[i]] > distMatrix[i][j]) dMin[i] = j; } } // create leaves of the tree i = -1; while (++i < n) { clusters[i] = []; clusters[i][0] = { left: null, right: null, dist: 0, centroid: vectors[i], size: 1, depth: 0 }; cSize[i] = 1; } // Main loop for (p = 0; p < n-1; p++) { // find the closest pair of clusters c1 = 0; for (i = 0; i < n; i++) { if (distMatrix[i][dMin[i]] < distMatrix[c1][dMin[c1]]) c1 = i; } c2 = dMin[c1]; // create node to store cluster info c1Cluster = clusters[c1][0]; c2Cluster = clusters[c2][0]; var newCluster = { left: c1Cluster, right: c2Cluster, dist: distMatrix[c1][c2], centroid: calculateCentroid(c1Cluster.size, c1Cluster.centroid, c2Cluster.size, c2Cluster.centroid), size: c1Cluster.size + c2Cluster.size, depth: 1 + Math.max(c1Cluster.depth, c2Cluster.depth) }; clusters[c1].splice(0, 0, newCluster); cSize[c1] += cSize[c2]; // overwrite row c1 with respect to the linkage type for (j = 0; j < n; j++) { switch (linkage) { case "single": if (distMatrix[c1][j] > distMatrix[c2][j]) distMatrix[j][c1] = distMatrix[c1][j] = distMatrix[c2][j]; break; case "complete": if (distMatrix[c1][j] < distMatrix[c2][j]) distMatrix[j][c1] = distMatrix[c1][j] = distMatrix[c2][j]; break; case "average": distMatrix[j][c1] = distMatrix[c1][j] = (cSize[c1] * distMatrix[c1][j] + cSize[c2] * distMatrix[c2][j]) / (cSize[c1] + cSize[j]); break; } } distMatrix[c1][c1] = Infinity; // infinity ­out old row c2 and column c2 for (i = 0; i < n; i++) distMatrix[i][c2] = distMatrix[c2][i] = Infinity; // update dmin and replace ones that previous pointed to c2 to point to c1 for (j = 0; j < n; j++) { if (dMin[j] == c2) dMin[j] = c1; if (distMatrix[c1][j] < distMatrix[c1][dMin[c1]]) dMin[c1] = j; } // keep track of the last added cluster root = newCluster; } return root; } hcluster.distance = function(x) { if (!arguments.length) return distance; distance = x; return hcluster; }; return hcluster; }; function calculateCentroid(c1Size, c1Centroid, c2Size, c2Centroid) { var newCentroid = [], newSize = c1Size + c2Size, n = c1Centroid.length, i = -1; while (++i < n) { newCentroid[i] = (c1Size * c1Centroid[i] + c2Size * c2Centroid[i]) / newSize; } return newCentroid; } science.js-1.9.3/src/stats/iqr.js000066400000000000000000000002051256532472600166370ustar00rootroot00000000000000science.stats.iqr = function(x) { var quartiles = science.stats.quantiles(x, [.25, .75]); return quartiles[1] - quartiles[0]; }; science.js-1.9.3/src/stats/kde.js000066400000000000000000000015161256532472600166150ustar00rootroot00000000000000// http://exploringdata.net/den_trac.htm science.stats.kde = function() { var kernel = science.stats.kernel.gaussian, sample = [], bandwidth = science.stats.bandwidth.nrd; function kde(points, i) { var bw = bandwidth.call(this, sample); return points.map(function(x) { var i = -1, y = 0, n = sample.length; while (++i < n) { y += kernel((x - sample[i]) / bw); } return [x, y / bw / n]; }); } kde.kernel = function(x) { if (!arguments.length) return kernel; kernel = x; return kde; }; kde.sample = function(x) { if (!arguments.length) return sample; sample = x; return kde; }; kde.bandwidth = function(x) { if (!arguments.length) return bandwidth; bandwidth = science.functor(x); return kde; }; return kde; }; science.js-1.9.3/src/stats/kernel.js000066400000000000000000000015501256532472600173300ustar00rootroot00000000000000// See . science.stats.kernel = { uniform: function(u) { if (u <= 1 && u >= -1) return .5; return 0; }, triangular: function(u) { if (u <= 1 && u >= -1) return 1 - Math.abs(u); return 0; }, epanechnikov: function(u) { if (u <= 1 && u >= -1) return .75 * (1 - u * u); return 0; }, quartic: function(u) { if (u <= 1 && u >= -1) { var tmp = 1 - u * u; return (15 / 16) * tmp * tmp; } return 0; }, triweight: function(u) { if (u <= 1 && u >= -1) { var tmp = 1 - u * u; return (35 / 32) * tmp * tmp * tmp; } return 0; }, gaussian: function(u) { return 1 / Math.sqrt(2 * Math.PI) * Math.exp(-.5 * u * u); }, cosine: function(u) { if (u <= 1 && u >= -1) return Math.PI / 4 * Math.cos(Math.PI / 2 * u); return 0; } }; science.js-1.9.3/src/stats/kmeans.js000066400000000000000000000063431256532472600173330ustar00rootroot00000000000000// Based on figue implementation by Jean-Yves Delort. // http://code.google.com/p/figue/ science.stats.kmeans = function() { var distance = science.stats.distance.euclidean, maxIterations = 1000, k = 1; function kmeans(vectors) { var n = vectors.length, assignments = [], clusterSizes = [], repeat = 1, iterations = 0, centroids = science_stats_kmeansRandom(k, vectors), newCentroids, i, j, x, d, min, best; while (repeat && iterations < maxIterations) { // Assignment step. j = -1; while (++j < k) { clusterSizes[j] = 0; } i = -1; while (++i < n) { x = vectors[i]; min = Infinity; j = -1; while (++j < k) { d = distance.call(this, centroids[j], x); if (d < min) { min = d; best = j; } } clusterSizes[assignments[i] = best]++; } // Update centroids step. newCentroids = []; i = -1; while (++i < n) { x = assignments[i]; d = newCentroids[x]; if (d == null) newCentroids[x] = vectors[i].slice(); else { j = -1; while (++j < d.length) { d[j] += vectors[i][j]; } } } j = -1; while (++j < k) { x = newCentroids[j]; d = 1 / clusterSizes[j]; i = -1; while (++i < x.length) x[i] *= d; } // Check convergence. repeat = 0; j = -1; while (++j < k) { if (!science_stats_kmeansCompare(newCentroids[j], centroids[j])) { repeat = 1; break; } } centroids = newCentroids; iterations++; } return {assignments: assignments, centroids: centroids}; } kmeans.k = function(x) { if (!arguments.length) return k; k = x; return kmeans; }; kmeans.distance = function(x) { if (!arguments.length) return distance; distance = x; return kmeans; }; return kmeans; }; function science_stats_kmeansCompare(a, b) { if (!a || !b || a.length !== b.length) return false; var n = a.length, i = -1; while (++i < n) if (a[i] !== b[i]) return false; return true; } // Returns an array of k distinct vectors randomly selected from the input // array of vectors. Returns null if k > n or if there are less than k distinct // objects in vectors. function science_stats_kmeansRandom(k, vectors) { var n = vectors.length; if (k > n) return null; var selected_vectors = []; var selected_indices = []; var tested_indices = {}; var tested = 0; var selected = 0; var i, vector, select; while (selected < k) { if (tested === n) return null; var random_index = Math.floor(Math.random() * n); if (random_index in tested_indices) continue; tested_indices[random_index] = 1; tested++; vector = vectors[random_index]; select = true; for (i = 0; i < selected; i++) { if (science_stats_kmeansCompare(vector, selected_vectors[i])) { select = false; break; } } if (select) { selected_vectors[selected] = vector; selected_indices[selected] = random_index; selected++; } } return selected_vectors; } science.js-1.9.3/src/stats/loess.js000066400000000000000000000135261256532472600172030ustar00rootroot00000000000000// Based on org.apache.commons.math.analysis.interpolation.LoessInterpolator // from http://commons.apache.org/math/ science.stats.loess = function() { var bandwidth = .3, robustnessIters = 2, accuracy = 1e-12; function smooth(xval, yval, weights) { var n = xval.length, i; if (n !== yval.length) throw {error: "Mismatched array lengths"}; if (n == 0) throw {error: "At least one point required."}; if (arguments.length < 3) { weights = []; i = -1; while (++i < n) weights[i] = 1; } science_stats_loessFiniteReal(xval); science_stats_loessFiniteReal(yval); science_stats_loessFiniteReal(weights); science_stats_loessStrictlyIncreasing(xval); if (n == 1) return [yval[0]]; if (n == 2) return [yval[0], yval[1]]; var bandwidthInPoints = Math.floor(bandwidth * n); if (bandwidthInPoints < 2) throw {error: "Bandwidth too small."}; var res = [], residuals = [], robustnessWeights = []; // Do an initial fit and 'robustnessIters' robustness iterations. // This is equivalent to doing 'robustnessIters+1' robustness iterations // starting with all robustness weights set to 1. i = -1; while (++i < n) { res[i] = 0; residuals[i] = 0; robustnessWeights[i] = 1; } var iter = -1; while (++iter <= robustnessIters) { var bandwidthInterval = [0, bandwidthInPoints - 1]; // At each x, compute a local weighted linear regression var x; i = -1; while (++i < n) { x = xval[i]; // Find out the interval of source points on which // a regression is to be made. if (i > 0) { science_stats_loessUpdateBandwidthInterval(xval, weights, i, bandwidthInterval); } var ileft = bandwidthInterval[0], iright = bandwidthInterval[1]; // Compute the point of the bandwidth interval that is // farthest from x var edge = (xval[i] - xval[ileft]) > (xval[iright] - xval[i]) ? ileft : iright; // Compute a least-squares linear fit weighted by // the product of robustness weights and the tricube // weight function. // See http://en.wikipedia.org/wiki/Linear_regression // (section "Univariate linear case") // and http://en.wikipedia.org/wiki/Weighted_least_squares // (section "Weighted least squares") var sumWeights = 0, sumX = 0, sumXSquared = 0, sumY = 0, sumXY = 0, denom = Math.abs(1 / (xval[edge] - x)); for (var k = ileft; k <= iright; ++k) { var xk = xval[k], yk = yval[k], dist = k < i ? x - xk : xk - x, w = science_stats_loessTricube(dist * denom) * robustnessWeights[k] * weights[k], xkw = xk * w; sumWeights += w; sumX += xkw; sumXSquared += xk * xkw; sumY += yk * w; sumXY += yk * xkw; } var meanX = sumX / sumWeights, meanY = sumY / sumWeights, meanXY = sumXY / sumWeights, meanXSquared = sumXSquared / sumWeights; var beta = (Math.sqrt(Math.abs(meanXSquared - meanX * meanX)) < accuracy) ? 0 : ((meanXY - meanX * meanY) / (meanXSquared - meanX * meanX)); var alpha = meanY - beta * meanX; res[i] = beta * x + alpha; residuals[i] = Math.abs(yval[i] - res[i]); } // No need to recompute the robustness weights at the last // iteration, they won't be needed anymore if (iter === robustnessIters) { break; } // Recompute the robustness weights. // Find the median residual. var medianResidual = science.stats.median(residuals); if (Math.abs(medianResidual) < accuracy) break; var arg, w; i = -1; while (++i < n) { arg = residuals[i] / (6 * medianResidual); robustnessWeights[i] = (arg >= 1) ? 0 : ((w = 1 - arg * arg) * w); } } return res; } smooth.bandwidth = function(x) { if (!arguments.length) return x; bandwidth = x; return smooth; }; smooth.robustnessIterations = function(x) { if (!arguments.length) return x; robustnessIters = x; return smooth; }; smooth.accuracy = function(x) { if (!arguments.length) return x; accuracy = x; return smooth; }; return smooth; }; function science_stats_loessFiniteReal(values) { var n = values.length, i = -1; while (++i < n) if (!isFinite(values[i])) return false; return true; } function science_stats_loessStrictlyIncreasing(xval) { var n = xval.length, i = 0; while (++i < n) if (xval[i - 1] >= xval[i]) return false; return true; } // Compute the tricube weight function. // http://en.wikipedia.org/wiki/Local_regression#Weight_function function science_stats_loessTricube(x) { return (x = 1 - x * x * x) * x * x; } // Given an index interval into xval that embraces a certain number of // points closest to xval[i-1], update the interval so that it embraces // the same number of points closest to xval[i], ignoring zero weights. function science_stats_loessUpdateBandwidthInterval( xval, weights, i, bandwidthInterval) { var left = bandwidthInterval[0], right = bandwidthInterval[1]; // The right edge should be adjusted if the next point to the right // is closer to xval[i] than the leftmost point of the current interval var nextRight = science_stats_loessNextNonzero(weights, right); if ((nextRight < xval.length) && (xval[nextRight] - xval[i]) < (xval[i] - xval[left])) { var nextLeft = science_stats_loessNextNonzero(weights, left); bandwidthInterval[0] = nextLeft; bandwidthInterval[1] = nextRight; } } function science_stats_loessNextNonzero(weights, i) { var j = i + 1; while (j < weights.length && weights[j] === 0) j++; return j; } science.js-1.9.3/src/stats/mean.js000066400000000000000000000003011256532472600167610ustar00rootroot00000000000000// Welford's algorithm. science.stats.mean = function(x) { var n = x.length; if (n === 0) return NaN; var m = 0, i = -1; while (++i < n) m += (x[i] - m) / (i + 1); return m; }; science.js-1.9.3/src/stats/median.js000066400000000000000000000001261256532472600173030ustar00rootroot00000000000000science.stats.median = function(x) { return science.stats.quantiles(x, [.5])[0]; }; science.js-1.9.3/src/stats/mode.js000066400000000000000000000005651256532472600170010ustar00rootroot00000000000000science.stats.mode = function(x) { var counts = {}, mode = [], max = 0, n = x.length, i = -1, d, k; while (++i < n) { k = counts.hasOwnProperty(d = x[i]) ? ++counts[d] : counts[d] = 1; if (k === max) mode.push(d); else if (k > max) { max = k; mode = [d]; } } if (mode.length === 1) return mode[0]; }; science.js-1.9.3/src/stats/phi.js000066400000000000000000000001341256532472600166250ustar00rootroot00000000000000science.stats.phi = function(x) { return .5 * (1 + science.stats.erf(x / Math.SQRT2)); }; science.js-1.9.3/src/stats/quantiles.js000066400000000000000000000006521256532472600200570ustar00rootroot00000000000000// Uses R's quantile algorithm type=7. science.stats.quantiles = function(d, quantiles) { d = d.slice().sort(science.ascending); var n_1 = d.length - 1; return quantiles.map(function(q) { if (q === 0) return d[0]; else if (q === 1) return d[n_1]; var index = 1 + q * n_1, lo = Math.floor(index), h = index - lo, a = d[lo - 1]; return h === 0 ? a : a + h * (d[lo] - a); }); }; science.js-1.9.3/src/stats/stats.js000066400000000000000000000000241256532472600172010ustar00rootroot00000000000000science.stats = {}; science.js-1.9.3/src/stats/variance.js000066400000000000000000000005711256532472600176420ustar00rootroot00000000000000// Unbiased estimate of a sample's variance. // Also known as the sample variance, where the denominator is n - 1. science.stats.variance = function(x) { var n = x.length; if (n < 1) return NaN; if (n === 1) return 0; var mean = science.stats.mean(x), i = -1, s = 0; while (++i < n) { var v = x[i] - mean; s += v * v; } return s / (n - 1); }; science.js-1.9.3/test/000077500000000000000000000000001256532472600145435ustar00rootroot00000000000000science.js-1.9.3/test/core/000077500000000000000000000000001256532472600154735ustar00rootroot00000000000000science.js-1.9.3/test/core/ascending-test.js000066400000000000000000000005401256532472600207400ustar00rootroot00000000000000require("../../science.v1"); var vows = require("vows"), assert = require("assert"); var suite = vows.describe("science.ascending"); suite.addBatch({ "ascending": { "simple": function() { var a = [1, 4, 5, 2, 3, 6]; a.sort(science.ascending); assert.deepEqual(a, [1, 2, 3, 4, 5, 6]); } } }); suite.export(module); science.js-1.9.3/test/core/expm1-test.js000066400000000000000000000011641256532472600200420ustar00rootroot00000000000000require("../../science.v1"); var vows = require("vows"), assert = require("assert"); var suite = vows.describe("science.expm1"); suite.addBatch({ "expm1": { "simple": function() { var expm1 = science.expm1; assert.inDelta(expm1(-1 ), -0.632120558828558, 1e-6); assert.inDelta(expm1( 0 ), 0, 1e-6); assert.inDelta(expm1(1e-5 - 1e-8), 0.000009990049900216168, 1e-6); assert.inDelta(expm1(1e-5 + 1e-8), 0.000010010050100217178, 1e-6); assert.inDelta(expm1( 0.5), 0.6487212707001282, 1e-6); } } }); suite.export(module); science.js-1.9.3/test/core/hypot-test.js000066400000000000000000000005631256532472600201550ustar00rootroot00000000000000require("../../science.v1"); var vows = require("vows"), assert = require("assert"); var suite = vows.describe("science.hypot"); suite.addBatch({ "hypot": { "maximum supported hypotenuse": function() { var max = Number.MAX_VALUE / Math.sqrt(2); assert.equal(science.hypot(max, max), 1.7976931348623155e+308); } } }); suite.export(module); science.js-1.9.3/test/core/quadratic-test.js000066400000000000000000000014331256532472600207640ustar00rootroot00000000000000require("../../science.v1"); var vows = require("vows"), assert = require("assert"); var suite = vows.describe("science.quadratic"); suite.addBatch({ "real roots": { topic: function() { return science.quadratic(); }, "no roots": function(quadratic) { assert.deepEqual(quadratic(1, 1, 1), []); }, "single root": function(quadratic) { assert.deepEqual(quadratic(1, -2, 1), [1]); }, "two roots": function(quadratic) { assert.deepEqual(quadratic(1, 1, -2), [-2.5, .5]); } }, "complex roots": { topic: function() { return science.quadratic().complex(true); }, "imaginary parts": function(quadratic) { assert.deepEqual(quadratic(1, 0, 1), [{r: 0, i: -1}, {r: 0, i: 1}]); } } }); suite.export(module); science.js-1.9.3/test/core/zeroes-test.js000066400000000000000000000014541256532472600203210ustar00rootroot00000000000000require("../../science.v1"); var vows = require("vows"), assert = require("assert"); var suite = vows.describe("science.zeroes"); suite.addBatch({ "zeroes": { "10": function() { assert.deepEqual(science.zeroes(10), [ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ]); }, "10, 10": function() { assert.deepEqual(science.zeroes(10, 10), [ [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] ]); } } }); suite.export(module); science.js-1.9.3/test/env-assert.js000066400000000000000000000013671256532472600171770ustar00rootroot00000000000000var assert = require("assert"); assert.inDelta = function(actual, expected, delta, message) { if (!inDelta(actual, expected, delta)) { assert.fail(actual, expected, message || "expected {actual} to be in within *" + delta + "* of {expected}", null, assert.inDelta); } }; function inDelta(actual, expected, delta) { return (Array.isArray(expected) ? inDeltaArray : inDeltaNumber)(actual, expected, delta); } function inDeltaArray(actual, expected, delta) { var n = expected.length, i = -1; if (actual.length !== n) return false; while (++i < n) if (!inDelta(actual[i], expected[i], delta)) return false; return true; } function inDeltaNumber(actual, expected, delta) { return actual >= expected - delta && actual <= expected + delta; } science.js-1.9.3/test/lin/000077500000000000000000000000001256532472600153255ustar00rootroot00000000000000science.js-1.9.3/test/lin/decompose-test.js000066400000000000000000000010301256532472600206100ustar00rootroot00000000000000require("../../science.v1"); require("../../science.v1"); var vows = require("vows"), assert = require("assert"); var suite = vows.describe("science.lin.decompose"); suite.addBatch({ "decompose": { topic: science.lin.decompose, "symmetric": function(decompose) { var A = [[1, 1, 1], [1, 2, 3], [1, 3, 6]], result = decompose(A); assert.inDelta( science.lin.multiply(A, result.V), science.lin.multiply(result.V, result.D), 1e-6 ); } } }); suite.export(module); science.js-1.9.3/test/lin/tridag-test.js000066400000000000000000000020061256532472600201100ustar00rootroot00000000000000require("../../science.v1"); require("../../science.v1"); var vows = require("vows"), assert = require("assert"); var suite = vows.describe("science.lin.tridag"); suite.addBatch({ "tridag": { "simple": function() { var n = 31; var a = [], b = [], c = [], d = [], x = []; for (var i=0; i 0) matrix[i - 1][i] = a[i]; if (i < n - 1) matrix[i + 1][i] = c[i]; } var result = science.lin.multiply(matrix, x.map(function(d) { return [d]; })); var epsilon = 1e-12; for (var i=0; i