{"version":3,"sources":["jsdelivr-header.js","/npm/d3-scale-cluster@2.0.1/dist/d3-scale-cluster.umd.js"],"names":[],"mappings":"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","file":"/npm/d3-scale-cluster@2.0.1/dist/d3-scale-cluster.umd.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/d3-scale-cluster@2.0.1/dist/d3-scale-cluster.umd.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = global || self, global.d3scaleCluster = factory());\n}(this, (function () { 'use strict';\n\n  /**\n   * Ckmeans algorithm\n   *\n   * Much of the code that lies within was taken from the simple-statistics library,\n   * which offers a javascript implementation of the ckmeans algorithm originally\n   * designed by Haizhou Wang and Mingzhou Song\n   *\n   * https://cran.r-project.org/web/packages/Ckmeans.1d.dp/\n   * https://github.com/simple-statistics/simple-statistics\n   *\n   * The simple-statistics software license is included below\n   *\n   * --\n   *\n   * ISC License\n   *\n   * Copyright (c) 2014, Tom MacWright\n   *\n   * Permission to use, copy, modify, and/or distribute this software for any\n   * purpose with or without fee is hereby granted, provided that the above\n   * copyright notice and this permission notice appear in all copies.\n   *\n   * THE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\n   * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND\n   * FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\n   * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\n   * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\n   * OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\n   * PERFORMANCE OF THIS SOFTWARE.\n   */\n\n  function numericSort(array) {\n    return (\n      array\n        // ensure the array is not changed in-place\n        .slice()\n        // comparator function that treats input as numeric\n        .sort(function (a, b) {\n          return a - b;\n        })\n    );\n  }\n\n  function uniqueCountSorted(input) {\n    var uniqueValueCount = 0;\n    var lastSeenValue;\n    for (var i = 0; i < input.length; i++) {\n      if (i === 0 || input[i] !== lastSeenValue) {\n        lastSeenValue = input[i];\n        uniqueValueCount++;\n      }\n    }\n    return uniqueValueCount;\n  }\n\n  function makeMatrix(columns, rows) {\n    var matrix = [];\n    for (var i = 0; i < columns; i++) {\n      var column = [];\n      for (var j = 0; j < rows; j++) {\n        column.push(0);\n      }\n      matrix.push(column);\n    }\n    return matrix;\n  }\n\n  function ssq(j, i, sumX, sumXsq) {\n    var sji; // s(j, i)\n    if (j > 0) {\n      var muji = (sumX[i] - sumX[j - 1]) / (i - j + 1); // mu(j, i)\n      sji = sumXsq[i] - sumXsq[j - 1] - (i - j + 1) * muji * muji;\n    } else {\n      sji = sumXsq[i] - (sumX[i] * sumX[i]) / (i + 1);\n    }\n    return sji < 0 ? 0 : sji;\n  }\n\n  function fillMatrixColumn(imin, imax, column, matrix, backtrackMatrix, sumX, sumXsq) {\n    if (imin > imax) {\n      return;\n    }\n\n    // Start at midpoint between imin and imax\n    var i = Math.floor((imin + imax) / 2);\n\n    // Initialization of S[k][i]:\n    matrix[column][i] = matrix[column - 1][i - 1];\n    backtrackMatrix[column][i] = i;\n\n    var jlow = column; // the lower end for j\n\n    if (imin > column) {\n      jlow = Math.max(jlow, backtrackMatrix[column][imin - 1] || 0);\n    }\n    jlow = Math.max(jlow, backtrackMatrix[column - 1][i] || 0);\n\n    var jhigh = i - 1; // the upper end for j\n    if (imax < matrix.length - 1) {\n      jhigh = Math.min(jhigh, backtrackMatrix[column][imax + 1] || 0);\n    }\n\n    var sji;\n    var sjlowi;\n    var ssqjlow;\n    var ssqj;\n    for (var j = jhigh; j >= jlow; --j) {\n      // compute s(j,i)\n      sji = ssq(j, i, sumX, sumXsq);\n\n      // MS May 11, 2016 Added:\n      if (sji + matrix[column - 1][jlow - 1] >= matrix[column][i]) {\n        break;\n      }\n\n      // Examine the lower bound of the cluster border\n      // compute s(jlow, i)\n      sjlowi = ssq(jlow, i, sumX, sumXsq);\n\n      ssqjlow = sjlowi + matrix[column - 1][jlow - 1];\n\n      if (ssqjlow < matrix[column][i]) {\n        // shrink the lower bound\n        matrix[column][i] = ssqjlow;\n        backtrackMatrix[column][i] = jlow;\n      }\n      jlow++;\n\n      ssqj = sji + matrix[column - 1][j - 1];\n      if (ssqj < matrix[column][i]) {\n        matrix[column][i] = ssqj;\n        backtrackMatrix[column][i] = j;\n      }\n    }\n\n    fillMatrixColumn(imin, i - 1, column, matrix, backtrackMatrix, sumX, sumXsq);\n    fillMatrixColumn(i + 1, imax, column, matrix, backtrackMatrix, sumX, sumXsq);\n  }\n\n  function fillMatrices(data, matrix, backtrackMatrix) {\n    var nValues = matrix[0].length;\n    var sumX = new Array(nValues);\n    var sumXsq = new Array(nValues);\n\n    // Use the median to shift values of x to improve numerical stability\n    var shift = data[Math.floor(nValues / 2)];\n\n    // Initialize first row in matrix & backtrackMatrix\n    for (var i = 0; i < nValues; ++i) {\n      if (i === 0) {\n        sumX[0] = data[0] - shift;\n        sumXsq[0] = (data[0] - shift) * (data[0] - shift);\n      } else {\n        sumX[i] = sumX[i - 1] + data[i] - shift;\n        sumXsq[i] = sumXsq[i - 1] + (data[i] - shift) * (data[i] - shift);\n      }\n\n      // Initialize for k = 0\n      matrix[0][i] = ssq(0, i, sumX, sumXsq);\n      backtrackMatrix[0][i] = 0;\n    }\n\n    // Initialize the rest of the columns\n    var imin;\n    for (var k = 1; k < matrix.length; ++k) {\n      if (k < matrix.length - 1) {\n        imin = k;\n      } else {\n        // No need to compute matrix[K-1][0] ... matrix[K-1][N-2]\n        imin = nValues - 1;\n      }\n\n      fillMatrixColumn(imin, nValues - 1, k, matrix, backtrackMatrix, sumX, sumXsq);\n    }\n  }\n\n  /**\n   * Ckmeans clustering is an improvement on heuristic-based clustering\n   * approaches like Jenks. The algorithm was developed in\n   * [Haizhou Wang and Mingzhou Song](http://journal.r-project.org/archive/2011-2/RJournal_2011-2_Wang+Song.pdf)\n   * as a [dynamic programming](https://en.wikipedia.org/wiki/Dynamic_programming) approach\n   * to the problem of clustering numeric data into groups with the least\n   * within-group sum-of-squared-deviations.\n   *\n   * Minimizing the difference within groups - what Wang & Song refer to as\n   * `withinss`, or within sum-of-squares, means that groups are optimally\n   * homogenous within and the data is split into representative groups.\n   * This is very useful for visualization, where you may want to represent\n   * a continuous variable in discrete color or style groups. This function\n   * can provide groups that emphasize differences between data.\n   *\n   * Being a dynamic approach, this algorithm is based on two matrices that\n   * store incrementally-computed values for squared deviations and backtracking\n   * indexes.\n   *\n   * Unlike the [original implementation](https://cran.r-project.org/web/packages/Ckmeans.1d.dp/index.html),\n   * this implementation does not include any code to automatically determine\n   * the optimal number of clusters: this information needs to be explicitly\n   * provided.\n   *\n   * ### References\n   * _Ckmeans.1d.dp: Optimal k-means Clustering in One Dimension by Dynamic\n   * Programming_ Haizhou Wang and Mingzhou Song ISSN 2073-4859\n   *\n   * from The R Journal Vol. 3/2, December 2011\n   * @param {Array<number>} data input data, as an array of number values\n   * @param {number} nClusters number of desired classes. This cannot be\n   * greater than the number of values in the data array.\n   * @returns {Array<Array<number>>} clustered input\n   * @example\n   * ckmeans([-1, 2, -1, 2, 4, 5, 6, -1, 2, -1], 3);\n   * // The input, clustered into groups of similar numbers.\n   * //= [[-1, -1, -1, -1], [2, 2, 2], [4, 5, 6]]);\n   */\n  function ckmeans(data, nClusters) {\n    if (nClusters > data.length) {\n      throw new Error('Cannot generate more classes than there are data values');\n    }\n\n    var nValues = data.length;\n\n    var sorted = numericSort(data);\n    // we'll use this as the maximum number of clusters\n    var uniqueCount = uniqueCountSorted(sorted);\n\n    // if all of the input values are identical, there's one cluster\n    // with all of the input in it.\n    if (uniqueCount === 1) {\n      return [sorted];\n    }\n    nClusters = Math.min(uniqueCount, nClusters);\n\n    // named 'S' originally\n    var matrix = makeMatrix(nClusters, nValues);\n    // named 'J' originally\n    var backtrackMatrix = makeMatrix(nClusters, nValues);\n\n    // This is a dynamic programming way to solve the problem of minimizing\n    // within-cluster sum of squares. It's similar to linear regression\n    // in this way, and this calculation incrementally computes the\n    // sum of squares that are later read.\n    fillMatrices(sorted, matrix, backtrackMatrix);\n\n    // The real work of Ckmeans clustering happens in the matrix generation:\n    // the generated matrices encode all possible clustering combinations, and\n    // once they're generated we can solve for the best clustering groups\n    // very quickly.\n    var clusters = [];\n    var clusterRight = backtrackMatrix[0].length - 1;\n\n    // Backtrack the clusters from the dynamic programming matrix. This\n    // starts at the bottom-right corner of the matrix (if the top-left is 0, 0),\n    // and moves the cluster target with the loop.\n    for (var cluster = backtrackMatrix.length - 1; cluster >= 0; cluster--) {\n      var clusterLeft = backtrackMatrix[cluster][clusterRight];\n\n      // fill the cluster from the sorted input by taking a slice of the\n      // array. the backtrack matrix makes this easy - it stores the\n      // indexes where the cluster should start and end.\n      clusters[cluster] = sorted[clusterLeft];\n\n      if (cluster > 0) {\n        clusterRight = clusterLeft - 1;\n      }\n    }\n\n    return clusters;\n  }\n\n  var ckmeans_esm = ckmeans;\n\n  function d3scaleCluster() {\n    var isReady = false;\n    var domain = [];\n    var range = [];\n    var breakpoints = [];\n\n    var scale = function (x) {\n      if (!isReady) return undefined;\n\n      for (var i = breakpoints.length - 1; i >= 0; i--) {\n        if (x >= breakpoints[i]) {\n          return range[i];\n        }\n      }\n      return range[0];\n    };\n\n    function rescale() {\n      if (range.length <= 2) {\n        return;\n      }\n\n      var clusters = ckmeans_esm(domain, Math.min(domain.length, range.length));\n      isReady = clusters.length !== 0;\n      breakpoints = [];\n      for (var i = 0; i < clusters.length; i++) {\n        // clusters might be a typed array\n        breakpoints.push(clusters[i]);\n      }\n    }\n\n    scale.domain = function () {\n      if (arguments.length) {\n        domain = arguments[0];\n        rescale();\n        return scale;\n      } else {\n        return domain;\n      }\n    };\n\n    scale.range = function () {\n      if (arguments.length) {\n        var newRange = arguments[0];\n        var needsUpdate = newRange.length !== range.length;\n        range = newRange;\n        if (needsUpdate) {\n          rescale();\n        }\n        return scale;\n      } else {\n        return range;\n      }\n    };\n\n    scale.invertExtent = function (rangeValue) {\n      // d3.scaleQuantile.invertExtent returns NaNs for invalid usage, emulate that behavior here\n      var extentA = NaN;\n      var extentB = NaN;\n      for (var i = 0; i < range.length; i++) {\n        if (range[i] === rangeValue) {\n          extentA = breakpoints[i];\n          extentB = i + 1 < range.length ? breakpoints[i + 1] : NaN;\n          break;\n        }\n      }\n      return [extentA, extentB];\n    };\n\n    scale.clusters = function () {\n      return breakpoints.slice(1);\n    };\n\n    scale.export = function () {\n      return {\n        isReady: isReady,\n        domain: domain,\n        range: range,\n        breakpoints: breakpoints,\n      };\n    };\n\n    scale.import = function (params) {\n      if (!params) {\n        throw new Error('Import requires parameters');\n      }\n      isReady = params.isReady;\n      domain = params.domain;\n      range = params.range;\n      breakpoints = params.breakpoints;\n      return scale;\n    };\n\n    scale.copy = function () {\n      return d3scaleCluster().domain(domain).range(range);\n    };\n\n    return scale;\n  }\n\n  if (typeof d3 === 'object') {\n    // eslint-disable-next-line no-undef\n    d3.scaleCluster = d3scaleCluster;\n  }\n\n  var src = d3scaleCluster;\n\n  return src;\n\n})));\n"]}