@datagrok/eda 1.2.8 → 1.3.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (11) hide show
  1. package/dist/738.js.map +1 -1
  2. package/dist/980.js.map +1 -1
  3. package/dist/package-test.js +1 -1
  4. package/dist/package-test.js.map +1 -1
  5. package/dist/package.js +1 -1
  6. package/dist/package.js.map +1 -1
  7. package/package.json +95 -94
  8. package/src/package.ts +14 -25
  9. package/src/pls/pls-tools.ts +4 -3
  10. package/test-console-output-1.log +330 -0
  11. package/test-record-1.mp4 +0 -0
package/dist/738.js.map CHANGED
@@ -1 +1 @@
1
- {"version":3,"file":"738.js","mappings":"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","sources":["webpack://eda/./node_modules/@datagrok-libraries/math/src/dbscan/wasm/wasmDbscan.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/distance-matrix/utils.js","webpack://eda/./node_modules/@datagrok-libraries/utils/src/type-declarations.js","webpack://eda/./node_modules/@datagrok-libraries/utils/src/vector-operations.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/typed-metrics/typed-metrics.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/distance-matrix/distance-matrix-service.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/utils.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/heap.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/matrix.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/tree.js","webpack://eda/./node_modules/@datagrok-libraries/ml/node_modules/is-any-array/src/index.js","webpack://eda/./node_modules/@datagrok-libraries/ml/node_modules/ml-levenberg-marquardt/src/errorCalculation.js","webpack://eda/./node_modules/@datagrok-libraries/ml/node_modules/ml-levenberg-marquardt/src/step.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/umap.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/nn_descent.js","webpack://eda/./node_modules/@datagrok-libraries/ml/node_modules/ml-levenberg-marquardt/src/index.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/t-sne/t-sne.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/distance-matrix/proxy.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/getGPUDevice.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/multi-col-distances/webGPU-aggregation.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/multi-col-distances/webGPU-multicol-distances.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/multi-col-knn/multiCol-KNN.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/types.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/preprocessing/webGPU-process-info.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/knn-sparse-info.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/pairwise-sparse-ops.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/errorCalculation.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/step.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/gradientFunction.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/utils.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/index.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/checkOptions.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/fuzzy-simplical-set.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/wgsl/knn-sparse-info.wgsl.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/smooth-knn-distance.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/wgsl/smooth-knn-distance.wgsl.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/WEBGPU-UMAP.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/optimization-loop.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/wgsl/optimization-loop.wgsl.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/membership-strengths.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/wgsl/membership-strengths.wgsl.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/simplical-set-embedding.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/mulit-column-dim-reducer-worker.js","webpack://eda/./node_modules/seedrandom/index.js","webpack://eda/./node_modules/seedrandom/lib/alea.js","webpack://eda/./node_modules/seedrandom/lib/tychei.js","webpack://eda/./node_modules/seedrandom/lib/xor128.js","webpack://eda/./node_modules/seedrandom/lib/xor4096.js","webpack://eda/./node_modules/seedrandom/lib/xorshift7.js","webpack://eda/./node_modules/seedrandom/lib/xorwow.js","webpack://eda/./node_modules/seedrandom/seedrandom.js"],"sourcesContent":["\r\nexport var exportCppDbscanLib = (() => {\r\n var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;\r\n \r\n return (\r\nfunction(exportCppDbscanLib = {}) {\r\n\r\n// include: shell.js\r\n// The Module object: Our interface to the outside world. We import\r\n// and export values on it. There are various ways Module can be used:\r\n// 1. Not defined. We create it here\r\n// 2. A function parameter, function(Module) { ..generated code.. }\r\n// 3. pre-run appended it, var Module = {}; ..generated code..\r\n// 4. External script tag defines var Module.\r\n// We need to check if Module already exists (e.g. case 3 above).\r\n// Substitution will be replaced with actual code on later stage of the build,\r\n// this way Closure Compiler will not mangle it (e.g. case 4. above).\r\n// Note that if you want to run closure, and also to use Module\r\n// after the generated code, you will need to define var Module = {};\r\n// before the code. Then that object will be used in the code, and you\r\n// can continue to use Module afterwards as well.\r\nvar Module = typeof exportCppDbscanLib != 'undefined' ? exportCppDbscanLib : {};\r\n\r\n// Set up the promise that indicates the Module is initialized\r\nvar readyPromiseResolve, readyPromiseReject;\r\nModule['ready'] = new Promise(function(resolve, reject) {\r\n readyPromiseResolve = resolve;\r\n readyPromiseReject = reject;\r\n});\r\n\r\n// --pre-jses are emitted after the Module integration code, so that they can\r\n// refer to Module (if they choose; they can also define Module)\r\n\r\n\r\n// Sometimes an existing Module object exists with properties\r\n// meant to overwrite the default module functionality. Here\r\n// we collect those properties and reapply _after_ we configure\r\n// the current environment's defaults to avoid having to be so\r\n// defensive during initialization.\r\nvar moduleOverrides = Object.assign({}, Module);\r\n\r\nvar arguments_ = [];\r\nvar thisProgram = './this.program';\r\nvar quit_ = (status, toThrow) => {\r\n throw toThrow;\r\n};\r\n\r\n// Determine the runtime environment we are in. You can customize this by\r\n// setting the ENVIRONMENT setting at compile time (see settings.js).\r\n\r\n// Attempt to auto-detect the environment\r\nvar ENVIRONMENT_IS_WEB = typeof window == 'object';\r\nvar ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';\r\n// N.b. Electron.js environment is simultaneously a NODE-environment, but\r\n// also a web environment.\r\nvar ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';\r\nvar ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;\r\n\r\n// `/` should be present at the end if `scriptDirectory` is not empty\r\nvar scriptDirectory = '';\r\nfunction locateFile(path) {\r\n if (Module['locateFile']) {\r\n return Module['locateFile'](path, scriptDirectory);\r\n }\r\n return scriptDirectory + path;\r\n}\r\n\r\n// Hooks that are implemented differently in different runtime environments.\r\nvar read_,\r\n readAsync,\r\n readBinary,\r\n setWindowTitle;\r\n\r\n// Note that this includes Node.js workers when relevant (pthreads is enabled).\r\n// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and\r\n// ENVIRONMENT_IS_NODE.\r\nif (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {\r\n if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled\r\n scriptDirectory = self.location.href;\r\n } else if (typeof document != 'undefined' && document.currentScript) { // web\r\n scriptDirectory = document.currentScript.src;\r\n }\r\n // When MODULARIZE, this JS may be executed later, after document.currentScript\r\n // is gone, so we saved it, and we use it here instead of any other info.\r\n if (_scriptDir) {\r\n scriptDirectory = _scriptDir;\r\n }\r\n // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.\r\n // otherwise, slice off the final part of the url to find the script directory.\r\n // if scriptDirectory does not contain a slash, lastIndexOf will return -1,\r\n // and scriptDirectory will correctly be replaced with an empty string.\r\n // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),\r\n // they are removed because they could contain a slash.\r\n if (scriptDirectory.indexOf('blob:') !== 0) {\r\n scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, \"\").lastIndexOf('/')+1);\r\n } else {\r\n scriptDirectory = '';\r\n }\r\n\r\n // Differentiate the Web Worker from the Node Worker case, as reading must\r\n // be done differently.\r\n {\r\n// include: web_or_worker_shell_read.js\r\nread_ = (url) => {\r\n var xhr = new XMLHttpRequest();\r\n xhr.open('GET', url, false);\r\n xhr.send(null);\r\n return xhr.responseText;\r\n }\r\n\r\n if (ENVIRONMENT_IS_WORKER) {\r\n readBinary = (url) => {\r\n var xhr = new XMLHttpRequest();\r\n xhr.open('GET', url, false);\r\n xhr.responseType = 'arraybuffer';\r\n xhr.send(null);\r\n return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));\r\n };\r\n }\r\n\r\n readAsync = (url, onload, onerror) => {\r\n var xhr = new XMLHttpRequest();\r\n xhr.open('GET', url, true);\r\n xhr.responseType = 'arraybuffer';\r\n xhr.onload = () => {\r\n if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0\r\n onload(xhr.response);\r\n return;\r\n }\r\n onerror();\r\n };\r\n xhr.onerror = onerror;\r\n xhr.send(null);\r\n }\r\n\r\n// end include: web_or_worker_shell_read.js\r\n }\r\n\r\n setWindowTitle = (title) => document.title = title;\r\n} else\r\n{\r\n}\r\n\r\nvar out = Module['print'] || console.log.bind(console);\r\nvar err = Module['printErr'] || console.warn.bind(console);\r\n\r\n// Merge back in the overrides\r\nObject.assign(Module, moduleOverrides);\r\n// Free the object hierarchy contained in the overrides, this lets the GC\r\n// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.\r\nmoduleOverrides = null;\r\n\r\n// Emit code to handle expected values on the Module object. This applies Module.x\r\n// to the proper local x. This has two benefits: first, we only emit it if it is\r\n// expected to arrive, and second, by using a local everywhere else that can be\r\n// minified.\r\n\r\nif (Module['arguments']) arguments_ = Module['arguments'];\r\n\r\nif (Module['thisProgram']) thisProgram = Module['thisProgram'];\r\n\r\nif (Module['quit']) quit_ = Module['quit'];\r\n\r\n// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message\r\n\r\n\r\n// end include: shell.js\r\n// include: preamble.js\r\n// === Preamble library stuff ===\r\n\r\n// Documentation for the public APIs defined in this file must be updated in:\r\n// site/source/docs/api_reference/preamble.js.rst\r\n// A prebuilt local version of the documentation is available at:\r\n// site/build/text/docs/api_reference/preamble.js.txt\r\n// You can also build docs locally as HTML or other formats in site/\r\n// An online HTML version (which may be of a different version of Emscripten)\r\n// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html\r\n\r\nvar wasmBinary;\r\nif (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];\r\nvar noExitRuntime = Module['noExitRuntime'] || true;\r\n\r\nif (typeof WebAssembly != 'object') {\r\n abort('no native wasm support detected');\r\n}\r\n\r\n// Wasm globals\r\n\r\nvar wasmMemory;\r\n\r\n//========================================\r\n// Runtime essentials\r\n//========================================\r\n\r\n// whether we are quitting the application. no code should run after this.\r\n// set in exit() and abort()\r\nvar ABORT = false;\r\n\r\n// set by exit() and abort(). Passed to 'onExit' handler.\r\n// NOTE: This is also used as the process return code code in shell environments\r\n// but only when noExitRuntime is false.\r\nvar EXITSTATUS;\r\n\r\n/** @type {function(*, string=)} */\r\nfunction assert(condition, text) {\r\n if (!condition) {\r\n // This build was created without ASSERTIONS defined. `assert()` should not\r\n // ever be called in this configuration but in case there are callers in\r\n // the wild leave this simple abort() implemenation here for now.\r\n abort(text);\r\n }\r\n}\r\n\r\n// Memory management\r\n\r\nvar HEAP,\r\n/** @type {!Int8Array} */\r\n HEAP8,\r\n/** @type {!Uint8Array} */\r\n HEAPU8,\r\n/** @type {!Int16Array} */\r\n HEAP16,\r\n/** @type {!Uint16Array} */\r\n HEAPU16,\r\n/** @type {!Int32Array} */\r\n HEAP32,\r\n/** @type {!Uint32Array} */\r\n HEAPU32,\r\n/** @type {!Float32Array} */\r\n HEAPF32,\r\n/** @type {!Float64Array} */\r\n HEAPF64;\r\n\r\nfunction updateMemoryViews() {\r\n var b = wasmMemory.buffer;\r\n Module['HEAP8'] = HEAP8 = new Int8Array(b);\r\n Module['HEAP16'] = HEAP16 = new Int16Array(b);\r\n Module['HEAP32'] = HEAP32 = new Int32Array(b);\r\n Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);\r\n Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);\r\n Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);\r\n Module['HEAPF32'] = HEAPF32 = new Float32Array(b);\r\n Module['HEAPF64'] = HEAPF64 = new Float64Array(b);\r\n}\r\n\r\n// include: runtime_init_table.js\r\n// In regular non-RELOCATABLE mode the table is exported\r\n// from the wasm module and this will be assigned once\r\n// the exports are available.\r\nvar wasmTable;\r\n\r\n// end include: runtime_init_table.js\r\n// include: runtime_stack_check.js\r\n// end include: runtime_stack_check.js\r\n// include: runtime_assertions.js\r\n// end include: runtime_assertions.js\r\nvar __ATPRERUN__ = []; // functions called before the runtime is initialized\r\nvar __ATINIT__ = []; // functions called during startup\r\nvar __ATEXIT__ = []; // functions called during shutdown\r\nvar __ATPOSTRUN__ = []; // functions called after the main() is called\r\n\r\nvar runtimeInitialized = false;\r\n\r\nvar runtimeKeepaliveCounter = 0;\r\n\r\nfunction keepRuntimeAlive() {\r\n return noExitRuntime || runtimeKeepaliveCounter > 0;\r\n}\r\n\r\nfunction preRun() {\r\n if (Module['preRun']) {\r\n if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];\r\n while (Module['preRun'].length) {\r\n addOnPreRun(Module['preRun'].shift());\r\n }\r\n }\r\n callRuntimeCallbacks(__ATPRERUN__);\r\n}\r\n\r\nfunction initRuntime() {\r\n runtimeInitialized = true;\r\n\r\n \r\n callRuntimeCallbacks(__ATINIT__);\r\n}\r\n\r\nfunction postRun() {\r\n\r\n if (Module['postRun']) {\r\n if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];\r\n while (Module['postRun'].length) {\r\n addOnPostRun(Module['postRun'].shift());\r\n }\r\n }\r\n\r\n callRuntimeCallbacks(__ATPOSTRUN__);\r\n}\r\n\r\nfunction addOnPreRun(cb) {\r\n __ATPRERUN__.unshift(cb);\r\n}\r\n\r\nfunction addOnInit(cb) {\r\n __ATINIT__.unshift(cb);\r\n}\r\n\r\nfunction addOnExit(cb) {\r\n}\r\n\r\nfunction addOnPostRun(cb) {\r\n __ATPOSTRUN__.unshift(cb);\r\n}\r\n\r\n// include: runtime_math.js\r\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul\r\n\r\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround\r\n\r\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32\r\n\r\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc\r\n\r\n// end include: runtime_math.js\r\n// A counter of dependencies for calling run(). If we need to\r\n// do asynchronous work before running, increment this and\r\n// decrement it. Incrementing must happen in a place like\r\n// Module.preRun (used by emcc to add file preloading).\r\n// Note that you can add dependencies in preRun, even though\r\n// it happens right before run - run will be postponed until\r\n// the dependencies are met.\r\nvar runDependencies = 0;\r\nvar runDependencyWatcher = null;\r\nvar dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled\r\n\r\nfunction getUniqueRunDependency(id) {\r\n return id;\r\n}\r\n\r\nfunction addRunDependency(id) {\r\n runDependencies++;\r\n\r\n if (Module['monitorRunDependencies']) {\r\n Module['monitorRunDependencies'](runDependencies);\r\n }\r\n\r\n}\r\n\r\nfunction removeRunDependency(id) {\r\n runDependencies--;\r\n\r\n if (Module['monitorRunDependencies']) {\r\n Module['monitorRunDependencies'](runDependencies);\r\n }\r\n\r\n if (runDependencies == 0) {\r\n if (runDependencyWatcher !== null) {\r\n clearInterval(runDependencyWatcher);\r\n runDependencyWatcher = null;\r\n }\r\n if (dependenciesFulfilled) {\r\n var callback = dependenciesFulfilled;\r\n dependenciesFulfilled = null;\r\n callback(); // can add another dependenciesFulfilled\r\n }\r\n }\r\n}\r\n\r\n/** @param {string|number=} what */\r\nfunction abort(what) {\r\n if (Module['onAbort']) {\r\n Module['onAbort'](what);\r\n }\r\n\r\n what = 'Aborted(' + what + ')';\r\n // TODO(sbc): Should we remove printing and leave it up to whoever\r\n // catches the exception?\r\n err(what);\r\n\r\n ABORT = true;\r\n EXITSTATUS = 1;\r\n\r\n what += '. Build with -sASSERTIONS for more info.';\r\n\r\n // Use a wasm runtime error, because a JS error might be seen as a foreign\r\n // exception, which means we'd run destructors on it. We need the error to\r\n // simply make the program stop.\r\n // FIXME This approach does not work in Wasm EH because it currently does not assume\r\n // all RuntimeErrors are from traps; it decides whether a RuntimeError is from\r\n // a trap or not based on a hidden field within the object. So at the moment\r\n // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that\r\n // allows this in the wasm spec.\r\n\r\n // Suppress closure compiler warning here. Closure compiler's builtin extern\r\n // defintion for WebAssembly.RuntimeError claims it takes no arguments even\r\n // though it can.\r\n // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.\r\n /** @suppress {checkTypes} */\r\n var e = new WebAssembly.RuntimeError(what);\r\n\r\n readyPromiseReject(e);\r\n // Throw the error whether or not MODULARIZE is set because abort is used\r\n // in code paths apart from instantiation where an exception is expected\r\n // to be thrown when abort is called.\r\n throw e;\r\n}\r\n\r\n// include: memoryprofiler.js\r\n// end include: memoryprofiler.js\r\n// include: URIUtils.js\r\n// Prefix of data URIs emitted by SINGLE_FILE and related options.\r\nvar dataURIPrefix = 'data:application/octet-stream;base64,';\r\n\r\n// Indicates whether filename is a base64 data URI.\r\nfunction isDataURI(filename) {\r\n // Prefix of data URIs emitted by SINGLE_FILE and related options.\r\n return filename.startsWith(dataURIPrefix);\r\n}\r\n\r\n// Indicates whether filename is delivered via file protocol (as opposed to http/https)\r\nfunction isFileURI(filename) {\r\n return filename.startsWith('file://');\r\n}\r\n\r\n// end include: URIUtils.js\r\n// include: runtime_exceptions.js\r\n// end include: runtime_exceptions.js\r\nvar wasmBinaryFile;\r\n wasmBinaryFile = 'wasmDbscan.wasm';\r\n if (!isDataURI(wasmBinaryFile)) {\r\n wasmBinaryFile = locateFile(wasmBinaryFile);\r\n }\r\n\r\nfunction getBinary(file) {\r\n try {\r\n if (file == wasmBinaryFile && wasmBinary) {\r\n return new Uint8Array(wasmBinary);\r\n }\r\n if (readBinary) {\r\n return readBinary(file);\r\n }\r\n throw \"both async and sync fetching of the wasm failed\";\r\n }\r\n catch (err) {\r\n abort(err);\r\n }\r\n}\r\n\r\nfunction getBinaryPromise(binaryFile) {\r\n // If we don't have the binary yet, try to load it asynchronously.\r\n // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.\r\n // See https://github.com/github/fetch/pull/92#issuecomment-140665932\r\n // Cordova or Electron apps are typically loaded from a file:// url.\r\n // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.\r\n if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {\r\n if (typeof fetch == 'function'\r\n ) {\r\n return fetch(binaryFile, { credentials: 'same-origin' }).then(function(response) {\r\n if (!response['ok']) {\r\n throw \"failed to load wasm binary file at '\" + binaryFile + \"'\";\r\n }\r\n return response['arrayBuffer']();\r\n }).catch(function () {\r\n return getBinary(binaryFile);\r\n });\r\n }\r\n }\r\n\r\n // Otherwise, getBinary should be able to get it synchronously\r\n return Promise.resolve().then(function() { return getBinary(binaryFile); });\r\n}\r\n\r\nfunction instantiateArrayBuffer(binaryFile, imports, receiver) {\r\n return getBinaryPromise(binaryFile).then(function(binary) {\r\n return WebAssembly.instantiate(binary, imports);\r\n }).then(function (instance) {\r\n return instance;\r\n }).then(receiver, function(reason) {\r\n err('failed to asynchronously prepare wasm: ' + reason);\r\n\r\n abort(reason);\r\n });\r\n}\r\n\r\nfunction instantiateAsync(binary, binaryFile, imports, callback) {\r\n if (!binary &&\r\n typeof WebAssembly.instantiateStreaming == 'function' &&\r\n !isDataURI(binaryFile) &&\r\n typeof fetch == 'function') {\r\n return fetch(binaryFile, { credentials: 'same-origin' }).then(function(response) {\r\n // Suppress closure warning here since the upstream definition for\r\n // instantiateStreaming only allows Promise<Repsponse> rather than\r\n // an actual Response.\r\n // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.\r\n /** @suppress {checkTypes} */\r\n var result = WebAssembly.instantiateStreaming(response, imports);\r\n\r\n return result.then(\r\n callback,\r\n function(reason) {\r\n // We expect the most common failure cause to be a bad MIME type for the binary,\r\n // in which case falling back to ArrayBuffer instantiation should work.\r\n err('wasm streaming compile failed: ' + reason);\r\n err('falling back to ArrayBuffer instantiation');\r\n return instantiateArrayBuffer(binaryFile, imports, callback);\r\n });\r\n });\r\n } else {\r\n return instantiateArrayBuffer(binaryFile, imports, callback);\r\n }\r\n}\r\n\r\n// Create the wasm instance.\r\n// Receives the wasm imports, returns the exports.\r\nfunction createWasm() {\r\n // prepare imports\r\n var info = {\r\n 'env': wasmImports,\r\n 'wasi_snapshot_preview1': wasmImports,\r\n };\r\n // Load the wasm module and create an instance of using native support in the JS engine.\r\n // handle a generated wasm instance, receiving its exports and\r\n // performing other necessary setup\r\n /** @param {WebAssembly.Module=} module*/\r\n function receiveInstance(instance, module) {\r\n var exports = instance.exports;\r\n\r\n Module['asm'] = exports;\r\n\r\n wasmMemory = Module['asm']['memory'];\r\n updateMemoryViews();\r\n\r\n wasmTable = Module['asm']['__indirect_function_table'];\r\n\r\n addOnInit(Module['asm']['__wasm_call_ctors']);\r\n\r\n removeRunDependency('wasm-instantiate');\r\n\r\n return exports;\r\n }\r\n // wait for the pthread pool (if any)\r\n addRunDependency('wasm-instantiate');\r\n\r\n // Prefer streaming instantiation if available.\r\n function receiveInstantiationResult(result) {\r\n // 'result' is a ResultObject object which has both the module and instance.\r\n // receiveInstance() will swap in the exports (to Module.asm) so they can be called\r\n // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.\r\n // When the regression is fixed, can restore the above PTHREADS-enabled path.\r\n receiveInstance(result['instance']);\r\n }\r\n\r\n // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback\r\n // to manually instantiate the Wasm module themselves. This allows pages to\r\n // run the instantiation parallel to any other async startup actions they are\r\n // performing.\r\n // Also pthreads and wasm workers initialize the wasm instance through this\r\n // path.\r\n if (Module['instantiateWasm']) {\r\n\r\n try {\r\n return Module['instantiateWasm'](info, receiveInstance);\r\n } catch(e) {\r\n err('Module.instantiateWasm callback failed with error: ' + e);\r\n // If instantiation fails, reject the module ready promise.\r\n readyPromiseReject(e);\r\n }\r\n }\r\n\r\n // If instantiation fails, reject the module ready promise.\r\n instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);\r\n return {}; // no exports yet; we'll fill them in later\r\n}\r\n\r\n// Globals used by JS i64 conversions (see makeSetValue)\r\nvar tempDouble;\r\nvar tempI64;\r\n\r\n// include: runtime_debug.js\r\n// end include: runtime_debug.js\r\n// === Body ===\r\n\r\n\r\n// end include: preamble.js\r\n\r\n /** @constructor */\r\n function ExitStatus(status) {\r\n this.name = 'ExitStatus';\r\n this.message = 'Program terminated with exit(' + status + ')';\r\n this.status = status;\r\n }\r\n\r\n function callRuntimeCallbacks(callbacks) {\r\n while (callbacks.length > 0) {\r\n // Pass the module as the first argument.\r\n callbacks.shift()(Module);\r\n }\r\n }\r\n\r\n \r\n /**\r\n * @param {number} ptr\r\n * @param {string} type\r\n */\r\n function getValue(ptr, type = 'i8') {\r\n if (type.endsWith('*')) type = '*';\r\n switch (type) {\r\n case 'i1': return HEAP8[((ptr)>>0)];\r\n case 'i8': return HEAP8[((ptr)>>0)];\r\n case 'i16': return HEAP16[((ptr)>>1)];\r\n case 'i32': return HEAP32[((ptr)>>2)];\r\n case 'i64': return HEAP32[((ptr)>>2)];\r\n case 'float': return HEAPF32[((ptr)>>2)];\r\n case 'double': return HEAPF64[((ptr)>>3)];\r\n case '*': return HEAPU32[((ptr)>>2)];\r\n default: abort('invalid type for getValue: ' + type);\r\n }\r\n }\r\n\r\n \r\n /**\r\n * @param {number} ptr\r\n * @param {number} value\r\n * @param {string} type\r\n */\r\n function setValue(ptr, value, type = 'i8') {\r\n if (type.endsWith('*')) type = '*';\r\n switch (type) {\r\n case 'i1': HEAP8[((ptr)>>0)] = value; break;\r\n case 'i8': HEAP8[((ptr)>>0)] = value; break;\r\n case 'i16': HEAP16[((ptr)>>1)] = value; break;\r\n case 'i32': HEAP32[((ptr)>>2)] = value; break;\r\n case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)] = tempI64[0],HEAP32[(((ptr)+(4))>>2)] = tempI64[1]); break;\r\n case 'float': HEAPF32[((ptr)>>2)] = value; break;\r\n case 'double': HEAPF64[((ptr)>>3)] = value; break;\r\n case '*': HEAPU32[((ptr)>>2)] = value; break;\r\n default: abort('invalid type for setValue: ' + type);\r\n }\r\n }\r\n\r\n /** @constructor */\r\n function ExceptionInfo(excPtr) {\r\n this.excPtr = excPtr;\r\n this.ptr = excPtr - 24;\r\n \r\n this.set_type = function(type) {\r\n HEAPU32[(((this.ptr)+(4))>>2)] = type;\r\n };\r\n \r\n this.get_type = function() {\r\n return HEAPU32[(((this.ptr)+(4))>>2)];\r\n };\r\n \r\n this.set_destructor = function(destructor) {\r\n HEAPU32[(((this.ptr)+(8))>>2)] = destructor;\r\n };\r\n \r\n this.get_destructor = function() {\r\n return HEAPU32[(((this.ptr)+(8))>>2)];\r\n };\r\n \r\n this.set_caught = function (caught) {\r\n caught = caught ? 1 : 0;\r\n HEAP8[(((this.ptr)+(12))>>0)] = caught;\r\n };\r\n \r\n this.get_caught = function () {\r\n return HEAP8[(((this.ptr)+(12))>>0)] != 0;\r\n };\r\n \r\n this.set_rethrown = function (rethrown) {\r\n rethrown = rethrown ? 1 : 0;\r\n HEAP8[(((this.ptr)+(13))>>0)] = rethrown;\r\n };\r\n \r\n this.get_rethrown = function () {\r\n return HEAP8[(((this.ptr)+(13))>>0)] != 0;\r\n };\r\n \r\n // Initialize native structure fields. Should be called once after allocated.\r\n this.init = function(type, destructor) {\r\n this.set_adjusted_ptr(0);\r\n this.set_type(type);\r\n this.set_destructor(destructor);\r\n }\r\n \r\n this.set_adjusted_ptr = function(adjustedPtr) {\r\n HEAPU32[(((this.ptr)+(16))>>2)] = adjustedPtr;\r\n };\r\n \r\n this.get_adjusted_ptr = function() {\r\n return HEAPU32[(((this.ptr)+(16))>>2)];\r\n };\r\n \r\n // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted\r\n // when the pointer is casted to some of the exception object base classes (e.g. when virtual\r\n // inheritance is used). When a pointer is thrown this method should return the thrown pointer\r\n // itself.\r\n this.get_exception_ptr = function() {\r\n // Work around a fastcomp bug, this code is still included for some reason in a build without\r\n // exceptions support.\r\n var isPointer = ___cxa_is_pointer_type(this.get_type());\r\n if (isPointer) {\r\n return HEAPU32[((this.excPtr)>>2)];\r\n }\r\n var adjusted = this.get_adjusted_ptr();\r\n if (adjusted !== 0) return adjusted;\r\n return this.excPtr;\r\n };\r\n }\r\n \r\n var exceptionLast = 0;\r\n \r\n var uncaughtExceptionCount = 0;\r\n function ___cxa_throw(ptr, type, destructor) {\r\n var info = new ExceptionInfo(ptr);\r\n // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception.\r\n info.init(type, destructor);\r\n exceptionLast = ptr;\r\n uncaughtExceptionCount++;\r\n throw exceptionLast;\r\n }\r\n\r\n function _abort() {\r\n abort('');\r\n }\r\n\r\n function _emscripten_memcpy_big(dest, src, num) {\r\n HEAPU8.copyWithin(dest, src, src + num);\r\n }\r\n\r\n function getHeapMax() {\r\n // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate\r\n // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side\r\n // for any code that deals with heap sizes, which would require special\r\n // casing all heap size related code to treat 0 specially.\r\n return 2147483648;\r\n }\r\n \r\n function emscripten_realloc_buffer(size) {\r\n var b = wasmMemory.buffer;\r\n try {\r\n // round size grow request up to wasm page size (fixed 64KB per spec)\r\n wasmMemory.grow((size - b.byteLength + 65535) >>> 16); // .grow() takes a delta compared to the previous size\r\n updateMemoryViews();\r\n return 1 /*success*/;\r\n } catch(e) {\r\n }\r\n // implicit 0 return to save code size (caller will cast \"undefined\" into 0\r\n // anyhow)\r\n }\r\n function _emscripten_resize_heap(requestedSize) {\r\n var oldSize = HEAPU8.length;\r\n requestedSize = requestedSize >>> 0;\r\n // With multithreaded builds, races can happen (another thread might increase the size\r\n // in between), so return a failure, and let the caller retry.\r\n \r\n // Memory resize rules:\r\n // 1. Always increase heap size to at least the requested size, rounded up\r\n // to next page multiple.\r\n // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap\r\n // geometrically: increase the heap size according to\r\n // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most\r\n // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).\r\n // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap\r\n // linearly: increase the heap size by at least\r\n // MEMORY_GROWTH_LINEAR_STEP bytes.\r\n // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by\r\n // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest\r\n // 4. If we were unable to allocate as much memory, it may be due to\r\n // over-eager decision to excessively reserve due to (3) above.\r\n // Hence if an allocation fails, cut down on the amount of excess\r\n // growth, in an attempt to succeed to perform a smaller allocation.\r\n \r\n // A limit is set for how much we can grow. We should not exceed that\r\n // (the wasm binary specifies it, so if we tried, we'd fail anyhow).\r\n var maxHeapSize = getHeapMax();\r\n if (requestedSize > maxHeapSize) {\r\n return false;\r\n }\r\n \r\n let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;\r\n \r\n // Loop through potential heap size increases. If we attempt a too eager\r\n // reservation that fails, cut down on the attempted size and reserve a\r\n // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)\r\n for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {\r\n var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth\r\n // but limit overreserving (default to capping at +96MB overgrowth at most)\r\n overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 );\r\n \r\n var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));\r\n \r\n var replacement = emscripten_realloc_buffer(newSize);\r\n if (replacement) {\r\n \r\n return true;\r\n }\r\n }\r\n return false;\r\n }\r\n\r\n function getCFunc(ident) {\r\n var func = Module['_' + ident]; // closure exported function\r\n return func;\r\n }\r\n \r\n \r\n function writeArrayToMemory(array, buffer) {\r\n HEAP8.set(array, buffer);\r\n }\r\n \r\n function lengthBytesUTF8(str) {\r\n var len = 0;\r\n for (var i = 0; i < str.length; ++i) {\r\n // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code\r\n // unit, not a Unicode code point of the character! So decode\r\n // UTF16->UTF32->UTF8.\r\n // See http://unicode.org/faq/utf_bom.html#utf16-3\r\n var c = str.charCodeAt(i); // possibly a lead surrogate\r\n if (c <= 0x7F) {\r\n len++;\r\n } else if (c <= 0x7FF) {\r\n len += 2;\r\n } else if (c >= 0xD800 && c <= 0xDFFF) {\r\n len += 4; ++i;\r\n } else {\r\n len += 3;\r\n }\r\n }\r\n return len;\r\n }\r\n \r\n function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {\r\n // Parameter maxBytesToWrite is not optional. Negative values, 0, null,\r\n // undefined and false each don't write out any bytes.\r\n if (!(maxBytesToWrite > 0))\r\n return 0;\r\n \r\n var startIdx = outIdx;\r\n var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.\r\n for (var i = 0; i < str.length; ++i) {\r\n // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code\r\n // unit, not a Unicode code point of the character! So decode\r\n // UTF16->UTF32->UTF8.\r\n // See http://unicode.org/faq/utf_bom.html#utf16-3\r\n // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description\r\n // and https://www.ietf.org/rfc/rfc2279.txt\r\n // and https://tools.ietf.org/html/rfc3629\r\n var u = str.charCodeAt(i); // possibly a lead surrogate\r\n if (u >= 0xD800 && u <= 0xDFFF) {\r\n var u1 = str.charCodeAt(++i);\r\n u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);\r\n }\r\n if (u <= 0x7F) {\r\n if (outIdx >= endIdx) break;\r\n heap[outIdx++] = u;\r\n } else if (u <= 0x7FF) {\r\n if (outIdx + 1 >= endIdx) break;\r\n heap[outIdx++] = 0xC0 | (u >> 6);\r\n heap[outIdx++] = 0x80 | (u & 63);\r\n } else if (u <= 0xFFFF) {\r\n if (outIdx + 2 >= endIdx) break;\r\n heap[outIdx++] = 0xE0 | (u >> 12);\r\n heap[outIdx++] = 0x80 | ((u >> 6) & 63);\r\n heap[outIdx++] = 0x80 | (u & 63);\r\n } else {\r\n if (outIdx + 3 >= endIdx) break;\r\n heap[outIdx++] = 0xF0 | (u >> 18);\r\n heap[outIdx++] = 0x80 | ((u >> 12) & 63);\r\n heap[outIdx++] = 0x80 | ((u >> 6) & 63);\r\n heap[outIdx++] = 0x80 | (u & 63);\r\n }\r\n }\r\n // Null-terminate the pointer to the buffer.\r\n heap[outIdx] = 0;\r\n return outIdx - startIdx;\r\n }\r\n function stringToUTF8(str, outPtr, maxBytesToWrite) {\r\n return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);\r\n }\r\n function stringToUTF8OnStack(str) {\r\n var size = lengthBytesUTF8(str) + 1;\r\n var ret = stackAlloc(size);\r\n stringToUTF8(str, ret, size);\r\n return ret;\r\n }\r\n \r\n var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;\r\n \r\n /**\r\n * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given\r\n * array that contains uint8 values, returns a copy of that string as a\r\n * Javascript String object.\r\n * heapOrArray is either a regular array, or a JavaScript typed array view.\r\n * @param {number} idx\r\n * @param {number=} maxBytesToRead\r\n * @return {string}\r\n */\r\n function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {\r\n var endIdx = idx + maxBytesToRead;\r\n var endPtr = idx;\r\n // TextDecoder needs to know the byte length in advance, it doesn't stop on\r\n // null terminator by itself. Also, use the length info to avoid running tiny\r\n // strings through TextDecoder, since .subarray() allocates garbage.\r\n // (As a tiny code save trick, compare endPtr against endIdx using a negation,\r\n // so that undefined means Infinity)\r\n while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;\r\n \r\n if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {\r\n return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));\r\n }\r\n var str = '';\r\n // If building with TextDecoder, we have already computed the string length\r\n // above, so test loop end condition against that\r\n while (idx < endPtr) {\r\n // For UTF8 byte structure, see:\r\n // http://en.wikipedia.org/wiki/UTF-8#Description\r\n // https://www.ietf.org/rfc/rfc2279.txt\r\n // https://tools.ietf.org/html/rfc3629\r\n var u0 = heapOrArray[idx++];\r\n if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }\r\n var u1 = heapOrArray[idx++] & 63;\r\n if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }\r\n var u2 = heapOrArray[idx++] & 63;\r\n if ((u0 & 0xF0) == 0xE0) {\r\n u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;\r\n } else {\r\n u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);\r\n }\r\n \r\n if (u0 < 0x10000) {\r\n str += String.fromCharCode(u0);\r\n } else {\r\n var ch = u0 - 0x10000;\r\n str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));\r\n }\r\n }\r\n return str;\r\n }\r\n \r\n \r\n /**\r\n * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the\r\n * emscripten HEAP, returns a copy of that string as a Javascript String object.\r\n *\r\n * @param {number} ptr\r\n * @param {number=} maxBytesToRead - An optional length that specifies the\r\n * maximum number of bytes to read. You can omit this parameter to scan the\r\n * string until the first \u0000 byte. If maxBytesToRead is passed, and the string\r\n * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the\r\n * string will cut short at that byte index (i.e. maxBytesToRead will not\r\n * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing\r\n * frequent uses of UTF8ToString() with and without maxBytesToRead may throw\r\n * JS JIT optimizations off, so it is worth to consider consistently using one\r\n * @return {string}\r\n */\r\n function UTF8ToString(ptr, maxBytesToRead) {\r\n return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';\r\n }\r\n \r\n /**\r\n * @param {string|null=} returnType\r\n * @param {Array=} argTypes\r\n * @param {Arguments|Array=} args\r\n * @param {Object=} opts\r\n */\r\n function ccall(ident, returnType, argTypes, args, opts) {\r\n // For fast lookup of conversion functions\r\n var toC = {\r\n 'string': (str) => {\r\n var ret = 0;\r\n if (str !== null && str !== undefined && str !== 0) { // null string\r\n // at most 4 bytes per UTF-8 code point, +1 for the trailing '\\0'\r\n ret = stringToUTF8OnStack(str);\r\n }\r\n return ret;\r\n },\r\n 'array': (arr) => {\r\n var ret = stackAlloc(arr.length);\r\n writeArrayToMemory(arr, ret);\r\n return ret;\r\n }\r\n };\r\n \r\n function convertReturnValue(ret) {\r\n if (returnType === 'string') {\r\n \r\n return UTF8ToString(ret);\r\n }\r\n if (returnType === 'boolean') return Boolean(ret);\r\n return ret;\r\n }\r\n \r\n var func = getCFunc(ident);\r\n var cArgs = [];\r\n var stack = 0;\r\n if (args) {\r\n for (var i = 0; i < args.length; i++) {\r\n var converter = toC[argTypes[i]];\r\n if (converter) {\r\n if (stack === 0) stack = stackSave();\r\n cArgs[i] = converter(args[i]);\r\n } else {\r\n cArgs[i] = args[i];\r\n }\r\n }\r\n }\r\n var ret = func.apply(null, cArgs);\r\n function onDone(ret) {\r\n if (stack !== 0) stackRestore(stack);\r\n return convertReturnValue(ret);\r\n }\r\n \r\n ret = onDone(ret);\r\n return ret;\r\n }\r\n \r\n /**\r\n * @param {string=} returnType\r\n * @param {Array=} argTypes\r\n * @param {Object=} opts\r\n */\r\n function cwrap(ident, returnType, argTypes, opts) {\r\n // When the function takes numbers and returns a number, we can just return\r\n // the original function\r\n var numericArgs = !argTypes || argTypes.every((type) => type === 'number' || type === 'boolean');\r\n var numericRet = returnType !== 'string';\r\n if (numericRet && numericArgs && !opts) {\r\n return getCFunc(ident);\r\n }\r\n return function() {\r\n return ccall(ident, returnType, argTypes, arguments, opts);\r\n }\r\n }\r\n\r\nvar wasmImports = {\r\n \"__cxa_throw\": ___cxa_throw,\r\n \"abort\": _abort,\r\n \"emscripten_memcpy_big\": _emscripten_memcpy_big,\r\n \"emscripten_resize_heap\": _emscripten_resize_heap\r\n};\r\nvar asm = createWasm();\r\n/** @type {function(...*):?} */\r\nvar ___wasm_call_ctors = function() {\r\n return (___wasm_call_ctors = Module[\"asm\"][\"__wasm_call_ctors\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar _dbscan = Module[\"_dbscan\"] = function() {\r\n return (_dbscan = Module[\"_dbscan\"] = Module[\"asm\"][\"dbscan\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar ___errno_location = function() {\r\n return (___errno_location = Module[\"asm\"][\"__errno_location\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar _malloc = Module[\"_malloc\"] = function() {\r\n return (_malloc = Module[\"_malloc\"] = Module[\"asm\"][\"malloc\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar _free = Module[\"_free\"] = function() {\r\n return (_free = Module[\"_free\"] = Module[\"asm\"][\"free\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar stackSave = function() {\r\n return (stackSave = Module[\"asm\"][\"stackSave\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar stackRestore = function() {\r\n return (stackRestore = Module[\"asm\"][\"stackRestore\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar stackAlloc = function() {\r\n return (stackAlloc = Module[\"asm\"][\"stackAlloc\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar ___cxa_is_pointer_type = function() {\r\n return (___cxa_is_pointer_type = Module[\"asm\"][\"__cxa_is_pointer_type\"]).apply(null, arguments);\r\n};\r\n\r\n\r\n\r\n// include: postamble.js\r\n// === Auto-generated postamble setup entry stuff ===\r\n\r\nModule[\"ccall\"] = ccall;\r\nModule[\"cwrap\"] = cwrap;\r\n\r\n\r\nvar calledRun;\r\n\r\ndependenciesFulfilled = function runCaller() {\r\n // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)\r\n if (!calledRun) run();\r\n if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled\r\n};\r\n\r\nfunction run() {\r\n\r\n if (runDependencies > 0) {\r\n return;\r\n }\r\n\r\n preRun();\r\n\r\n // a preRun added a dependency, run will be called later\r\n if (runDependencies > 0) {\r\n return;\r\n }\r\n\r\n function doRun() {\r\n // run may have just been called through dependencies being fulfilled just in this very frame,\r\n // or while the async setStatus time below was happening\r\n if (calledRun) return;\r\n calledRun = true;\r\n Module['calledRun'] = true;\r\n\r\n if (ABORT) return;\r\n\r\n initRuntime();\r\n\r\n readyPromiseResolve(Module);\r\n if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();\r\n\r\n postRun();\r\n }\r\n\r\n if (Module['setStatus']) {\r\n Module['setStatus']('Running...');\r\n setTimeout(function() {\r\n setTimeout(function() {\r\n Module['setStatus']('');\r\n }, 1);\r\n doRun();\r\n }, 1);\r\n } else\r\n {\r\n doRun();\r\n }\r\n}\r\n\r\nif (Module['preInit']) {\r\n if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];\r\n while (Module['preInit'].length > 0) {\r\n Module['preInit'].pop()();\r\n }\r\n}\r\n\r\nrun();\r\n\r\n\r\n// end include: postamble.js\r\n\r\n\r\n return exportCppDbscanLib.ready\r\n}\r\n\r\n);\r\n})();\r\nif (typeof exports === 'object' && typeof module === 'object')\r\n module.exports = exportCppDbscanLib;\r\nelse if (typeof define === 'function' && define['amd'])\r\n define([], function() { return exportCppDbscanLib; });\r\nelse if (typeof exports === 'object')\r\n exports[\"exportCppDbscanLib\"] = exportCppDbscanLib;\r\n","import { DistanceAggregationMethods } from './types';\nexport const isNil = (x) => x === null || x === undefined;\nexport function insertSmaller(distancesAr, indexes, num, index) {\n if (num > distancesAr[distancesAr.length - 1])\n return;\n const newPosition = distancesAr.findIndex((v) => num < v);\n distancesAr.pop();\n distancesAr.splice(newPosition, 0, num);\n indexes.pop();\n indexes.splice(newPosition, 0, index);\n}\nexport function insertLarger(distancesAr, indexes, num, index) {\n if (num < distancesAr[distancesAr.length - 1])\n return;\n const newPosition = distancesAr.findIndex((v) => num > v);\n distancesAr.pop();\n distancesAr.splice(newPosition, 0, num);\n indexes.pop();\n indexes.splice(newPosition, 0, index);\n}\nexport function getAggregationFunction(aggregationMethod, weights) {\n switch (aggregationMethod) {\n case DistanceAggregationMethods.MANHATTAN:\n return (vs) => vs.reduce((acc, val, idx) => acc + val * weights[idx], 0);\n default:\n return (vs) => {\n // euclidean\n const sum = vs.reduce((acc, val, idx) => acc + (val * weights[idx]) ** 2, 0);\n return Math.sqrt(sum);\n };\n }\n}\n//# sourceMappingURL=data:application/json;base64,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","/**\n * Denotes a vector of floating poit values.\n *\n * @export\n * @class Vector\n * @extends {Float32Array}\n */\nexport class Vector extends Float32Array {\n}\n/**\n * Denotes a two-dimensional matrix.\n *\n * @export\n * @class Matrix\n * @extends {Array<Vector>}\n */\nexport class Matrix extends Array {\n}\n/**\n * Denotes cartesian coordinates.\n *\n * @export\n * @class Coordinates\n * @extends {Matrix}\n */\nexport class Coordinates extends Matrix {\n}\n/**\n * Denotes an array of arbitrary-typed vectors.\n *\n * @export\n * @class Vectors\n * @extends {Array<any>}\n */\nexport class Vectors extends Array {\n}\n//# sourceMappingURL=data:application/json;base64,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","import { Vector } from './type-declarations';\nimport { randomFloat, randomInt } from './random';\n/**\n * Asserts a condition by throwing an Error.\n *\n * @export\n * @param {boolean} [condition=false] Condition to assert.\n * @param {string} [message='Assertion error.'] Message to output.\n * @throws {Error}\n */\nexport function assert(condition = false, message = 'Assertion error.') {\n if (!condition)\n throw new Error(message);\n}\n/**\n * Creates new two-dimensional array and fills it with the value given.\n *\n * @param {number} dimension1 The first dimension of the coordinates (number of rows).\n * @param {number} dimension2 The second dimension of the coordinates (number of columns).\n * @param {number} [fill=0] A value to fill the coordinates with.\n * @return {Coordinates} A two-dimensional filled with the value given.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function initCoordinates(dimension1, dimension2, fill = 0) {\n return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));\n}\n/**\n * Transpose matrix.\n *\n * @export\n * @param {Matrix} matrix The matrix to be transposed.\n * @return {Matrix} Transposed matrix.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function transposeMatrix(matrix) {\n return new Array(matrix[0].length).fill(0)\n .map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));\n}\n/**\n * Adds two vectors with the second one to be multiplied by the given ratio.\n *\n * @export\n * @param {Vector} p The first vector to add.\n * @param {Vector} q The second vector to add.\n * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.\n * @return {Vector} New vector contained the result of operation p+multiplier*q.\n */\nexport function vectorAdd(p, q, multiplier = 1) {\n const nItems = p.length;\n assert(nItems == q.length, 'Vector lengths do not match.');\n const total = new Vector(nItems);\n for (let i = 0; i < p.length; ++i)\n total[i] = p[i] + multiplier * q[i];\n return total;\n}\n/**\n * Sums the vector's items.\n *\n * @param {Vector} v The vector to be summed.\n * @return {number} The vector's items sum.\n */\nfunction itemsSum(v) {\n let total = 0;\n for (let i = 0; i < v.length; ++i)\n total += v[i];\n return total;\n}\n/**\n * Suqares the vector's items.\n *\n * @param {Vector} v The vector to square.\n * @return {Vector} A new vector containing the original's items squared.\n */\nfunction vectorSquare(v) {\n const nItems = v.length;\n const total = new Vector(nItems);\n for (let i = 0; i < v.length; ++i)\n total[i] = v[i] * v[i];\n return total;\n}\nexport function vectorLength(v) {\n let sqrSum = 0;\n for (let i = 0; i < v.length; i++)\n sqrSum += v[i] * v[i];\n return Math.sqrt(sqrSum);\n}\nexport function vectorDotProduct(v1, v2) {\n if (v1.length != v2.length)\n throw new Error('The dimensionality of the vectors must match');\n let prod = 0;\n for (let i = 0; i < v1.length; i++)\n prod += v1[i] * v2[i];\n return prod;\n}\n/**\n * Creates a matrix filled with random floating point values.\n *\n * @export\n * @param {number} dimension1 The first dimension of the matrix.\n * @param {number} dimension2 The second dimension of the matrix.\n * @param {number} [scale=1.] Max value given by random generator.\n * @return {Matrix} A new matrix filled with random floating point values.\n */\nexport function fillRandomMatrix(dimension1, dimension2, scale = 1.) {\n const matrix = initCoordinates(dimension1, dimension2);\n for (let i = 0; i < dimension1; ++i) {\n for (let j = 0; j < dimension2; ++j)\n matrix[i][j] = randomFloat(scale);\n }\n return matrix;\n}\n/**\n * Calculates Euclidean distance between two vectors.\n *\n * @export\n * @param {Vector} p The first vector.\n * @param {Vector} q The second vector.\n * @return {number} Euclidean distance between the given vectors.\n */\nexport function calculateEuclideanDistance(p, q) {\n let result = 0;\n const len = p.length;\n if (len !== q.length)\n throw new Error('The dimensionality of the vectors must match');\n for (let i = 0; i < len; ++i)\n result += Math.pow((p[i] - q[i]), 2);\n return Math.sqrt(result);\n}\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcDistanceMatrix(data, distance) {\n const nItems = data.length;\n const matrix = initCoordinates(nItems, nItems, 0);\n for (let i = 0; i < nItems; ++i) {\n for (let j = i + 1; j < nItems; ++j) {\n const d = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);\n matrix[i][j] = matrix[j][i] = d;\n }\n }\n return matrix;\n}\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcNormalizedDistanceMatrix(data, distance) {\n const nItems = data.length;\n const matrix = initCoordinates(nItems, nItems, 0);\n let max = Number.MIN_VALUE;\n let min = Number.MAX_VALUE;\n for (let i = 0; i < nItems; ++i) {\n for (let j = i; j < nItems; ++j) {\n const d = (data[i] == null) || (data[j] == null || i === j) ? 0 : distance(data[i], data[j]);\n matrix[i][j] = matrix[j][i] = d;\n if (d > max)\n max = d;\n if (d < min)\n min = d;\n }\n }\n for (let i = 0; i < nItems; ++i) {\n for (let j = i + 1; j < nItems; ++j)\n matrix[i][j] = matrix[j][i] = (matrix[i][j] - min) / (max - min);\n }\n return matrix;\n}\n/** Generates array from a range [begin; end] or [begin; end) if endExclusive. **/\nexport function genRange(begin, end, endExclusive = false) {\n const nItems = end - begin + (endExclusive ? 0 : 1);\n const series = new Int32Array(nItems);\n for (let i = 0; i < nItems; ++i)\n series[i] = begin + i;\n return series;\n}\n/**\n * Returns order of values as if they are sorted.\n *\n * @export\n * @param {any[]} values Input array.\n * @param {boolean} [reverse=false] Whether to return reversed order.\n * @return {number[]} The order computed.\n */\nexport function argSort(values, reverse = false) {\n const sortfn = reverse ? (a, b) => (b[0] - a[0]) : (a, b) => (a[0] - b[0]);\n const decor = (v, i) => [v, i]; // set index to value\n const undecor = (a) => a[1]; // leave only index\n const _argsort = (arr) => arr.map(decor).sort(sortfn).map(undecor);\n return _argsort(values);\n}\n/**\n * Returns the indexes of the most diverse objects according to the dist function\n * @param {number} length total number of objects\n * @param {number} n number of diverse elements to find\n * @param {(i1: number, i2: number) => number} dist a function which calculates distance between\n * two objects using their indexes\n * @returns {number[]} The indexes of the most diverse objects\n */\nexport function getDiverseSubset(length, n, dist) {\n function maxBy(values, orderBy) {\n let maxValue = null;\n let maxOrderBy = null;\n for (const element of values) {\n const elementOrderBy = orderBy(element);\n if (maxOrderBy == null || elementOrderBy > maxOrderBy) {\n maxValue = element;\n maxOrderBy = elementOrderBy;\n }\n }\n return maxValue;\n }\n const subset = [randomInt(length - 1)];\n const complement = new Set();\n for (let i = 0; i < length; ++i) {\n if (!subset.includes(i))\n complement.add(i);\n }\n while (subset.length < n) {\n const idx = maxBy(complement.values(), (i) => Math.min.apply(Math, subset.map(function (val, index) {\n return dist(i, val);\n })));\n if (idx) {\n subset.push(idx);\n complement.delete(idx);\n }\n }\n return subset;\n}\n/**\n * Returns normalized vector.\n *\n * @export\n * @param {Vector} data numerical array\n */\nexport function normalize(data) {\n const len = data.length;\n let sum = 0;\n let sumOfSquares = 0;\n for (let i = 0; i < len; ++i) {\n sum += data[i];\n sumOfSquares += Math.pow(data[i], 2);\n }\n const mean = sum / len;\n const stdDevInverse = 1.0 / Math.sqrt(sumOfSquares / len - Math.pow(mean, 2));\n for (let i = 0; i < len; ++i)\n data[i] = (data[i] - mean) * stdDevInverse;\n return data;\n}\n/**\n * Finds set difference between two lists.\n * @param {any[]} a The first list.\n * @param {any[]} b The second list.\n * @return {any[]}\n */\nexport function setDifference(a, b) {\n const bSet = new Set(b);\n return Array.from(new Set(a.filter((x) => !bSet.has(x))).values());\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vector-operations.js","sourceRoot":"","sources":["vector-operations.ts"],"names":[],"mappings":"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","sourcesContent":["import {Matrix, Vector, Coordinates, Vectors, DistanceMetric} from './type-declarations';\nimport {randomFloat, randomInt} from './random';\n\n/**\n * Asserts a condition by throwing an Error.\n *\n * @export\n * @param {boolean} [condition=false] Condition to assert.\n * @param {string} [message='Assertion error.'] Message to output.\n * @throws {Error}\n */\nexport function assert(condition: boolean = false, message: string = 'Assertion error.') {\n  if (!condition)\n    throw new Error(message);\n}\n\n/**\n * Creates new two-dimensional array and fills it with the value given.\n *\n * @param {number} dimension1 The first dimension of the coordinates (number of rows).\n * @param {number} dimension2 The second dimension of the coordinates (number of columns).\n * @param {number} [fill=0] A value to fill the coordinates with.\n * @return {Coordinates} A two-dimensional filled with the value given.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function initCoordinates(dimension1: number, dimension2: number, fill: number = 0): Coordinates {\n  return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));\n}\n\n/**\n * Transpose matrix.\n *\n * @export\n * @param {Matrix} matrix The matrix to be transposed.\n * @return {Matrix} Transposed matrix.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function transposeMatrix(matrix: Matrix): Matrix {\n  return new Array(matrix[0].length).fill(0)\n    .map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));\n}\n\n/**\n * Adds two vectors with the second one to be multiplied by the given ratio.\n *\n * @export\n * @param {Vector} p The first vector to add.\n * @param {Vector} q The second vector to add.\n * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.\n * @return {Vector} New vector contained the result of operation p+multiplier*q.\n */\nexport function vectorAdd(p: Vector, q: Vector, multiplier: number = 1): Vector {\n  const nItems = p.length;\n\n  assert(nItems == q.length, 'Vector lengths do not match.');\n\n  const total = new Vector(nItems);\n\n  for (let i = 0; i < p.length; ++i)\n    total[i] = p[i] + multiplier * q[i];\n\n  return total;\n}\n\n/**\n * Sums the vector's items.\n *\n * @param {Vector} v The vector to be summed.\n * @return {number} The vector's items sum.\n */\nfunction itemsSum(v: Vector): number {\n  let total = 0;\n\n  for (let i = 0; i < v.length; ++i)\n    total += v[i];\n\n  return total;\n}\n\n/**\n * Suqares the vector's items.\n *\n * @param {Vector} v The vector to square.\n * @return {Vector} A new vector containing the original's items squared.\n */\nfunction vectorSquare(v: Vector): Vector {\n  const nItems = v.length;\n  const total = new Vector(nItems);\n\n  for (let i = 0; i < v.length; ++i)\n    total[i] = v[i] * v[i];\n\n  return total;\n}\n\nexport function vectorLength(v: Vector): number {\n  let sqrSum: number = 0;\n  for (let i: number = 0; i < v.length; i++)\n    sqrSum += v[i] * v[i];\n  return Math.sqrt(sqrSum);\n}\n\nexport function vectorDotProduct(v1: Vector, v2: Vector): number {\n  if (v1.length != v2.length)\n    throw new Error('The dimensionality of the vectors must match');\n  let prod: number = 0;\n  for (let i: number = 0; i < v1.length; i++)\n    prod += v1[i] * v2[i];\n  return prod;\n}\n\n/**\n * Creates a matrix filled with random floating point values.\n *\n * @export\n * @param {number} dimension1 The first dimension of the matrix.\n * @param {number} dimension2 The second dimension of the matrix.\n * @param {number} [scale=1.] Max value given by random generator.\n * @return {Matrix} A new matrix filled with random floating point  values.\n */\nexport function fillRandomMatrix(dimension1: number, dimension2: number, scale: number = 1.): Matrix {\n  const matrix = initCoordinates(dimension1, dimension2);\n\n  for (let i = 0; i < dimension1; ++i) {\n    for (let j = 0; j < dimension2; ++j)\n      matrix[i][j] = randomFloat(scale);\n  }\n  return matrix;\n}\n\n/**\n * Calculates Euclidean distance between two vectors.\n *\n * @export\n * @param {Vector} p The first vector.\n * @param {Vector} q The second vector.\n * @return {number} Euclidean distance between the given vectors.\n */\nexport function calculateEuclideanDistance(p: Vector, q: Vector): number {\n  let result = 0;\n  const len = p.length;\n\n  if (len !== q.length)\n    throw new Error('The dimensionality of the vectors must match');\n  \n  for (let i = 0; i < len; ++i)\n    result += (p[i] - q[i]) ** 2;\n  \n  return Math.sqrt(result);\n}\n\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix {\n  const nItems = data.length;\n  const matrix = initCoordinates(nItems, nItems, 0);\n\n  for (let i = 0; i < nItems; ++i) {\n    for (let j = i + 1; j < nItems; ++j) {\n      const d: number = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);\n      matrix[i][j] = matrix[j][i] = d;\n    }\n  }\n  return matrix;\n}\n\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcNormalizedDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix {\n  const nItems = data.length;\n  const matrix = initCoordinates(nItems, nItems, 0);\n  let max = Number.MIN_VALUE;\n  let min = Number.MAX_VALUE;\n  for (let i = 0; i < nItems; ++i) {\n    for (let j = i; j < nItems; ++j) {\n      const d: number = (data[i] == null) || (data[j] == null || i === j) ? 0 : distance(data[i], data[j]);\n      matrix[i][j] = matrix[j][i] = d;\n      if (d > max) max = d;\n      if (d < min) min = d;\n    }\n  }\n  for (let i = 0; i < nItems; ++i) {\n    for (let j = i + 1; j < nItems; ++j)\n      matrix[i][j] = matrix[j][i] = (matrix[i][j] - min) / (max - min);\n  }\n  return matrix;\n}\n\n/** Generates array from a range [begin; end] or [begin; end) if endExclusive. **/\nexport function genRange(begin: number, end: number, endExclusive = false): Int32Array {\n  const nItems = end - begin + (endExclusive ? 0 : 1);\n  const series = new Int32Array(nItems);\n\n  for (let i = 0; i < nItems; ++i)\n    series[i] = begin + i;\n\n  return series;\n}\n\n/**\n * Returns order of values as if they are sorted.\n *\n * @export\n * @param {any[]} values Input array.\n * @param {boolean} [reverse=false] Whether to return reversed order.\n * @return {number[]} The order computed.\n */\nexport function argSort(values: any[], reverse = false): number[] {\n  const sortfn = reverse ? (a: any[], b: any[]) => (b[0] - a[0]) : (a: any[], b: any[]) => (a[0] - b[0]);\n  const decor = (v: any, i: number) => [v, i]; // set index to value\n  const undecor = (a: any[]) => a[1]; // leave only index\n  const _argsort = (arr: any[]) => arr.map(decor).sort(sortfn).map(undecor);\n  return _argsort(values);\n}\n\n/**\n * Returns the indexes of the most diverse objects according to the dist function\n * @param {number} length total number of objects\n * @param {number} n number of diverse elements to find\n * @param {(i1: number, i2: number) => number} dist a function which calculates distance between\n *                                                  two objects using their indexes\n * @returns {number[]} The indexes of the most diverse objects\n */\nexport function getDiverseSubset(length: number, n: number, dist: (i1: number, i2: number) => number): number[] {\n  function maxBy(values: IterableIterator<number>, orderBy: (i: number) => number) {\n    let maxValue = null;\n    let maxOrderBy = null;\n\n    for (const element of values) {\n      const elementOrderBy = orderBy(element);\n      if (maxOrderBy == null || elementOrderBy > maxOrderBy) {\n        maxValue = element;\n        maxOrderBy = elementOrderBy;\n      }\n    }\n    return maxValue;\n  }\n\n  const subset = [randomInt(length - 1)];\n  const complement = new Set();\n\n  for (let i = 0; i < length; ++i) {\n    if (!subset.includes(i))\n      complement.add(i);\n  }\n\n  while (subset.length < n) {\n    const idx = maxBy(\n      complement.values() as IterableIterator<number>,\n      (i) => Math.min.apply(Math, subset.map(function(val, index) {\n        return dist(i, val);\n      })));\n    if (idx) {\n      subset.push(idx);\n      complement.delete(idx);\n    }\n  }\n  return subset;\n}\n\n/**\n * Returns normalized vector.\n * \n * @export\n * @param {Vector} data numerical array\n */\nexport function normalize(data: Vector): Vector {\n  const len = data.length;\n  let sum = 0;\n  let sumOfSquares = 0;\n\n  for (let i = 0; i < len; ++i) {\n    sum += data[i];\n    sumOfSquares += data[i] ** 2;\n  }\n\n  const mean = sum / len;\n  const stdDevInverse = 1.0 / Math.sqrt(sumOfSquares / len - mean ** 2);\n\n  for (let i = 0; i < len; ++i)\n    data[i] = (data[i] - mean) * stdDevInverse;\n\n  return data;\n}\n\n/**\n * Finds set difference between two lists.\n * @param {any[]} a The first list.\n * @param {any[]} b The second list.\n * @return {any[]}\n */\nexport function setDifference(a: any[], b: any[]): any[] {\n  const bSet = new Set(b);\n  return Array.from(new Set(a.filter((x) => !bSet.has(x))).values());\n}\n"]}","import * as fl from 'fastest-levenshtein';\nimport { jaroWinkler } from 'jaro-winkler-typescript';\nimport { asymmetricDistance, braunBlanquetDistance, cosineDistance, diceDistance, euclideanDistance, hammingDistance, kulczynskiDistance, mcConnaugheyDistance, rogotGoldbergDistance, russelDistance, sokalDistance, tanimotoDistance, numericDistance, tanimotoDistanceIntArray, inverseCommonItemsCount, } from '../distance-metrics-methods';\nimport { calculateEuclideanDistance } from '@datagrok-libraries/utils/src/vector-operations';\nimport { mmDistanceFunctions, MmDistanceFunctionsNames } from '../macromolecule-distance-functions';\nimport { DistanceMetricsSubjects, BitArrayMetricsNames, StringMetricsNames, VectorMetricsNames, NumberMetricsNames, IntArrayMetricsNames, NumberArrayMetricsNames } from './consts';\nexport const vectorDistanceMetricsMethods = {\n [VectorMetricsNames.Euclidean]: calculateEuclideanDistance,\n};\nexport const stringDistanceMetricsMethods = {\n [StringMetricsNames.Levenshtein]: fl.distance,\n [StringMetricsNames.JaroWinkler]: jaroWinkler,\n [StringMetricsNames.Manhattan]: manhattanDistance,\n [StringMetricsNames.Onehot]: categoricalDistance,\n};\nexport const bitArrayDistanceMetricsMethods = {\n [BitArrayMetricsNames.Tanimoto]: tanimotoDistance,\n [BitArrayMetricsNames.Dice]: diceDistance,\n [BitArrayMetricsNames.Asymmetric]: asymmetricDistance,\n [BitArrayMetricsNames.BraunBlanquet]: braunBlanquetDistance,\n [BitArrayMetricsNames.Cosine]: cosineDistance,\n [BitArrayMetricsNames.Kulczynski]: kulczynskiDistance,\n [BitArrayMetricsNames.McConnaughey]: mcConnaugheyDistance,\n [BitArrayMetricsNames.RogotGoldberg]: rogotGoldbergDistance,\n [BitArrayMetricsNames.Russel]: russelDistance,\n [BitArrayMetricsNames.Sokal]: sokalDistance,\n [BitArrayMetricsNames.Hamming]: hammingDistance,\n [BitArrayMetricsNames.Euclidean]: euclideanDistance,\n};\nexport const intArrayDistanceMetricsMethods = {\n [IntArrayMetricsNames.TanimotoIntArray]: tanimotoDistanceIntArray,\n};\nexport const numberDistanceMetricsMethods = {\n [NumberMetricsNames.Difference]: numericDistance,\n};\nexport const numberArrayDistanceMetrics = {\n [NumberArrayMetricsNames.CommonItems]: inverseCommonItemsCount,\n};\nexport const AvailableMetrics = {\n [DistanceMetricsSubjects.Vector]: {\n [VectorMetricsNames.Euclidean]: vectorDistanceMetricsMethods[VectorMetricsNames.Euclidean],\n },\n [DistanceMetricsSubjects.String]: {\n [StringMetricsNames.Levenshtein]: stringDistanceMetricsMethods[StringMetricsNames.Levenshtein],\n [StringMetricsNames.JaroWinkler]: stringDistanceMetricsMethods[StringMetricsNames.JaroWinkler],\n [StringMetricsNames.Manhattan]: stringDistanceMetricsMethods[StringMetricsNames.Manhattan],\n [StringMetricsNames.Onehot]: stringDistanceMetricsMethods[StringMetricsNames.Onehot],\n },\n [DistanceMetricsSubjects.BitArray]: {\n [BitArrayMetricsNames.Tanimoto]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Tanimoto],\n [BitArrayMetricsNames.Dice]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Dice],\n [BitArrayMetricsNames.Asymmetric]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Asymmetric],\n [BitArrayMetricsNames.BraunBlanquet]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.BraunBlanquet],\n [BitArrayMetricsNames.Cosine]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Cosine],\n [BitArrayMetricsNames.Kulczynski]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Kulczynski],\n [BitArrayMetricsNames.McConnaughey]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.McConnaughey],\n [BitArrayMetricsNames.RogotGoldberg]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.RogotGoldberg],\n [BitArrayMetricsNames.Russel]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Russel],\n [BitArrayMetricsNames.Sokal]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Sokal],\n },\n [DistanceMetricsSubjects.MacroMolecule]: {\n [MmDistanceFunctionsNames.HAMMING]: mmDistanceFunctions[MmDistanceFunctionsNames.HAMMING],\n [MmDistanceFunctionsNames.LEVENSHTEIN]: mmDistanceFunctions[MmDistanceFunctionsNames.LEVENSHTEIN],\n [MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH]: mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH],\n [MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE]: mmDistanceFunctions[MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE],\n },\n [DistanceMetricsSubjects.Number]: {\n [NumberMetricsNames.Difference]: numberDistanceMetricsMethods[NumberMetricsNames.Difference],\n },\n [DistanceMetricsSubjects.IntArray]: {\n [IntArrayMetricsNames.TanimotoIntArray]: intArrayDistanceMetricsMethods[IntArrayMetricsNames.TanimotoIntArray],\n },\n [DistanceMetricsSubjects.NumberArray]: {\n [NumberArrayMetricsNames.CommonItems]: numberArrayDistanceMetrics[NumberArrayMetricsNames.CommonItems],\n },\n};\nexport const MetricToDataType = Object.keys(AvailableMetrics)\n .reduce((ret, key) => {\n for (const val of Object.keys(AvailableMetrics[key]))\n ret[val] = key;\n return ret;\n}, {});\nexport function isStringMetric(name) {\n return MetricToDataType[name] == 'String';\n}\nexport function isBitArrayMetric(name) {\n return MetricToDataType[name] == 'BitArray';\n}\nexport function isVectorMetric(name) {\n return MetricToDataType[name] == 'Vector';\n}\nexport function isMacroMoleculeMetric(name) {\n return MetricToDataType[name] == DistanceMetricsSubjects.MacroMolecule.toString();\n}\nexport function isNumericMetric(name) {\n return MetricToDataType[name] == DistanceMetricsSubjects.Number.toString();\n}\nexport function isNumberArrayMetric(name) {\n return MetricToDataType[name] == DistanceMetricsSubjects.NumberArray.toString();\n}\n/** Manhattan distance between two sequences (match - 0, mismatch - 1) normalized for length. */\nexport function manhattanDistance(s1, s2) {\n if (s1.length !== s2.length) {\n return 1;\n }\n else {\n let dist = 0;\n for (let i = 1; i < s1.length; i++)\n dist += s1[i] == s2[i] ? 0 : 1;\n return dist / s1.length;\n }\n}\nexport function categoricalDistance(s1, s2) {\n return s1 === s2 ? 0 : 1;\n}\n/** Unified class implementing different string measures. */\nexport class Measure {\n /**\n * Creates an instance of Measure with .\n * @param {string} method Method to calculate distance between strings.\n * @memberof Measurer\n */\n constructor(method) {\n this.method = method;\n this.dataType = MetricToDataType[method];\n }\n /**\n * Returns true if the metric needs arguments to be calculated.\n * @param {KnownMetrics} method Metric to check if it needs arguments.\n * @return {boolean} True if the metric needs arguments.\n * @memberof Measure\n */\n metricNeedsArgs(method) {\n return isMacroMoleculeMetric(method) || isNumericMetric(method) || isNumberArrayMetric(method);\n }\n /**\n * Returns custom string distance function specified.\n * @param {opts} opts Options for the measure. used for macromolecule distances\n * @return {DistanceMetric} Callback of the measure chosen.\n * @memberof Measurer\n */\n getMeasure(opts) {\n const dict = AvailableMetrics;\n if (!dict.hasOwnProperty(this.dataType) || !dict[this.dataType].hasOwnProperty(this.method))\n throw new Error(`Unknown measure ${this.method} for data type ${this.dataType}`);\n return this.metricNeedsArgs(this.method) ?\n dict[this.dataType][this.method](opts) :\n dict[this.dataType][this.method];\n }\n /**\n * Returns custom string distance by the given data type.\n * @param {AvailableDataTypes} dataType Metric's data type\n * @return {string[]} Metric names which expects the given data type\n * @memberof Measurer\n */\n static getMetricByDataType(dataType) {\n return Object.keys(AvailableMetrics[dataType]);\n }\n /** Returns metric names available.\n * @memberof Measurer\n */\n static get availableMeasures() {\n return Object.keys(AvailableMetrics);\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typed-metrics.js","sourceRoot":"","sources":["typed-metrics.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fl from 'fastest-levenshtein';\nimport {jaroWinkler} from 'jaro-winkler-typescript';\nimport {DistanceMetric} from '@datagrok-libraries/utils/src/type-declarations';\nimport {\n  asymmetricDistance,\n  braunBlanquetDistance,\n  cosineDistance,\n  diceDistance,\n  euclideanDistance,\n  hammingDistance,\n  kulczynskiDistance,\n  mcConnaugheyDistance,\n  rogotGoldbergDistance,\n  russelDistance,\n  sokalDistance,\n  tanimotoDistance,\n  numericDistance,\n  tanimotoDistanceIntArray,\n  inverseCommonItemsCount,\n} from '../distance-metrics-methods';\n\nimport {calculateEuclideanDistance} from '@datagrok-libraries/utils/src/vector-operations';\nimport BitArray from '@datagrok-libraries/utils/src/bit-array';\nimport {Vector, StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';\nimport {mmDistanceFunctions, MmDistanceFunctionsNames} from '../macromolecule-distance-functions';\nimport {DistanceMetricsSubjects, BitArrayMetricsNames,\n  StringMetricsNames, VectorMetricsNames, NumberMetricsNames, IntArrayMetricsNames,\n  NumberArrayMetricsNames} from './consts';\n\n\nexport const vectorDistanceMetricsMethods: { [name: string]: (x: Vector, y: Vector) => number } = {\n  [VectorMetricsNames.Euclidean]: calculateEuclideanDistance,\n};\n\nexport const stringDistanceMetricsMethods: { [name: string]: (x: string, y: string) => number } = {\n  [StringMetricsNames.Levenshtein]: fl.distance,\n  [StringMetricsNames.JaroWinkler]: jaroWinkler,\n  [StringMetricsNames.Manhattan]: manhattanDistance,\n  [StringMetricsNames.Onehot]: categoricalDistance,\n};\n\nexport const bitArrayDistanceMetricsMethods: { [name: string]: (x: BitArray, y: BitArray) => number } = {\n  [BitArrayMetricsNames.Tanimoto]: tanimotoDistance,\n  [BitArrayMetricsNames.Dice]: diceDistance,\n  [BitArrayMetricsNames.Asymmetric]: asymmetricDistance,\n  [BitArrayMetricsNames.BraunBlanquet]: braunBlanquetDistance,\n  [BitArrayMetricsNames.Cosine]: cosineDistance,\n  [BitArrayMetricsNames.Kulczynski]: kulczynskiDistance,\n  [BitArrayMetricsNames.McConnaughey]: mcConnaugheyDistance,\n  [BitArrayMetricsNames.RogotGoldberg]: rogotGoldbergDistance,\n  [BitArrayMetricsNames.Russel]: russelDistance,\n  [BitArrayMetricsNames.Sokal]: sokalDistance,\n  [BitArrayMetricsNames.Hamming]: hammingDistance,\n  [BitArrayMetricsNames.Euclidean]: euclideanDistance,\n};\n\nexport const intArrayDistanceMetricsMethods: { [name: string]: (x: Uint32Array, y: Uint32Array) => number } = {\n  [IntArrayMetricsNames.TanimotoIntArray]: tanimotoDistanceIntArray,\n};\n\nexport const numberDistanceMetricsMethods: { [name: string]: (args: any) => (x: number, y: number) => number } = {\n  [NumberMetricsNames.Difference]: numericDistance,\n};\n\nexport const numberArrayDistanceMetrics:\n{ [name: string]: (args: any) => (x: ArrayLike<number>, y: ArrayLike<number>) => number } = {\n  [NumberArrayMetricsNames.CommonItems]: inverseCommonItemsCount,\n};\n\nexport const AvailableMetrics = {\n  [DistanceMetricsSubjects.Vector]: {\n    [VectorMetricsNames.Euclidean]: vectorDistanceMetricsMethods[VectorMetricsNames.Euclidean],\n  },\n  [DistanceMetricsSubjects.String]: {\n    [StringMetricsNames.Levenshtein]: stringDistanceMetricsMethods[StringMetricsNames.Levenshtein],\n    [StringMetricsNames.JaroWinkler]: stringDistanceMetricsMethods[StringMetricsNames.JaroWinkler],\n    [StringMetricsNames.Manhattan]: stringDistanceMetricsMethods[StringMetricsNames.Manhattan],\n    [StringMetricsNames.Onehot]: stringDistanceMetricsMethods[StringMetricsNames.Onehot],\n  },\n  [DistanceMetricsSubjects.BitArray]: {\n    [BitArrayMetricsNames.Tanimoto]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Tanimoto],\n    [BitArrayMetricsNames.Dice]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Dice],\n    [BitArrayMetricsNames.Asymmetric]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Asymmetric],\n    [BitArrayMetricsNames.BraunBlanquet]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.BraunBlanquet],\n    [BitArrayMetricsNames.Cosine]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Cosine],\n    [BitArrayMetricsNames.Kulczynski]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Kulczynski],\n    [BitArrayMetricsNames.McConnaughey]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.McConnaughey],\n    [BitArrayMetricsNames.RogotGoldberg]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.RogotGoldberg],\n    [BitArrayMetricsNames.Russel]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Russel],\n    [BitArrayMetricsNames.Sokal]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Sokal],\n  },\n  [DistanceMetricsSubjects.MacroMolecule]: { // optional args needed for macromolecule functions which initialize them\n    [MmDistanceFunctionsNames.HAMMING]: mmDistanceFunctions[MmDistanceFunctionsNames.HAMMING],\n    [MmDistanceFunctionsNames.LEVENSHTEIN]: mmDistanceFunctions[MmDistanceFunctionsNames.LEVENSHTEIN],\n    [MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH]: mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH],\n    [MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE]:\n      mmDistanceFunctions[MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE],\n  },\n  [DistanceMetricsSubjects.Number]: {\n    [NumberMetricsNames.Difference]: numberDistanceMetricsMethods[NumberMetricsNames.Difference],\n  },\n  [DistanceMetricsSubjects.IntArray]: {\n    [IntArrayMetricsNames.TanimotoIntArray]: intArrayDistanceMetricsMethods[IntArrayMetricsNames.TanimotoIntArray],\n  },\n  [DistanceMetricsSubjects.NumberArray]: {\n    [NumberArrayMetricsNames.CommonItems]: numberArrayDistanceMetrics[NumberArrayMetricsNames.CommonItems],\n  },\n};\n\nexport const MetricToDataType: StringDictionary = Object.keys(AvailableMetrics)\n  .reduce((ret: StringDictionary, key) => {\n    for (const val of Object.keys(AvailableMetrics[key as AvailableDataTypes]))\n      ret[val as AvailableDataTypes] = key;\n\n    return ret;\n  }, {});\n\nexport type AvailableDataTypes = keyof typeof AvailableMetrics;\nexport type VectorMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.Vector];\nexport type StringMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.String];\nexport type BitArrayMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.BitArray];\nexport type NumberMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.Number];\nexport type IntArrayMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.IntArray];\nexport type NumberArrayMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.NumberArray];\nexport type KnownMetrics = StringMetrics | BitArrayMetrics | VectorMetrics |\n  MmDistanceFunctionsNames | NumberMetricsNames | IntArrayMetricsNames | NumberArrayMetricsNames;\n\nexport type ValidTypes =\n  { data: string[], metric: StringMetrics | MmDistanceFunctionsNames } |\n  { data: Vector[], metric: VectorMetrics } |\n  { data: BitArray[], metric: BitArrayMetrics } |\n  { data: number[], metric: NumberMetricsNames };\n\nexport function isStringMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == 'String';\n}\n\nexport function isBitArrayMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == 'BitArray';\n}\n\nexport function isVectorMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == 'Vector';\n}\n\nexport function isMacroMoleculeMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == DistanceMetricsSubjects.MacroMolecule.toString();\n}\n\nexport function isNumericMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == DistanceMetricsSubjects.Number.toString();\n}\n\nexport function isNumberArrayMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == DistanceMetricsSubjects.NumberArray.toString();\n}\n\n/** Manhattan distance between two sequences (match - 0, mismatch - 1) normalized for length. */\nexport function manhattanDistance(s1: string, s2: string): number {\n  if (s1.length !== s2.length) {\n    return 1;\n  } else {\n    let dist: number = 0;\n    for (let i = 1; i < s1.length; i++)\n      dist += s1[i] == s2[i] ? 0 : 1;\n    return dist / s1.length;\n  }\n}\n\nexport function categoricalDistance(s1: string, s2: string): number {\n  return s1 === s2 ? 0 : 1;\n}\n\n/** Unified class implementing different string measures. */\nexport class Measure {\n  protected method: KnownMetrics;\n  protected dataType: AvailableDataTypes;\n\n  /**\n   * Creates an instance of Measure with .\n   * @param {string} method Method to calculate distance between strings.\n   * @memberof Measurer\n   */\n  constructor(method: KnownMetrics) {\n    this.method = method;\n    this.dataType = MetricToDataType[method] as AvailableDataTypes;\n  }\n\n  /**\n   * Returns true if the metric needs arguments to be calculated.\n   * @param {KnownMetrics} method Metric to check if it needs arguments.\n   * @return {boolean} True if the metric needs arguments.\n   * @memberof Measure\n   */\n  public metricNeedsArgs(method: KnownMetrics): boolean {\n    return isMacroMoleculeMetric(method) || isNumericMetric(method) || isNumberArrayMetric(method);\n  }\n  /**\n   * Returns custom string distance function specified.\n   * @param {opts} opts Options for the measure. used for macromolecule distances\n   * @return {DistanceMetric} Callback of the measure chosen.\n   * @memberof Measurer\n   */\n  public getMeasure(opts?: any): DistanceMetric {\n    const dict: { [key: string]:\n      {[key2: string]: DistanceMetric | ((opts: any) => DistanceMetric)}\n    } = AvailableMetrics;\n    if (!dict.hasOwnProperty(this.dataType) || !dict[this.dataType].hasOwnProperty(this.method))\n      throw new Error(`Unknown measure ${this.method} for data type ${this.dataType}`);\n    return this.metricNeedsArgs(this.method) ?\n      (dict[this.dataType][this.method] as ((opts: any) => DistanceMetric))(opts) :\n      dict[this.dataType][this.method] as DistanceMetric;\n  }\n\n  /**\n   * Returns custom string distance by the given data type.\n   * @param {AvailableDataTypes} dataType Metric's data type\n   * @return {string[]} Metric names which expects the given data type\n   * @memberof Measurer\n   */\n  public static getMetricByDataType(dataType: AvailableDataTypes): string[] {\n    return Object.keys(AvailableMetrics[dataType]);\n  }\n\n  /** Returns metric names available.\n   * @memberof Measurer\n   */\n  static get availableMeasures(): string[] {\n    return Object.keys(AvailableMetrics);\n  }\n}\n"]}","import { DistanceAggregationMethods } from './types';\nexport class DistanceMatrixService {\n constructor(useConcurrentWorkers = true, terminateOnComplete = true) {\n const threadCount = navigator.hardwareConcurrency;\n this._workerCount = useConcurrentWorkers ? Math.max(threadCount - 2, 1) : 1;\n this._workers = new Array(this._workerCount).fill(null)\n .map(() => new Worker(new URL('./distance-matrix-worker', import.meta.url)));\n this._terminateOnComplete = terminateOnComplete;\n }\n ;\n async calc(values, fnName, normalize = true, opts) {\n return await this.calcMulti([values], [fnName], normalize, [opts ?? {}], [1], DistanceAggregationMethods.MANHATTAN);\n }\n async calcMulti(values, fnNames, normalize = true, opts = [{}], weights = [1], aggregationMethod = DistanceAggregationMethods.MANHATTAN) {\n if (values.length < 1)\n throw new Error('values must contain at least one array');\n if (fnNames.length !== values.length || opts.length !== values.length || weights.length !== values.length)\n throw new Error('values, fnNames, weights and opts must have the same length');\n return new Promise(async (resolve, reject) => {\n try {\n const len = values[0].length;\n const promises = new Array(this._workerCount);\n const totalLength = len * (len - 1) / 2; // size of reduced distance matrix\n this._workerCount = Math.min(this._workerCount, totalLength);\n const chunkSize = totalLength / this._workerCount;\n const distanceMatrix = new Float32Array(totalLength);\n let endRow = 0;\n let endCol = 1;\n // minmax for normalization\n let lmin = 0;\n let lmax = Number.MIN_VALUE;\n for (let i = 0; i < this._workerCount; i++) {\n const start = Math.floor(i * chunkSize);\n const end = (i === this._workerCount - 1) ? totalLength : Math.floor((i + 1) * chunkSize);\n const startRow = endRow;\n const startCol = endCol;\n if (i !== this._workerCount - 1) {\n // These formulas map the linear index to the upper triangular matrix indices\n endRow = len - 2 - Math.floor(Math.sqrt(-8 * end + 4 * len * (len - 1) - 7) / 2 - 0.5);\n endCol = end - len * endRow + Math.floor((endRow + 1) * (endRow + 2) / 2);\n }\n this._workers[i].postMessage({ values, fnNames, startRow, startCol, chunckSize: end - start, opts, weights, aggregationMethod });\n promises[i] = new Promise((resolveWorker, rejectWorker) => {\n this._workers[i].onmessage = ({ data: { error, distanceMatrixData, min, max } }) => {\n this._terminateOnComplete && setTimeout(() => this._workers[i].terminate());\n if (error) {\n rejectWorker(error);\n }\n else {\n distanceMatrix.set(distanceMatrixData, start);\n if (min < lmin)\n lmin = min;\n if (max > lmax)\n lmax = max;\n resolveWorker();\n }\n };\n });\n }\n await Promise.all(promises);\n if (normalize)\n distanceMatrix.forEach((value, index) => { distanceMatrix[index] = (value - lmin) / (lmax - lmin); });\n resolve(distanceMatrix);\n }\n catch (e) {\n reject(e);\n }\n });\n }\n terminate() {\n this._workers.forEach((worker) => worker.terminate());\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"distance-matrix-service.js","sourceRoot":"","sources":["distance-matrix-service.ts"],"names":[],"mappings":"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","sourcesContent":["import {KnownMetrics} from '../typed-metrics';\nimport {DistanceAggregationMethod, DistanceAggregationMethods} from './types';\n\nexport class DistanceMatrixService {\n    private _workers: Worker[];\n    private _workerCount: number;\n    private _terminateOnComplete: boolean;\n    public constructor(useConcurrentWorkers = true, terminateOnComplete = true) {\n      const threadCount = navigator.hardwareConcurrency;\n      this._workerCount = useConcurrentWorkers ? Math.max(threadCount - 2, 1) : 1;\n      this._workers = new Array(this._workerCount).fill(null)\n        .map(() => new Worker(new URL('./distance-matrix-worker', import.meta.url)));\n      this._terminateOnComplete = terminateOnComplete;\n    };\n\n    public async calc(values: ArrayLike<any>, fnName: KnownMetrics,\n      normalize = true, opts?: {[_: string]: any}): Promise<Float32Array> {\n      return await this.calcMulti([values], [fnName], normalize,\n        [opts ?? {}], [1], DistanceAggregationMethods.MANHATTAN);\n    }\n\n    public async calcMulti(\n      values: ArrayLike<any>[], fnNames: KnownMetrics[],\n      normalize = true, opts: {[_: string]: any}[] = [{}],\n      weights: number[] = [1], aggregationMethod: DistanceAggregationMethod = DistanceAggregationMethods.MANHATTAN\n    ): Promise<Float32Array> {\n      if (values.length < 1)\n        throw new Error('values must contain at least one array');\n      if (fnNames.length !== values.length || opts.length !== values.length || weights.length !== values.length)\n        throw new Error('values, fnNames, weights and opts must have the same length');\n      return new Promise(async (resolve, reject) => {\n        try {\n          const len = values[0].length;\n          const promises = new Array<Promise<void>>(this._workerCount);\n          const totalLength = len * (len - 1) / 2; // size of reduced distance matrix\n          this._workerCount = Math.min(this._workerCount, totalLength);\n          const chunkSize = totalLength / this._workerCount;\n          const distanceMatrix = new Float32Array(totalLength);\n          let endRow = 0;\n          let endCol = 1;\n          // minmax for normalization\n          let lmin = 0;\n          let lmax = Number.MIN_VALUE;\n          for (let i = 0; i < this._workerCount; i++) {\n            const start = Math.floor(i * chunkSize);\n            const end = (i === this._workerCount - 1) ? totalLength : Math.floor((i + 1) * chunkSize);\n            const startRow = endRow;\n            const startCol = endCol;\n            if (i !== this._workerCount - 1) {\n              // These formulas map the linear index to the upper triangular matrix indices\n              endRow = len - 2 - Math.floor(Math.sqrt(-8 * end + 4 * len * (len - 1) - 7) / 2 - 0.5);\n              endCol = end - len * endRow + Math.floor((endRow + 1) * (endRow + 2) / 2);\n            }\n            this._workers[i].postMessage(\n              {values, fnNames, startRow, startCol, chunckSize: end - start, opts, weights, aggregationMethod}\n            );\n            promises[i] = new Promise((resolveWorker, rejectWorker) => {\n              this._workers[i].onmessage = ({data: {error, distanceMatrixData, min, max}}): void => {\n                this._terminateOnComplete && setTimeout(() => this._workers[i].terminate());\n                if (error) {\n                  rejectWorker(error);\n                } else {\n                  distanceMatrix.set(distanceMatrixData, start);\n                  if (min < lmin)\n                    lmin = min;\n                  if (max > lmax)\n                    lmax = max;\n                  resolveWorker();\n                }\n              };\n            });\n          }\n          await Promise.all(promises);\n          if (normalize)\n            distanceMatrix.forEach((value, index) => { distanceMatrix[index] = (value - lmin) / (lmax - lmin); });\n          resolve(distanceMatrix);\n        } catch (e) {\n          reject(e);\n        }\n      });\n    }\n\n    public terminate(): void {\n      this._workers.forEach((worker) => worker.terminate());\n    }\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n/**\n * Simple random integer function\n */\nexport function tauRandInt(n, random) {\n return Math.floor(random() * n);\n}\n/**\n * Simple random float function\n */\nexport function tauRand(random) {\n return random();\n}\n/**\n * Compute the (standard l2) norm of a vector.\n */\nexport function norm(vec) {\n let result = 0;\n for (const item of vec)\n result += item ** 2;\n return Math.sqrt(result);\n}\n/**\n * Creates an empty array (filled with undefined)\n */\nexport function empty(n) {\n const output = [];\n for (let i = 0; i < n; i++)\n output.push(undefined);\n return output;\n}\n/**\n * Creates an array filled with index values\n */\nexport function range(n) {\n return empty(n).map((_, i) => i);\n}\n/**\n * Creates an array filled with a specific value\n */\nexport function filled(n, v) {\n return empty(n).map(() => v);\n}\n/**\n * Creates an array filled with zeros\n */\nexport function zeros(n) {\n return filled(n, 0);\n}\n/**\n * Creates an array filled with ones\n */\nexport function ones(n) {\n return filled(n, 1);\n}\n/**\n * Creates an array from a to b, of length len, inclusive\n */\nexport function linear(a, b, len) {\n return empty(len).map((_, i) => {\n return a + i * ((b - a) / (len - 1));\n });\n}\n/**\n * Returns the sum of an array\n */\nexport function sum(input) {\n return input.reduce((sum, val) => sum + val);\n}\n/**\n * Returns the mean of an array\n */\nexport function mean(input) {\n return sum(input) / input.length;\n}\n/**\n * Returns the maximum value of an array\n */\nexport function max(input) {\n let max = 0;\n for (let i = 0; i < input.length; i++)\n max = input[i] > max ? input[i] : max;\n return max;\n}\n/**\n * Returns the maximum value of a 2d array\n */\nexport function max2d(input) {\n let max = 0;\n for (let i = 0; i < input.length; i++) {\n for (let j = 0; j < input[i].length; j++)\n max = input[i][j] > max ? input[i][j] : max;\n }\n return max;\n}\n/**\n * Generate nSamples many integers from 0 to poolSize such that no\n * integer is selected twice. The duplication constraint is achieved via\n * rejection sampling.\n */\nexport function rejectionSample(nSamples, poolSize, random) {\n const result = zeros(nSamples);\n for (let i = 0; i < nSamples; i++) {\n let rejectSample = true;\n while (rejectSample) {\n const j = tauRandInt(poolSize, random);\n let broken = false;\n for (let k = 0; k < i; k++) {\n if (j === result[k]) {\n broken = true;\n break;\n }\n }\n if (!broken)\n rejectSample = false;\n result[i] = j;\n }\n }\n return result;\n}\n/**\n * Reshapes a 1d array into a 2D of given dimensions.\n */\nexport function reshape2d(x, a, b) {\n const rows = [];\n // let count = 0;\n let index = 0;\n if (x.length !== a * b)\n throw new Error('Array dimensions must match input length.');\n for (let i = 0; i < a; i++) {\n const col = [];\n for (let j = 0; j < b; j++) {\n col.push(x[index]);\n index += 1;\n }\n rows.push(col);\n // count += 1;\n }\n return rows;\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\nimport {RandomFn} from './umap';\n\n/**\n * Simple random integer function\n */\nexport function tauRandInt(n: number, random: RandomFn) {\n  return Math.floor(random() * n);\n}\n\n/**\n * Simple random float function\n */\nexport function tauRand(random: RandomFn) {\n  return random();\n}\n/**\n * Compute the (standard l2) norm of a vector.\n */\nexport function norm(vec: number[]) {\n  let result = 0;\n  for (const item of vec)\n    result += item ** 2;\n\n  return Math.sqrt(result);\n}\n\n/**\n * Creates an empty array (filled with undefined)\n */\nexport function empty(n: number): undefined[] {\n  const output: undefined[] = [];\n  for (let i = 0; i < n; i++)\n    output.push(undefined);\n\n  return output;\n}\n\n/**\n * Creates an array filled with index values\n */\nexport function range(n: number): number[] {\n  return empty(n).map((_, i) => i);\n}\n\n/**\n * Creates an array filled with a specific value\n */\nexport function filled(n: number, v: number): number[] {\n  return empty(n).map(() => v);\n}\n\n/**\n * Creates an array filled with zeros\n */\nexport function zeros(n: number): number[] {\n  return filled(n, 0);\n}\n\n/**\n * Creates an array filled with ones\n */\nexport function ones(n: number): number[] {\n  return filled(n, 1);\n}\n\n/**\n * Creates an array from a to b, of length len, inclusive\n */\nexport function linear(a: number, b: number, len: number): number[] {\n  return empty(len).map((_, i) => {\n    return a + i * ((b - a) / (len - 1));\n  });\n}\n\n/**\n * Returns the sum of an array\n */\nexport function sum(input: number[]): number {\n  return input.reduce((sum, val) => sum + val);\n}\n\n/**\n * Returns the mean of an array\n */\nexport function mean(input: number[]): number {\n  return sum(input) / input.length;\n}\n\n/**\n * Returns the maximum value of an array\n */\nexport function max(input: number[]): number {\n  let max = 0;\n  for (let i = 0; i < input.length; i++)\n    max = input[i] > max ? input[i] : max;\n\n  return max;\n}\n\n/**\n * Returns the maximum value of a 2d array\n */\nexport function max2d(input: number[][]): number {\n  let max = 0;\n  for (let i = 0; i < input.length; i++) {\n    for (let j = 0; j < input[i].length; j++)\n      max = input[i][j] > max ? input[i][j] : max;\n  }\n  return max;\n}\n\n/**\n * Generate nSamples many integers from 0 to poolSize such that no\n * integer is selected twice. The duplication constraint is achieved via\n * rejection sampling.\n */\nexport function rejectionSample(\n  nSamples: number,\n  poolSize: number,\n  random: RandomFn\n): number[] {\n  const result = zeros(nSamples);\n  for (let i = 0; i < nSamples; i++) {\n    let rejectSample = true;\n    while (rejectSample) {\n      const j = tauRandInt(poolSize, random);\n      let broken = false;\n      for (let k = 0; k < i; k++) {\n        if (j === result[k]) {\n          broken = true;\n          break;\n        }\n      }\n      if (!broken)\n        rejectSample = false;\n\n      result[i] = j;\n    }\n  }\n  return result;\n}\n\n/**\n * Reshapes a 1d array into a 2D of given dimensions.\n */\nexport function reshape2d<T>(x: T[], a: number, b: number): T[][] {\n  const rows: T[][] = [];\n  // let count = 0;\n  let index = 0;\n\n  if (x.length !== a * b)\n    throw new Error('Array dimensions must match input length.');\n\n\n  for (let i = 0; i < a; i++) {\n    const col: T[] = [];\n    for (let j = 0; j < b; j++) {\n      col.push(x[index]);\n      index += 1;\n    }\n    rows.push(col);\n    // count += 1;\n  }\n  return rows;\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\nimport * as utils from './utils';\n/**\n * Constructor for the heap objects. The heaps are used\n * for approximate nearest neighbor search, maintaining a list of potential\n * neighbors sorted by their distance. We also flag if potential neighbors\n * are newly added to the list or not. Internally this is stored as\n * a single array; the first axis determines whether we are looking at the\n * array of candidate indices, the array of distances, or the flag array for\n * whether elements are new or not. Each of these arrays are of shape\n * (``nPoints``, ``size``)\n */\nexport function makeHeap(nPoints, size) {\n const makeArrays = (fillValue) => {\n return utils.empty(nPoints).map(() => {\n return utils.filled(size, fillValue);\n });\n };\n const heap = [];\n heap.push(makeArrays(-1));\n heap.push(makeArrays(Infinity));\n heap.push(makeArrays(0));\n return heap;\n}\n/**\n * Generate n_samples many integers from 0 to pool_size such that no\n * integer is selected twice. The duplication constraint is achieved via\n * rejection sampling.\n */\nexport function rejectionSample(nSamples, poolSize, random) {\n const result = utils.zeros(nSamples);\n for (let i = 0; i < nSamples; i++) {\n let rejectSample = true;\n let j = 0;\n while (rejectSample) {\n j = utils.tauRandInt(poolSize, random);\n let broken = false;\n for (let k = 0; k < i; k++) {\n if (j === result[k]) {\n broken = true;\n break;\n }\n }\n if (!broken)\n rejectSample = false;\n }\n result[i] = j;\n }\n return result;\n}\n/**\n * Push a new element onto the heap. The heap stores potential neighbors\n * for each data point. The ``row`` parameter determines which data point we\n * are addressing, the ``weight`` determines the distance (for heap sorting),\n * the ``index`` is the element to add, and the flag determines whether this\n * is to be considered a new addition.\n */\nexport function heapPush(heap, row, weight, index, flag) {\n row = Math.floor(row);\n const indices = heap[0][row];\n const weights = heap[1][row];\n //const isNew = heap[2][row];\n if (weight >= weights[0])\n return 0;\n // Break if we already have this element.\n for (let i = 0; i < indices.length; i++) {\n if (index === indices[i])\n return 0;\n }\n return uncheckedHeapPush(heap, row, weight, index, flag);\n}\n/**\n * Push a new element onto the heap. The heap stores potential neighbors\n * for each data point. The ``row`` parameter determines which data point we\n * are addressing, the ``weight`` determines the distance (for heap sorting),\n * the ``index`` is the element to add, and the flag determines whether this\n * is to be considered a new addition.\n */\nexport function uncheckedHeapPush(heap, row, weight, index, flag) {\n const indices = heap[0][row];\n const weights = heap[1][row];\n const isNew = heap[2][row];\n if (weight >= weights[0])\n return 0;\n // Insert val at position zero\n weights[0] = weight;\n indices[0] = index;\n isNew[0] = flag;\n // Descend the heap, swapping values until the max heap criterion is met\n let i = 0;\n let iSwap = 0;\n while (true) {\n const ic1 = 2 * i + 1;\n const ic2 = ic1 + 1;\n const heapShape2 = heap[0][0].length;\n if (ic1 >= heapShape2) {\n break;\n }\n else if (ic2 >= heapShape2) {\n if (weights[ic1] > weight)\n iSwap = ic1;\n else\n break;\n }\n else if (weights[ic1] >= weights[ic2]) {\n if (weight < weights[ic1])\n iSwap = ic1;\n else\n break;\n }\n else {\n if (weight < weights[ic2])\n iSwap = ic2;\n else\n break;\n }\n weights[i] = weights[iSwap];\n indices[i] = indices[iSwap];\n isNew[i] = isNew[iSwap];\n i = iSwap;\n }\n weights[i] = weight;\n indices[i] = index;\n isNew[i] = flag;\n return 1;\n}\n/**\n * Build a heap of candidate neighbors for nearest neighbor descent. For\n * each vertex the candidate neighbors are any current neighbors, and any\n * vertices that have the vertex as one of their nearest neighbors.\n */\nexport function buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random) {\n const candidateNeighbors = makeHeap(nVertices, maxCandidates);\n for (let i = 0; i < nVertices; i++) {\n for (let j = 0; j < nNeighbors; j++) {\n if (currentGraph[0][i][j] < 0)\n continue;\n const idx = currentGraph[0][i][j];\n const isn = currentGraph[2][i][j];\n const d = utils.tauRand(random);\n heapPush(candidateNeighbors, i, d, idx, isn);\n heapPush(candidateNeighbors, idx, d, i, isn);\n currentGraph[2][i][j] = 0;\n }\n }\n return candidateNeighbors;\n}\n/**\n * Given an array of heaps (of indices and weights), unpack the heap\n * out to give and array of sorted lists of indices and weights by increasing\n * weight. This is effectively just the second half of heap sort (the first\n * half not being required since we already have the data in a heap).\n */\nexport function deheapSort(heap) {\n const indices = heap[0];\n const weights = heap[1];\n for (let i = 0; i < indices.length; i++) {\n const indHeap = indices[i];\n const distHeap = weights[i];\n for (let j = 0; j < indHeap.length - 1; j++) {\n const indHeapIndex = indHeap.length - j - 1;\n const distHeapIndex = distHeap.length - j - 1;\n const temp1 = indHeap[0];\n indHeap[0] = indHeap[indHeapIndex];\n indHeap[indHeapIndex] = temp1;\n const temp2 = distHeap[0];\n distHeap[0] = distHeap[distHeapIndex];\n distHeap[distHeapIndex] = temp2;\n siftDown(distHeap, indHeap, distHeapIndex, 0);\n }\n }\n return { indices, weights };\n}\n/**\n * Restore the heap property for a heap with an out of place element\n * at position ``elt``. This works with a heap pair where heap1 carries\n * the weights and heap2 holds the corresponding elements.\n */\nfunction siftDown(heap1, heap2, ceiling, elt) {\n while (elt * 2 + 1 < ceiling) {\n const leftChild = elt * 2 + 1;\n const rightChild = leftChild + 1;\n let swap = elt;\n if (heap1[swap] < heap1[leftChild])\n swap = leftChild;\n if (rightChild < ceiling && heap1[swap] < heap1[rightChild])\n swap = rightChild;\n if (swap === elt) {\n break;\n }\n else {\n const temp1 = heap1[elt];\n heap1[elt] = heap1[swap];\n heap1[swap] = temp1;\n const temp2 = heap2[elt];\n heap2[elt] = heap2[swap];\n heap2[swap] = temp2;\n elt = swap;\n }\n }\n}\n/**\n * Search the heap for the smallest element that is still flagged.\n */\nexport function smallestFlagged(heap, row) {\n const ind = heap[0][row];\n const dist = heap[1][row];\n const flag = heap[2][row];\n let minDist = Infinity;\n let resultIndex = -1;\n for (let i = 0; i > ind.length; i++) {\n if (flag[i] === 1 && dist[i] < minDist) {\n minDist = dist[i];\n resultIndex = i;\n }\n }\n if (resultIndex >= 0) {\n flag[resultIndex] = 0;\n return Math.floor(ind[resultIndex]);\n }\n else {\n return -1;\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"heap.js","sourceRoot":"","sources":["heap.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n *   list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n *   this list of conditions and the following disclaimer in the documentation\n *   and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n *   contributors may be used to endorse or promote products derived from\n *   this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport {RandomFn} from './umap';\nimport * as utils from './utils';\n\nexport type Heap = number[][][];\n\n/**\n *  Constructor for the heap objects. The heaps are used\n * for approximate nearest neighbor search, maintaining a list of potential\n * neighbors sorted by their distance. We also flag if potential neighbors\n * are newly added to the list or not. Internally this is stored as\n * a single array; the first axis determines whether we are looking at the\n * array of candidate indices, the array of distances, or the flag array for\n * whether elements are new or not. Each of these arrays are of shape\n * (``nPoints``, ``size``)\n */\nexport function makeHeap(nPoints: number, size: number): Heap {\n  const makeArrays = (fillValue: number) => {\n    return utils.empty(nPoints).map(() => {\n      return utils.filled(size, fillValue);\n    });\n  };\n\n  const heap: Heap = [];\n  heap.push(makeArrays(-1));\n  heap.push(makeArrays(Infinity));\n  heap.push(makeArrays(0));\n  return heap;\n}\n\n/**\n * Generate n_samples many integers from 0 to pool_size such that no\n * integer is selected twice. The duplication constraint is achieved via\n * rejection sampling.\n */\nexport function rejectionSample(\n  nSamples: number,\n  poolSize: number,\n  random: RandomFn\n) {\n  const result = utils.zeros(nSamples);\n  for (let i = 0; i < nSamples; i++) {\n    let rejectSample = true;\n    let j = 0;\n    while (rejectSample) {\n      j = utils.tauRandInt(poolSize, random);\n      let broken = false;\n      for (let k = 0; k < i; k++) {\n        if (j === result[k]) {\n          broken = true;\n          break;\n        }\n      }\n      if (!broken) rejectSample = false;\n    }\n    result[i] = j;\n  }\n  return result;\n}\n\n/**\n * Push a new element onto the heap. The heap stores potential neighbors\n * for each data point. The ``row`` parameter determines which data point we\n * are addressing, the ``weight`` determines the distance (for heap sorting),\n * the ``index`` is the element to add, and the flag determines whether this\n * is to be considered a new addition.\n */\nexport function heapPush(\n  heap: Heap,\n  row: number,\n  weight: number,\n  index: number,\n  flag: number\n): number {\n  row = Math.floor(row);\n  const indices = heap[0][row];\n  const weights = heap[1][row];\n  //const isNew = heap[2][row];\n\n  if (weight >= weights[0])\n    return 0;\n\n\n  // Break if we already have this element.\n  for (let i = 0; i < indices.length; i++) {\n    if (index === indices[i])\n      return 0;\n  }\n\n  return uncheckedHeapPush(heap, row, weight, index, flag);\n}\n\n/**\n * Push a new element onto the heap. The heap stores potential neighbors\n * for each data point. The ``row`` parameter determines which data point we\n * are addressing, the ``weight`` determines the distance (for heap sorting),\n * the ``index`` is the element to add, and the flag determines whether this\n * is to be considered a new addition.\n */\nexport function uncheckedHeapPush(\n  heap: Heap,\n  row: number,\n  weight: number,\n  index: number,\n  flag: number\n): number {\n  const indices = heap[0][row];\n  const weights = heap[1][row];\n  const isNew = heap[2][row];\n\n  if (weight >= weights[0])\n    return 0;\n\n\n  // Insert val at position zero\n  weights[0] = weight;\n  indices[0] = index;\n  isNew[0] = flag;\n\n  // Descend the heap, swapping values until the max heap criterion is met\n  let i = 0;\n  let iSwap = 0;\n  while (true) {\n    const ic1 = 2 * i + 1;\n    const ic2 = ic1 + 1;\n\n    const heapShape2 = heap[0][0].length;\n    if (ic1 >= heapShape2) {\n      break;\n    } else if (ic2 >= heapShape2) {\n      if (weights[ic1] > weight)\n        iSwap = ic1;\n      else\n        break;\n    } else if (weights[ic1] >= weights[ic2]) {\n      if (weight < weights[ic1])\n        iSwap = ic1;\n      else\n        break;\n    } else {\n      if (weight < weights[ic2])\n        iSwap = ic2;\n      else\n        break;\n    }\n\n    weights[i] = weights[iSwap];\n    indices[i] = indices[iSwap];\n    isNew[i] = isNew[iSwap];\n\n    i = iSwap;\n  }\n\n  weights[i] = weight;\n  indices[i] = index;\n  isNew[i] = flag;\n  return 1;\n}\n\n/**\n * Build a heap of candidate neighbors for nearest neighbor descent. For\n * each vertex the candidate neighbors are any current neighbors, and any\n * vertices that have the vertex as one of their nearest neighbors.\n */\nexport function buildCandidates(\n  currentGraph: Heap,\n  nVertices: number,\n  nNeighbors: number,\n  maxCandidates: number,\n  random: RandomFn\n) {\n  const candidateNeighbors = makeHeap(nVertices, maxCandidates);\n  for (let i = 0; i < nVertices; i++) {\n    for (let j = 0; j < nNeighbors; j++) {\n      if (currentGraph[0][i][j] < 0)\n        continue;\n\n      const idx = currentGraph[0][i][j];\n      const isn = currentGraph[2][i][j];\n      const d = utils.tauRand(random);\n      heapPush(candidateNeighbors, i, d, idx, isn);\n      heapPush(candidateNeighbors, idx, d, i, isn);\n      currentGraph[2][i][j] = 0;\n    }\n  }\n  return candidateNeighbors;\n}\n\n/**\n * Given an array of heaps (of indices and weights), unpack the heap\n * out to give and array of sorted lists of indices and weights by increasing\n * weight. This is effectively just the second half of heap sort (the first\n * half not being required since we already have the data in a heap).\n */\nexport function deheapSort(heap: Heap) {\n  const indices = heap[0];\n  const weights = heap[1];\n\n  for (let i = 0; i < indices.length; i++) {\n    const indHeap = indices[i];\n    const distHeap = weights[i];\n\n    for (let j = 0; j < indHeap.length - 1; j++) {\n      const indHeapIndex = indHeap.length - j - 1;\n      const distHeapIndex = distHeap.length - j - 1;\n\n      const temp1 = indHeap[0];\n      indHeap[0] = indHeap[indHeapIndex];\n      indHeap[indHeapIndex] = temp1;\n\n      const temp2 = distHeap[0];\n      distHeap[0] = distHeap[distHeapIndex];\n      distHeap[distHeapIndex] = temp2;\n\n      siftDown(distHeap, indHeap, distHeapIndex, 0);\n    }\n  }\n  return {indices, weights};\n}\n\n/**\n * Restore the heap property for a heap with an out of place element\n * at position ``elt``. This works with a heap pair where heap1 carries\n * the weights and heap2 holds the corresponding elements.\n */\nfunction siftDown(\n  heap1: number[],\n  heap2: number[],\n  ceiling: number,\n  elt: number\n) {\n  while (elt * 2 + 1 < ceiling) {\n    const leftChild = elt * 2 + 1;\n    const rightChild = leftChild + 1;\n    let swap = elt;\n\n    if (heap1[swap] < heap1[leftChild])\n      swap = leftChild;\n\n    if (rightChild < ceiling && heap1[swap] < heap1[rightChild])\n      swap = rightChild;\n\n\n    if (swap === elt) {\n      break;\n    } else {\n      const temp1 = heap1[elt];\n      heap1[elt] = heap1[swap];\n      heap1[swap] = temp1;\n\n      const temp2 = heap2[elt];\n      heap2[elt] = heap2[swap];\n      heap2[swap] = temp2;\n      elt = swap;\n    }\n  }\n}\n\n/**\n * Search the heap for the smallest element that is still flagged.\n */\nexport function smallestFlagged(heap: Heap, row: number) {\n  const ind = heap[0][row];\n  const dist = heap[1][row];\n  const flag = heap[2][row];\n\n  let minDist = Infinity;\n  let resultIndex = -1;\n\n  for (let i = 0; i > ind.length; i++) {\n    if (flag[i] === 1 && dist[i] < minDist) {\n      minDist = dist[i];\n      resultIndex = i;\n    }\n  }\n\n  if (resultIndex >= 0) {\n    flag[resultIndex] = 0;\n    return Math.floor(ind[resultIndex]);\n  } else {\n    return -1;\n  }\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\nimport * as utils from './utils';\n/**\n * Internal 2-dimensional sparse matrix class\n */\nexport class SparseMatrix {\n constructor(rows, cols, values, dims) {\n this.entries = new Map();\n this.nRows = 0;\n this.nCols = 0;\n if (rows.length !== cols.length || rows.length !== values.length) {\n throw new Error('rows, cols and values arrays must all have the same length');\n }\n // TODO: Assert that dims are legit.\n this.nRows = dims[0];\n this.nCols = dims[1];\n for (let i = 0; i < values.length; i++) {\n const row = rows[i];\n const col = cols[i];\n this.checkDims(row, col);\n const key = this.makeKey(row, col);\n this.entries.set(key, { value: values[i], row, col });\n }\n }\n makeKey(row, col) {\n return `${row}:${col}`;\n }\n checkDims(row, col) {\n const withinBounds = row < this.nRows && col < this.nCols;\n if (!withinBounds)\n throw new Error('row and/or col specified outside of matrix dimensions');\n }\n set(row, col, value) {\n this.checkDims(row, col);\n const key = this.makeKey(row, col);\n if (!this.entries.has(key))\n this.entries.set(key, { value, row, col });\n else\n this.entries.get(key).value = value;\n }\n get(row, col, defaultValue = 0) {\n //this.checkDims(row, col);\n const key = this.makeKey(row, col);\n if (this.entries.has(key))\n return this.entries.get(key).value;\n else\n return defaultValue;\n }\n getAll(ordered = true) {\n const rowColValues = new Array(this.entries.size).fill(null);\n let i = 0;\n this.entries.forEach((value) => {\n rowColValues[i++] = value;\n });\n if (ordered) {\n // Ordering the result isn't required for processing but it does make it easier to write tests\n rowColValues.sort((a, b) => {\n if (a.row === b.row)\n return a.col - b.col;\n else\n return a.row - b.row;\n });\n }\n return rowColValues;\n }\n getDims() {\n return [this.nRows, this.nCols];\n }\n getRows() {\n return Array.from(this.entries, ([_key, value]) => value.row);\n // return this.rows as unknown as number[];\n }\n getCols() {\n return Array.from(this.entries, ([_key, value]) => value.col);\n // return this.cols as unknown as number[];\n }\n getValues() {\n return Array.from(this.entries, ([_key, value]) => value.value);\n //return this.values as unknown as number[];\n }\n forEach(fn) {\n this.entries.forEach((value) => fn(value.value, value.row, value.col));\n }\n map(fn) {\n const vals = new Float32Array(this.entries.size);\n let i = 0;\n this.entries.forEach((value) => {\n vals[i++] = fn(value.value, value.row, value.col);\n });\n const dims = [this.nRows, this.nCols];\n return new SparseMatrix(this.getRows(), this.getCols(), vals, dims);\n }\n toArray() {\n const rows = utils.empty(this.nRows);\n const output = rows.map(() => {\n return utils.zeros(this.nCols);\n });\n this.entries.forEach((value) => {\n output[value.row][value.col] = value.value;\n });\n return output;\n }\n}\n/**\n * Transpose a sparse matrix\n */\nexport function transpose(matrix) {\n const oldRows = matrix.getRows();\n const oldCols = matrix.getCols();\n const oldVals = matrix.getValues();\n const matlen = oldCols.length;\n const cols = new Int32Array(matlen);\n const rows = new Int32Array(matlen);\n const vals = new Float32Array(matlen);\n cols.set(oldRows);\n rows.set(oldCols);\n vals.set(oldVals);\n const dims = [matrix.nCols, matrix.nRows];\n return new SparseMatrix(rows, cols, vals, dims);\n}\n/**\n * Construct a sparse identity matrix\n */\nexport function identity(size) {\n const [rows] = size;\n const matrix = new SparseMatrix([], [], [], size);\n for (let i = 0; i < rows; i++)\n matrix.set(i, i, 1);\n return matrix;\n}\n/**\n * Element-wise multiplication of two matrices\n */\nexport function pairwiseMultiply(a, b) {\n return elementWise(a, b, (x, y) => x * y);\n}\n/**\n * Element-wise addition of two matrices\n */\nexport function add(a, b) {\n return elementWise(a, b, (x, y) => x + y);\n}\n/**\n * Element-wise subtraction of two matrices\n */\nexport function subtract(a, b) {\n return elementWise(a, b, (x, y) => x - y);\n}\n/**\n * Element-wise maximum of two matrices\n */\nexport function maximum(a, b) {\n return elementWise(a, b, (x, y) => (x > y ? x : y));\n}\n/**\n * Scalar multiplication of two matrices\n */\nexport function multiplyScalar(a, scalar) {\n return a.map((value) => {\n return value * scalar;\n });\n}\n/**\n * Returns a new matrix with zero entries removed.\n */\nexport function eliminateZeros(m) {\n const zeroIndices = new Set();\n const values = m.getValues();\n const rows = m.getRows();\n const cols = m.getCols();\n for (let i = 0; i < values.length; i++) {\n if (values[i] === 0)\n zeroIndices.add(i);\n }\n const removeByZeroIndex = (_, index) => !zeroIndices.has(index);\n const nextValues = values.filter(removeByZeroIndex);\n const nextRows = rows.filter(removeByZeroIndex);\n const nextCols = cols.filter(removeByZeroIndex);\n return new SparseMatrix(nextRows, nextCols, nextValues, m.getDims());\n}\n/**\n * Normalization of a sparse matrix.\n */\nexport function normalize(m, normType = \"l2\" /* NormType.l2 */) {\n const normFn = normFns[normType];\n const colsByRow = new Map();\n m.forEach((_, row, col) => {\n const cols = colsByRow.get(row) || [];\n cols.push(col);\n colsByRow.set(row, cols);\n });\n const nextMatrix = new SparseMatrix([], [], [], m.getDims());\n for (const row of colsByRow.keys()) {\n const cols = colsByRow.get(row).sort();\n const vals = cols.map((col) => m.get(row, col));\n const norm = normFn(vals);\n for (let i = 0; i < norm.length; i++)\n nextMatrix.set(row, cols[i], norm[i]);\n }\n return nextMatrix;\n}\nconst normFns = {\n [\"max\" /* NormType.max */]: (xs) => {\n let max = -Infinity;\n for (let i = 0; i < xs.length; i++)\n max = xs[i] > max ? xs[i] : max;\n return xs.map((x) => x / max);\n },\n [\"l1\" /* NormType.l1 */]: (xs) => {\n let sum = 0;\n for (let i = 0; i < xs.length; i++)\n sum += xs[i];\n return xs.map((x) => x / sum);\n },\n [\"l2\" /* NormType.l2 */]: (xs) => {\n let sum = 0;\n for (let i = 0; i < xs.length; i++)\n sum += xs[i] ** 2;\n return xs.map((x) => Math.sqrt(x ** 2 / sum));\n },\n};\n/**\n * Helper function for element-wise operations.\n */\nfunction elementWise(a, b, op) {\n const visited = new Set();\n const rows = [];\n const cols = [];\n const vals = [];\n const operate = (row, col) => {\n rows.push(row);\n cols.push(col);\n const nextValue = op(a.get(row, col), b.get(row, col));\n vals.push(nextValue);\n };\n const valuesA = a.getValues();\n const rowsA = a.getRows();\n const colsA = a.getCols();\n for (let i = 0; i < valuesA.length; i++) {\n const row = rowsA[i];\n const col = colsA[i];\n const key = `${row}:${col}`;\n visited.add(key);\n operate(row, col);\n }\n const valuesB = b.getValues();\n const rowsB = b.getRows();\n const colsB = b.getCols();\n for (let i = 0; i < valuesB.length; i++) {\n const row = rowsB[i];\n const col = colsB[i];\n const key = `${row}:${col}`;\n if (visited.has(key))\n continue;\n operate(row, col);\n }\n const dims = [a.nRows, a.nCols];\n return new SparseMatrix(rows, cols, vals, dims);\n}\n/**\n * Helper function for getting data, indices, and inptr arrays from a sparse\n * matrix to follow csr matrix conventions. Super inefficient (and kind of\n * defeats the purpose of this convention) but a lot of the ported python tree\n * search logic depends on this data format.\n */\nexport function getCSR(x) {\n const entries = [];\n x.forEach((value, row, col) => {\n entries.push({ value, row, col });\n });\n entries.sort((a, b) => {\n if (a.row === b.row)\n return a.col - b.col;\n else\n return a.row - b.row;\n });\n const indices = [];\n const values = [];\n const indptr = [];\n let currentRow = -1;\n for (let i = 0; i < entries.length; i++) {\n const { row, col, value } = entries[i];\n if (row !== currentRow) {\n currentRow = row;\n indptr.push(i);\n }\n indices.push(col);\n values.push(value);\n }\n return { indices, values, indptr };\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matrix.js","sourceRoot":"","sources":["matrix.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\nimport * as utils from './utils';\n\ntype Entry = { value: number; row: number; col: number };\n\n/**\n * Internal 2-dimensional sparse matrix class\n */\nexport class SparseMatrix {\n  private entries = new Map<string, Entry>();\n\n  readonly nRows: number = 0;\n  readonly nCols: number = 0;\n\n  constructor(\n    rows: number[] | Int32Array,\n    cols: number[] | Int32Array,\n    values: number[] | Float32Array,\n    dims: number[]\n  ) {\n    if (rows.length !== cols.length || rows.length !== values.length) {\n      throw new Error(\n        'rows, cols and values arrays must all have the same length'\n      );\n    }\n\n    // TODO: Assert that dims are legit.\n    this.nRows = dims[0];\n    this.nCols = dims[1];\n    for (let i = 0; i < values.length; i++) {\n      const row = rows[i];\n      const col = cols[i];\n      this.checkDims(row, col);\n      const key = this.makeKey(row, col);\n      this.entries.set(key, {value: values[i], row, col});\n    }\n  }\n\n  private makeKey(row: number, col: number): string {\n    return `${row}:${col}`;\n  }\n\n  private checkDims(row: number, col: number) {\n    const withinBounds = row < this.nRows && col < this.nCols;\n    if (!withinBounds)\n      throw new Error('row and/or col specified outside of matrix dimensions');\n  }\n\n  set(row: number, col: number, value: number) {\n    this.checkDims(row, col);\n    const key = this.makeKey(row, col);\n    if (!this.entries.has(key))\n      this.entries.set(key, {value, row, col});\n    else\n      this.entries.get(key)!.value = value;\n  }\n\n  get(row: number, col: number, defaultValue = 0) {\n    //this.checkDims(row, col);\n    const key = this.makeKey(row, col);\n    if (this.entries.has(key))\n      return this.entries.get(key)!.value;\n    else\n      return defaultValue;\n  }\n\n  getAll(ordered = true): { value: number; row: number; col: number }[] {\n    const rowColValues: Entry[] = new Array(this.entries.size).fill(null);\n    let i = 0;\n    this.entries.forEach((value) => {\n      rowColValues[i++] = value;\n    });\n    if (ordered) {\n      // Ordering the result isn't required for processing but it does make it easier to write tests\n      rowColValues.sort((a, b) => {\n        if (a.row === b.row)\n          return a.col - b.col;\n        else\n          return a.row - b.row;\n      });\n    }\n    return rowColValues;\n  }\n\n  getDims(): number[] {\n    return [this.nRows, this.nCols];\n  }\n\n  getRows(): number[] {\n    return Array.from(this.entries, ([_key, value]) => value.row);\n    // return this.rows as unknown as number[];\n  }\n\n  getCols(): number[] {\n    return Array.from(this.entries, ([_key, value]) => value.col);\n    // return this.cols as unknown as number[];\n  }\n\n  getValues(): number[] {\n    return Array.from(this.entries, ([_key, value]) => value.value);\n  //return this.values as unknown as number[];\n  }\n\n  forEach(fn: (value: number, row: number, col: number) => void): void {\n    this.entries.forEach((value) => fn(value.value, value.row, value.col));\n  }\n\n  map(fn: (value: number, row: number, col: number) => number): SparseMatrix {\n    const vals = new Float32Array(this.entries.size);\n    let i = 0;\n    this.entries.forEach((value) => {\n      vals[i++] = fn(value.value, value.row, value.col);\n    });\n    const dims = [this.nRows, this.nCols];\n    return new SparseMatrix(this.getRows(), this.getCols(), vals as unknown as number[], dims);\n  }\n\n  toArray() {\n    const rows: undefined[] = utils.empty(this.nRows);\n    const output = rows.map(() => {\n      return utils.zeros(this.nCols);\n    });\n    this.entries.forEach((value) => {\n      output[value.row][value.col] = value.value;\n    });\n    return output;\n  }\n}\n\n/**\n * Transpose a sparse matrix\n */\nexport function transpose(matrix: SparseMatrix): SparseMatrix {\n  const oldRows = matrix.getRows();\n  const oldCols = matrix.getCols();\n  const oldVals = matrix.getValues();\n  const matlen = oldCols.length;\n  const cols = new Int32Array(matlen);\n  const rows = new Int32Array(matlen);\n  const vals = new Float32Array(matlen);\n\n  cols.set(oldRows);\n  rows.set(oldCols);\n  vals.set(oldVals);\n  const dims = [matrix.nCols, matrix.nRows];\n  return new SparseMatrix(rows, cols, vals, dims);\n}\n\n/**\n * Construct a sparse identity matrix\n */\nexport function identity(size: number[]): SparseMatrix {\n  const [rows] = size;\n  const matrix = new SparseMatrix([], [], [], size);\n  for (let i = 0; i < rows; i++)\n    matrix.set(i, i, 1);\n\n  return matrix;\n}\n\n/**\n * Element-wise multiplication of two matrices\n */\nexport function pairwiseMultiply(\n  a: SparseMatrix,\n  b: SparseMatrix\n): SparseMatrix {\n  return elementWise(a, b, (x, y) => x * y);\n}\n\n/**\n * Element-wise addition of two matrices\n */\nexport function add(a: SparseMatrix, b: SparseMatrix): SparseMatrix {\n  return elementWise(a, b, (x, y) => x + y);\n}\n\n/**\n * Element-wise subtraction of two matrices\n */\nexport function subtract(a: SparseMatrix, b: SparseMatrix): SparseMatrix {\n  return elementWise(a, b, (x, y) => x - y);\n}\n\n/**\n * Element-wise maximum of two matrices\n */\nexport function maximum(a: SparseMatrix, b: SparseMatrix): SparseMatrix {\n  return elementWise(a, b, (x, y) => (x > y ? x : y));\n}\n\n/**\n * Scalar multiplication of two matrices\n */\nexport function multiplyScalar(a: SparseMatrix, scalar: number): SparseMatrix {\n  return a.map((value: number) => {\n    return value * scalar;\n  });\n}\n\n/**\n * Returns a new matrix with zero entries removed.\n */\nexport function eliminateZeros(m: SparseMatrix) {\n  const zeroIndices = new Set();\n  const values = m.getValues();\n  const rows = m.getRows();\n  const cols = m.getCols();\n  for (let i = 0; i < values.length; i++) {\n    if (values[i] === 0)\n      zeroIndices.add(i);\n  }\n  const removeByZeroIndex = (_: any, index: number) => !zeroIndices.has(index);\n  const nextValues = values.filter(removeByZeroIndex);\n  const nextRows = rows.filter(removeByZeroIndex);\n  const nextCols = cols.filter(removeByZeroIndex);\n\n  return new SparseMatrix(nextRows, nextCols, nextValues, m.getDims());\n}\n\n/**\n * Normalization of a sparse matrix.\n */\nexport function normalize(m: SparseMatrix, normType = NormType.l2) {\n  const normFn = normFns[normType];\n\n  const colsByRow = new Map<number, number[]>();\n  m.forEach((_, row, col) => {\n    const cols = colsByRow.get(row) || [];\n    cols.push(col);\n    colsByRow.set(row, cols);\n  });\n\n  const nextMatrix = new SparseMatrix([], [], [], m.getDims());\n\n  for (const row of colsByRow.keys()) {\n    const cols = colsByRow.get(row)!.sort();\n\n    const vals = cols.map((col) => m.get(row, col));\n    const norm = normFn(vals);\n    for (let i = 0; i < norm.length; i++)\n      nextMatrix.set(row, cols[i], norm[i]);\n  }\n\n  return nextMatrix;\n}\n\n/**\n * Vector normalization functions\n */\ntype NormFns = { [key in NormType]: (v: number[]) => number[] };\nconst normFns: NormFns = {\n  [NormType.max]: (xs: number[]) => {\n    let max = -Infinity;\n    for (let i = 0; i < xs.length; i++)\n      max = xs[i] > max ? xs[i] : max;\n\n    return xs.map((x) => x / max);\n  },\n  [NormType.l1]: (xs: number[]) => {\n    let sum = 0;\n    for (let i = 0; i < xs.length; i++)\n      sum += xs[i];\n\n    return xs.map((x) => x / sum);\n  },\n  [NormType.l2]: (xs: number[]) => {\n    let sum = 0;\n    for (let i = 0; i < xs.length; i++)\n      sum += xs[i] ** 2;\n\n    return xs.map((x) => Math.sqrt(x ** 2 / sum));\n  },\n};\n\nexport const enum NormType {\n  max = 'max',\n  l1 = 'l1',\n  l2 = 'l2',\n}\n\n/**\n * Helper function for element-wise operations.\n */\nfunction elementWise(\n  a: SparseMatrix,\n  b: SparseMatrix,\n  op: (x: number, y: number) => number\n): SparseMatrix {\n  const visited = new Set<string>();\n  const rows: number[] = [];\n  const cols: number[] = [];\n  const vals: number[] = [];\n\n  const operate = (row: number, col: number) => {\n    rows.push(row);\n    cols.push(col);\n    const nextValue = op(a.get(row, col), b.get(row, col));\n    vals.push(nextValue);\n  };\n  const valuesA = a.getValues();\n  const rowsA = a.getRows();\n  const colsA = a.getCols();\n  for (let i = 0; i < valuesA.length; i++) {\n    const row = rowsA[i];\n    const col = colsA[i];\n    const key = `${row}:${col}`;\n    visited.add(key);\n    operate(row, col);\n  }\n\n  const valuesB = b.getValues();\n  const rowsB = b.getRows();\n  const colsB = b.getCols();\n  for (let i = 0; i < valuesB.length; i++) {\n    const row = rowsB[i];\n    const col = colsB[i];\n    const key = `${row}:${col}`;\n    if (visited.has(key)) continue;\n    operate(row, col);\n  }\n\n  const dims = [a.nRows, a.nCols];\n  return new SparseMatrix(rows, cols, vals, dims);\n}\n\n/**\n * Helper function for getting data, indices, and inptr arrays from a sparse\n * matrix to follow csr matrix conventions. Super inefficient (and kind of\n * defeats the purpose of this convention) but a lot of the ported python tree\n * search logic depends on this data format.\n */\nexport function getCSR(x: SparseMatrix) {\n  const entries: Entry[] = [];\n\n  x.forEach((value, row, col) => {\n    entries.push({value, row, col});\n  });\n\n  entries.sort((a, b) => {\n    if (a.row === b.row)\n      return a.col - b.col;\n    else\n      return a.row - b.row;\n  });\n\n  const indices: number[] = [];\n  const values: number[] = [];\n  const indptr: number[] = [];\n\n  let currentRow = -1;\n  for (let i = 0; i < entries.length; i++) {\n    const {row, col, value} = entries[i];\n    if (row !== currentRow) {\n      currentRow = row;\n      indptr.push(i);\n    }\n    indices.push(col);\n    values.push(value);\n  }\n\n  return {indices, values, indptr};\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n * contributors may be used to endorse or promote products derived from\n * this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\nimport * as utils from './utils';\nexport class FlatTree {\n constructor(hyperplanes, offsets, children, indices) {\n this.hyperplanes = hyperplanes;\n this.offsets = offsets;\n this.children = children;\n this.indices = indices;\n }\n}\n/**\n * Build a random projection forest with ``nTrees``.\n */\nexport function makeForest(data, nNeighbors, nTrees, random) {\n const leafSize = Math.max(10, nNeighbors);\n const trees = utils\n .range(nTrees)\n .map((_, i) => makeTree(data, leafSize, i, random));\n const forest = trees.map((tree) => flattenTree(tree, leafSize));\n return forest;\n}\n/**\n * Construct a random projection tree based on ``data`` with leaves\n * of size at most ``leafSize``\n */\nfunction makeTree(data, leafSize = 30, n, random) {\n const indices = utils.range(data.length);\n const tree = makeEuclideanTree(data, indices, leafSize, n, random);\n return tree;\n}\nfunction makeEuclideanTree(data, indices, leafSize = 30, q, random) {\n if (indices.length > leafSize) {\n const splitResults = euclideanRandomProjectionSplit(data, indices, random);\n const { indicesLeft, indicesRight, hyperplane, offset } = splitResults;\n const leftChild = makeEuclideanTree(data, indicesLeft, leafSize, q + 1, random);\n const rightChild = makeEuclideanTree(data, indicesRight, leafSize, q + 1, random);\n const node = { leftChild, rightChild, isLeaf: false, hyperplane, offset };\n return node;\n }\n else {\n const node = { indices, isLeaf: true };\n return node;\n }\n}\n/**\n * Given a set of ``indices`` for data points from ``data``, create\n * a random hyperplane to split the data, returning two arrays indices\n * that fall on either side of the hyperplane. This is the basis for a\n * random projection tree, which simply uses this splitting recursively.\n * This particular split uses euclidean distance to determine the hyperplane\n * and which side each data sample falls on.\n */\nfunction euclideanRandomProjectionSplit(data, indices, random) {\n //const dim = 1;\n // Select two random points, set the hyperplane between them\n const leftIndex = utils.tauRandInt(indices.length, random);\n let rightIndex = utils.tauRandInt(indices.length, random);\n rightIndex += leftIndex === rightIndex ? 1 : 0;\n rightIndex = rightIndex % indices.length;\n const left = indices[leftIndex];\n const right = indices[rightIndex];\n // Compute the normal vector to the hyperplane (the vector between the two\n // points) and the offset from the origin\n let hyperplaneOffset = 0;\n let hyperplaneVector = 0;\n hyperplaneVector = data[left] - data[right];\n hyperplaneOffset -=\n (hyperplaneVector * (data[left] + data[right])) / 2.0;\n // For each point compute the margin (project into normal vector)\n // If we are on lower side of the hyperplane put in one pile, otherwise\n // put it in the other pile (if we hit hyperplane on the nose, flip a coin)\n let nLeft = 0;\n let nRight = 0;\n const side = utils.zeros(indices.length);\n for (let i = 0; i < indices.length; i++) {\n let margin = hyperplaneOffset;\n margin += hyperplaneVector * data[indices[i]];\n if (margin === 0) {\n side[i] = utils.tauRandInt(2, random);\n if (side[i] === 0)\n nLeft += 1;\n else\n nRight += 1;\n }\n else if (margin > 0) {\n side[i] = 0;\n nLeft += 1;\n }\n else {\n side[i] = 1;\n nRight += 1;\n }\n }\n // Now that we have the counts, allocate arrays\n const indicesLeft = utils.zeros(nLeft);\n const indicesRight = utils.zeros(nRight);\n // Populate the arrays with indices according to which side they fell on\n nLeft = 0;\n nRight = 0;\n for (let i = 0; i < side.length; i++) {\n if (side[i] === 0) {\n indicesLeft[nLeft] = indices[i];\n nLeft += 1;\n }\n else {\n indicesRight[nRight] = indices[i];\n nRight += 1;\n }\n }\n return {\n indicesLeft,\n indicesRight,\n hyperplane: hyperplaneVector,\n offset: hyperplaneOffset,\n };\n}\nfunction flattenTree(tree, leafSize) {\n const nNodes = numNodes(tree);\n const nLeaves = numLeaves(tree);\n // TODO: Verify that sparse code is not relevant...\n const hyperplanes = utils\n .range(nNodes)\n .map(() => tree.hyperplane ? 1 : 0);\n const offsets = utils.zeros(nNodes);\n const children = utils.range(nNodes).map(() => [-1, -1]);\n const indices = utils\n .range(nLeaves)\n .map(() => utils.range(leafSize).map(() => -1));\n recursiveFlatten(tree, hyperplanes, offsets, children, indices, 0, 0);\n return new FlatTree(hyperplanes, offsets, children, indices);\n}\nfunction recursiveFlatten(tree, hyperplanes, offsets, children, indices, nodeNum, leafNum) {\n if (tree.isLeaf) {\n children[nodeNum][0] = -leafNum;\n // TODO: Triple check this operation corresponds to\n // indices[leafNum : tree.indices.shape[0]] = tree.indices\n indices[leafNum].splice(0, tree.indices.length, ...tree.indices);\n leafNum += 1;\n return { nodeNum, leafNum };\n }\n else {\n hyperplanes[nodeNum] = tree.hyperplane;\n offsets[nodeNum] = tree.offset;\n children[nodeNum][0] = nodeNum + 1;\n const oldNodeNum = nodeNum;\n let res = recursiveFlatten(tree.leftChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);\n nodeNum = res.nodeNum;\n leafNum = res.leafNum;\n children[oldNodeNum][1] = nodeNum + 1;\n res = recursiveFlatten(tree.rightChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);\n return { nodeNum: res.nodeNum, leafNum: res.leafNum };\n }\n}\nfunction numNodes(tree) {\n if (tree.isLeaf)\n return 1;\n else\n return 1 + numNodes(tree.leftChild) + numNodes(tree.rightChild);\n}\nfunction numLeaves(tree) {\n if (tree.isLeaf)\n return 1;\n else\n return numLeaves(tree.leftChild) + numLeaves(tree.rightChild);\n}\n/**\n * Generate an array of sets of candidate nearest neighbors by\n * constructing a random projection forest and taking the leaves of all the\n * trees. Any given tree has leaves that are a set of potential nearest\n * neighbors. Given enough trees the set of all such leaves gives a good\n * likelihood of getting a good set of nearest neighbors in composite. Since\n * such a random projection forest is inexpensive to compute, this can be a\n * useful means of seeding other nearest neighbor algorithms.\n */\nexport function makeLeafArray(rpForest) {\n if (rpForest.length > 0) {\n const output = [];\n for (const tree of rpForest)\n output.push(...tree.indices);\n return output;\n }\n else {\n return [[-1]];\n }\n}\n/**\n * Selects the side of the tree to search during flat tree search.\n */\nfunction selectSide(hyperplane, offset, point, random) {\n let margin = offset;\n margin += hyperplane * point;\n if (margin === 0) {\n const side = utils.tauRandInt(2, random);\n return side;\n }\n else if (margin > 0) {\n return 0;\n }\n else {\n return 1;\n }\n}\n/**\n * Searches a flattened rp-tree for a point.\n */\nexport function searchFlatTree(point, tree, random) {\n let node = 0;\n while (tree.children[node][0] > 0) {\n const side = selectSide(tree.hyperplanes[node], tree.offsets[node], point, random);\n if (side === 0)\n node = tree.children[node][0];\n else\n node = tree.children[node][1];\n }\n const index = -1 * tree.children[node][0];\n return tree.indices[index];\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["tree.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n *   list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n *   this list of conditions and the following disclaimer in the documentation\n *   and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n *   contributors may be used to endorse or promote products derived from\n *   this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport * as utils from './utils';\nimport {RandomFn, Vector} from './umap';\n\n/**\n * Tree functionality for approximating nearest neighbors\n */\ninterface RandomProjectionTreeNode {\n  isLeaf: boolean;\n  indices?: number[];\n  leftChild?: RandomProjectionTreeNode;\n  rightChild?: RandomProjectionTreeNode;\n  hyperplane?: number;\n  offset?: number;\n}\n\nexport class FlatTree {\n  constructor(\n    public hyperplanes: number[],\n    public offsets: number[],\n    public children: number[][],\n    public indices: number[][]\n  ) {}\n}\n\n/**\n * Build a random projection forest with ``nTrees``.\n */\nexport function makeForest(\n  data: Vector,\n  nNeighbors: number,\n  nTrees: number,\n  random: RandomFn\n) {\n  const leafSize = Math.max(10, nNeighbors);\n\n  const trees = utils\n    .range(nTrees)\n    .map((_, i) => makeTree(data, leafSize, i, random));\n  const forest = trees.map((tree) => flattenTree(tree, leafSize));\n\n  return forest;\n}\n\n/**\n * Construct a random projection tree based on ``data`` with leaves\n * of size at most ``leafSize``\n */\nfunction makeTree(\n  data: Vector,\n  leafSize = 30,\n  n: number,\n  random: RandomFn\n): RandomProjectionTreeNode {\n  const indices = utils.range(data.length);\n  const tree = makeEuclideanTree(data, indices, leafSize, n, random);\n  return tree;\n}\n\nfunction makeEuclideanTree(\n  data: Vector,\n  indices: number[],\n  leafSize = 30,\n  q: number,\n  random: RandomFn\n): RandomProjectionTreeNode {\n  if (indices.length > leafSize) {\n    const splitResults = euclideanRandomProjectionSplit(data, indices, random);\n    const {indicesLeft, indicesRight, hyperplane, offset} = splitResults;\n\n    const leftChild = makeEuclideanTree(\n      data,\n      indicesLeft,\n      leafSize,\n      q + 1,\n      random\n    );\n    const rightChild = makeEuclideanTree(\n      data,\n      indicesRight,\n      leafSize,\n      q + 1,\n      random\n    );\n\n    const node = {leftChild, rightChild, isLeaf: false, hyperplane, offset};\n    return node;\n  } else {\n    const node = {indices, isLeaf: true};\n    return node;\n  }\n}\n\n/**\n * Given a set of ``indices`` for data points from ``data``, create\n * a random hyperplane to split the data, returning two arrays indices\n * that fall on either side of the hyperplane. This is the basis for a\n * random projection tree, which simply uses this splitting recursively.\n * This particular split uses euclidean distance to determine the hyperplane\n * and which side each data sample falls on.\n */\nfunction euclideanRandomProjectionSplit(\n  data: Vector,\n  indices: number[],\n  random: RandomFn\n) {\n  //const dim = 1;\n\n  // Select two random points, set the hyperplane between them\n  const leftIndex = utils.tauRandInt(indices.length, random);\n  let rightIndex = utils.tauRandInt(indices.length, random);\n  rightIndex += leftIndex === rightIndex ? 1 : 0;\n  rightIndex = rightIndex % indices.length;\n  const left = indices[leftIndex];\n  const right = indices[rightIndex];\n\n  // Compute the normal vector to the hyperplane (the vector between the two\n  // points) and the offset from the origin\n  let hyperplaneOffset = 0;\n  let hyperplaneVector = 0;\n\n\n  hyperplaneVector = data[left] - data[right];\n  hyperplaneOffset -=\n    (hyperplaneVector * (data[left] + data[right])) / 2.0;\n\n\n  // For each point compute the margin (project into normal vector)\n  // If we are on lower side of the hyperplane put in one pile, otherwise\n  // put it in the other pile (if we hit hyperplane on the nose, flip a coin)\n  let nLeft = 0;\n  let nRight = 0;\n  const side = utils.zeros(indices.length);\n  for (let i = 0; i < indices.length; i++) {\n    let margin = hyperplaneOffset;\n\n    margin += hyperplaneVector * data[indices[i]];\n\n    if (margin === 0) {\n      side[i] = utils.tauRandInt(2, random);\n      if (side[i] === 0)\n        nLeft += 1;\n      else\n        nRight += 1;\n    } else if (margin > 0) {\n      side[i] = 0;\n      nLeft += 1;\n    } else {\n      side[i] = 1;\n      nRight += 1;\n    }\n  }\n\n  // Now that we have the counts, allocate arrays\n  const indicesLeft = utils.zeros(nLeft);\n  const indicesRight = utils.zeros(nRight);\n\n  // Populate the arrays with indices according to which side they fell on\n  nLeft = 0;\n  nRight = 0;\n  for (let i = 0; i < side.length; i++) {\n    if (side[i] === 0) {\n      indicesLeft[nLeft] = indices[i];\n      nLeft += 1;\n    } else {\n      indicesRight[nRight] = indices[i];\n      nRight += 1;\n    }\n  }\n\n  return {\n    indicesLeft,\n    indicesRight,\n    hyperplane: hyperplaneVector,\n    offset: hyperplaneOffset,\n  };\n}\n\nfunction flattenTree(tree: RandomProjectionTreeNode, leafSize: number) {\n  const nNodes = numNodes(tree);\n  const nLeaves = numLeaves(tree);\n\n  // TODO: Verify that sparse code is not relevant...\n  const hyperplanes = utils\n    .range(nNodes)\n    .map(() => tree.hyperplane ? 1 : 0);\n\n  const offsets = utils.zeros(nNodes);\n  const children = utils.range(nNodes).map(() => [-1, -1]);\n  const indices = utils\n    .range(nLeaves)\n    .map(() => utils.range(leafSize).map(() => -1));\n  recursiveFlatten(tree, hyperplanes, offsets, children, indices, 0, 0);\n  return new FlatTree(hyperplanes, offsets, children, indices);\n}\n\nfunction recursiveFlatten(\n  tree: RandomProjectionTreeNode,\n  hyperplanes: number[],\n  offsets: number[],\n  children: number[][],\n  indices: number[][],\n  nodeNum: number,\n  leafNum: number\n): { nodeNum: number; leafNum: number } {\n  if (tree.isLeaf) {\n    children[nodeNum][0] = -leafNum;\n\n    // TODO: Triple check this operation corresponds to\n    // indices[leafNum : tree.indices.shape[0]] = tree.indices\n    indices[leafNum].splice(0, tree.indices!.length, ...tree.indices!);\n    leafNum += 1;\n    return {nodeNum, leafNum};\n  } else {\n    hyperplanes[nodeNum] = tree.hyperplane!;\n    offsets[nodeNum] = tree.offset!;\n    children[nodeNum][0] = nodeNum + 1;\n    const oldNodeNum = nodeNum;\n\n    let res = recursiveFlatten(\n      tree.leftChild!,\n      hyperplanes,\n      offsets,\n      children,\n      indices,\n      nodeNum + 1,\n      leafNum\n    );\n    nodeNum = res.nodeNum;\n    leafNum = res.leafNum;\n\n    children[oldNodeNum][1] = nodeNum + 1;\n\n    res = recursiveFlatten(\n      tree.rightChild!,\n      hyperplanes,\n      offsets,\n      children,\n      indices,\n      nodeNum + 1,\n      leafNum\n    );\n    return {nodeNum: res.nodeNum, leafNum: res.leafNum};\n  }\n}\n\nfunction numNodes(tree: RandomProjectionTreeNode): number {\n  if (tree.isLeaf)\n    return 1;\n  else\n    return 1 + numNodes(tree.leftChild!) + numNodes(tree.rightChild!);\n}\n\nfunction numLeaves(tree: RandomProjectionTreeNode): number {\n  if (tree.isLeaf)\n    return 1;\n  else\n    return numLeaves(tree.leftChild!) + numLeaves(tree.rightChild!);\n}\n\n/**\n * Generate an array of sets of candidate nearest neighbors by\n * constructing a random projection forest and taking the leaves of all the\n * trees. Any given tree has leaves that are a set of potential nearest\n * neighbors. Given enough trees the set of all such leaves gives a good\n * likelihood of getting a good set of nearest neighbors in composite. Since\n * such a random projection forest is inexpensive to compute, this can be a\n * useful means of seeding other nearest neighbor algorithms.\n */\nexport function makeLeafArray(rpForest: FlatTree[]): number[][] {\n  if (rpForest.length > 0) {\n    const output: number[][] = [];\n    for (const tree of rpForest)\n      output.push(...tree.indices!);\n\n    return output;\n  } else {\n    return [[-1]];\n  }\n}\n\n/**\n * Selects the side of the tree to search during flat tree search.\n */\nfunction selectSide(\n  hyperplane: number,\n  offset: number,\n  point: number,\n  random: RandomFn\n) {\n  let margin = offset;\n\n  margin += hyperplane * point;\n\n\n  if (margin === 0) {\n    const side = utils.tauRandInt(2, random);\n    return side;\n  } else if (margin > 0) {\n    return 0;\n  } else {\n    return 1;\n  }\n}\n\n/**\n * Searches a flattened rp-tree for a point.\n */\nexport function searchFlatTree(\n  point: number,\n  tree: FlatTree,\n  random: RandomFn\n) {\n  let node = 0;\n  while (tree.children[node][0] > 0) {\n    const side = selectSide(\n      tree.hyperplanes[node],\n      tree.offsets[node],\n      point,\n      random\n    );\n    if (side === 0)\n      node = tree.children[node][0];\n    else\n      node = tree.children[node][1];\n  }\n\n  const index = -1 * tree.children[node][0];\n  return tree.indices[index];\n}\n"]}","const toString = Object.prototype.toString;\n\nexport default function isAnyArray(object) {\n return toString.call(object).endsWith('Array]');\n}\n","/**\n * Calculate current error\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} parameters - Array of current parameter values\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {number}\n */\nexport default function errorCalculation(\n data,\n parameters,\n parameterizedFunction,\n) {\n let error = 0;\n const func = parameterizedFunction(parameters);\n\n for (let i = 0; i < data.x.length; i++) {\n error += Math.abs(data.y[i] - func(data.x[i]));\n }\n\n return error;\n}\n","import { inverse, Matrix } from 'ml-matrix';\n\n/**\n * Difference of the matrix function over the parameters\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} evaluatedData - Array of previous evaluated function values\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} gradientDifference - Adjustment for decrease the damping parameter\n * @param {function} paramFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Matrix}\n */\nfunction gradientFunction(\n data,\n evaluatedData,\n params,\n gradientDifference,\n paramFunction,\n) {\n const n = params.length;\n const m = data.x.length;\n\n let ans = new Array(n);\n\n for (let param = 0; param < n; param++) {\n ans[param] = new Array(m);\n let auxParams = params.slice();\n auxParams[param] += gradientDifference;\n let funcParam = paramFunction(auxParams);\n\n for (let point = 0; point < m; point++) {\n ans[param][point] = evaluatedData[point] - funcParam(data.x[point]);\n }\n }\n return new Matrix(ans);\n}\n\n/**\n * Matrix function over the samples\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} evaluatedData - Array of previous evaluated function values\n * @return {Matrix}\n */\nfunction matrixFunction(data, evaluatedData) {\n const m = data.x.length;\n\n let ans = new Array(m);\n\n for (let point = 0; point < m; point++) {\n ans[point] = [data.y[point] - evaluatedData[point]];\n }\n\n return new Matrix(ans);\n}\n\n/**\n * Iteration for Levenberg-Marquardt\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} damping - Levenberg-Marquardt parameter\n * @param {number} gradientDifference - Adjustment for decrease the damping parameter\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Array<number>}\n */\nexport default function step(\n data,\n params,\n damping,\n gradientDifference,\n parameterizedFunction,\n) {\n let value = damping * gradientDifference * gradientDifference;\n let identity = Matrix.eye(params.length, params.length, value);\n\n const func = parameterizedFunction(params);\n\n let evaluatedData = new Float64Array(data.x.length);\n for (let i = 0; i < data.x.length; i++) {\n evaluatedData[i] = func(data.x[i]);\n }\n\n let gradientFunc = gradientFunction(\n data,\n evaluatedData,\n params,\n gradientDifference,\n parameterizedFunction,\n );\n let matrixFunc = matrixFunction(data, evaluatedData);\n let inverseMatrix = inverse(\n identity.add(gradientFunc.mmul(gradientFunc.transpose())),\n );\n\n params = new Matrix([params]);\n params = params.sub(\n inverseMatrix\n .mmul(gradientFunc)\n .mmul(matrixFunc)\n .mul(gradientDifference)\n .transpose(),\n );\n\n return params.to1DArray();\n}\n","/* eslint-disable max-len */\n/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n * contributors may be used to endorse or promote products derived from\n * this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\nimport * as heap from './heap';\nimport * as matrix from './matrix';\nimport * as nnDescent from './nn_descent';\nimport * as tree from './tree';\nimport * as utils from './utils';\nimport LM from 'ml-levenberg-marquardt';\nconst SMOOTH_K_TOLERANCE = 1e-5;\nconst MIN_K_DIST_SCALE = 1e-3;\n/**\n * UMAP projection system, based on the python implementation from McInnes, L,\n * Healy, J, UMAP: Uniform Manifold Approximation and Projection for Dimension\n * Reduction (https://github.com/lmcinnes/umap).\n *\n * This implementation differs in a few regards:\n * a) The initialization of the embedding for optimization is not computed using\n * a spectral method, rather it is initialized randomly. This avoids some\n * computationally intensive matrix eigen computations that aren't easily\n * ported to JavaScript.\n * b) A lot of \"extra\" functionality has been omitted from this implementation,\n * most notably a great deal of alternate distance functions.\n *\n * This implementation provides three methods of reducing dimensionality:\n * 1) fit: fit the data synchronously\n * 2) fitAsync: fit the data asynchronously, with a callback function provided\n * that is invoked on each optimization step.\n * 3) initializeFit / step: manually initialize the algorithm then explictly\n * step through each epoch of the SGD optimization\n */\nexport class UMAP {\n get neighbors() {\n return this.nNeighbors;\n }\n constructor(params = {}) {\n this.learningRate = 1.0;\n this.localConnectivity = 1.0;\n this.minDist = 0.1;\n this.nComponents = 2;\n this.nEpochs = 0;\n this.nNeighbors = 15;\n this.negativeSampleRate = 5;\n this.random = Math.random;\n this.repulsionStrength = 1.0;\n this.setOpMixRatio = 1.0;\n this.spread = 1.0;\n this.transformQueueSize = 4.0;\n // Supervised projection params\n this.targetMetric = \"categorical\" /* TargetMetric.categorical */;\n this.targetWeight = 0.5;\n this.targetNNeighbors = 15;\n this.distanceFn = numeric;\n this.isInitialized = false;\n this.rpForest = [];\n // Projected embedding\n this.embedding = [];\n this.optimizationState = new OptimizationState();\n const setParam = (key) => {\n //@ts-ignore\n if (params[key] !== undefined)\n this[key] = params[key];\n };\n setParam('distanceFn');\n setParam('learningRate');\n setParam('localConnectivity');\n setParam('minDist');\n setParam('nComponents');\n setParam('nEpochs');\n setParam('nNeighbors');\n setParam('negativeSampleRate');\n setParam('random');\n setParam('repulsionStrength');\n setParam('setOpMixRatio');\n setParam('spread');\n setParam('transformQueueSize');\n this.targetNNeighbors = params.nNeighbors || this.nNeighbors || this.targetNNeighbors;\n }\n /**\n * Fit the data to a projected embedding space synchronously.\n */\n fit(X) {\n this.initializeFit(X);\n this.optimizeLayout();\n return this.embedding;\n }\n /**\n * Fit the data to a projected embedding space asynchronously, with a callback\n * function invoked on every epoch of optimization.\n */\n async fitAsync(X, callback = () => true) {\n this.initializeFit(X);\n await this.optimizeLayoutAsync(callback);\n return this.embedding;\n }\n /**\n * Initializes parameters needed for supervised projection.\n */\n setSupervisedProjection(Y, params = {}) {\n this.Y = Y;\n this.targetMetric = params.targetMetric || this.targetMetric;\n this.targetWeight = params.targetWeight || this.targetWeight;\n this.targetNNeighbors = params.targetNNeighbors || this.targetNNeighbors;\n }\n /**\n * Initializes umap with precomputed KNN indices and distances.\n */\n setPrecomputedKNN(knnIndices, knnDistances) {\n this.knnIndices = knnIndices;\n this.knnDistances = knnDistances;\n }\n /**\n * Initializes fit by computing KNN and a fuzzy simplicial set, as well as\n * initializing the projected embeddings. Sets the optimization state ahead\n * of optimization steps. Returns the number of epochs to be used for the\n * SGD optimization.\n */\n initializeFit(X) {\n if (X.length <= this.nNeighbors)\n throw new Error(`Not enough data points (${X.length}) to create nNeighbors: ${this.nNeighbors}. Add more data points or adjust the configuration.`);\n // We don't need to reinitialize if we've already initialized for this data.\n if (this.X === X && this.isInitialized)\n return this.getNEpochs();\n this.X = X;\n if (!this.knnIndices && !this.knnDistances) {\n const knnResults = this.nearestNeighbors(X);\n this.knnIndices = knnResults.knnIndices;\n this.knnDistances = knnResults.knnDistances;\n }\n this.graph = this.fuzzySimplicialSet(X, this.nNeighbors, this.setOpMixRatio);\n // Set up the search graph for subsequent transformation.\n this.makeSearchFns();\n this.searchGraph = this.makeSearchGraph(X);\n // Check if supervised projection, then adjust the graph.\n this.processGraphForSupervisedProjection();\n const { head, tail, epochsPerSample, } = this.initializeSimplicialSetEmbedding();\n // Set the optimization routine state\n this.optimizationState.head = head;\n this.optimizationState.tail = tail;\n this.optimizationState.epochsPerSample = epochsPerSample;\n // Now, initialize the optimization steps\n this.initializeOptimization();\n this.prepareForOptimizationLoop();\n this.isInitialized = true;\n return this.getNEpochs();\n }\n makeSearchFns() {\n const { initFromTree, initFromRandom } = nnDescent.makeInitializations(this.distanceFn);\n this.initFromTree = initFromTree;\n this.initFromRandom = initFromRandom;\n this.search = nnDescent.makeInitializedNNSearch(this.distanceFn);\n }\n makeSearchGraph(X) {\n const knnIndices = this.knnIndices;\n const knnDistances = this.knnDistances;\n const dims = [X.length, X.length];\n const searchGraph = new matrix.SparseMatrix([], [], [], dims);\n for (let i = 0; i < knnIndices.length; i++) {\n const knn = knnIndices[i];\n const distances = knnDistances[i];\n for (let j = 0; j < knn.length; j++) {\n const neighbor = knn[j];\n const distance = distances[j];\n if (distance > 0)\n searchGraph.set(i, neighbor, distance);\n }\n }\n const transpose = matrix.transpose(searchGraph);\n return matrix.maximum(searchGraph, transpose);\n }\n /**\n * Transforms data to the existing embedding space.\n */\n transform(toTransform) {\n // Use the previous rawData\n const rawData = this.X;\n if (rawData === undefined || rawData.length === 0)\n throw new Error('No data has been fit.');\n let nNeighbors = Math.floor(this.nNeighbors * this.transformQueueSize);\n nNeighbors = Math.min(rawData.length, nNeighbors);\n const init = nnDescent.initializeSearch(this.rpForest, rawData, toTransform, nNeighbors, this.initFromRandom, this.initFromTree, this.random);\n const result = this.search(rawData, this.searchGraph, init, toTransform);\n let { indices, weights: distances } = heap.deheapSort(result);\n indices = indices.map((x) => x.slice(0, this.nNeighbors));\n distances = distances.map((x) => x.slice(0, this.nNeighbors));\n const adjustedLocalConnectivity = Math.max(0, this.localConnectivity - 1);\n const { sigmas, rhos } = this.smoothKNNDistance(distances, this.nNeighbors, adjustedLocalConnectivity);\n const { rows, cols, vals } = this.computeMembershipStrengths(indices, distances, sigmas, rhos);\n const size = [toTransform.length, rawData.length];\n let graph = new matrix.SparseMatrix(rows, cols, vals, size);\n // This was a very specially constructed graph with constant degree.\n // That lets us do fancy unpacking by reshaping the csr matrix indices\n // and data. Doing so relies on the constant degree assumption!\n const normed = matrix.normalize(graph, \"l1\" /* matrix.NormType.l1 */);\n const csrMatrix = matrix.getCSR(normed);\n const nPoints = toTransform.length;\n const eIndices = utils.reshape2d(csrMatrix.indices, nPoints, this.nNeighbors);\n const eWeights = utils.reshape2d(csrMatrix.values, nPoints, this.nNeighbors);\n const embedding = initTransform(eIndices, eWeights, this.embedding);\n const nEpochs = this.nEpochs ?\n this.nEpochs / 3 :\n graph.nRows <= 10000 ?\n 100 :\n 30;\n const graphMax = graph\n .getValues()\n .reduce((max, val) => (val > max ? val : max), 0);\n graph = graph.map((value) => (value < graphMax / nEpochs ? 0 : value));\n graph = matrix.eliminateZeros(graph);\n const epochsPerSample = this.makeEpochsPerSample(graph.getValues(), nEpochs);\n const head = graph.getRows();\n const tail = graph.getCols();\n // Initialize optimization slightly differently than the fit method.\n this.assignOptimizationStateParameters({\n headEmbedding: embedding,\n tailEmbedding: this.embedding,\n head,\n tail,\n currentEpoch: 0,\n nEpochs,\n nVertices: graph.getDims()[1],\n epochsPerSample,\n });\n this.prepareForOptimizationLoop();\n return this.optimizeLayout();\n }\n /**\n * Checks if we're using supervised projection, then process the graph\n * accordingly.\n */\n processGraphForSupervisedProjection() {\n const { Y, X } = this;\n if (Y) {\n if (Y.length !== X.length)\n throw new Error('Length of X and y must be equal');\n if (this.targetMetric === \"categorical\" /* TargetMetric.categorical */) {\n const lt = this.targetWeight < 1.0;\n const farDist = lt ? 2.5 * (1.0 / (1.0 - this.targetWeight)) : 1.0e12;\n this.graph = this.categoricalSimplicialSetIntersection(this.graph, Y, farDist);\n }\n // TODO (andycoenen@): add non-categorical supervised embeddings.\n }\n }\n /**\n * Manually step through the optimization process one epoch at a time.\n */\n step() {\n const { currentEpoch } = this.optimizationState;\n if (currentEpoch < this.getNEpochs())\n this.optimizeLayoutStep(currentEpoch);\n return this.optimizationState.currentEpoch;\n }\n /**\n * Returns the computed projected embedding.\n */\n getEmbedding() {\n return this.embedding;\n }\n /**\n * Compute the ``nNeighbors`` nearest points for each data point in ``X``\n * This may be exact, but more likely is approximated via nearest neighbor\n * descent.\n */\n nearestNeighbors(X) {\n const { distanceFn, nNeighbors } = this;\n const log2 = (n) => Math.log(n) / Math.log(2);\n const metricNNDescent = nnDescent.makeNNDescent(distanceFn, this.random);\n // Handle python3 rounding down from 0.5 discrpancy\n const round = (n) => {\n return n === 0.5 ? 0 : Math.round(n);\n };\n const nTrees = 5 + Math.floor(round(X.length ** 0.5 / 20.0));\n const nIters = Math.max(5, Math.floor(Math.round(log2(X.length))));\n this.rpForest = tree.makeForest(X, nNeighbors, nTrees, this.random);\n const leafArray = tree.makeLeafArray(this.rpForest);\n const { indices, weights } = metricNNDescent(X, leafArray, nNeighbors, nIters);\n return { knnIndices: indices, knnDistances: weights };\n }\n /**\n * Given a set of data X, a neighborhood size, and a measure of distance\n * compute the fuzzy simplicial set (here represented as a fuzzy graph in\n * the form of a sparse matrix) associated to the data. This is done by\n * locally approximating geodesic distance at each point, creating a fuzzy\n * simplicial set for each such point, and then combining all the local\n * fuzzy simplicial sets into a global one via a fuzzy union.\n */\n fuzzySimplicialSet(X, nNeighbors, setOpMixRatio = 1.0) {\n const { knnIndices = [], knnDistances = [], localConnectivity } = this;\n const { sigmas, rhos } = this.smoothKNNDistance(knnDistances, nNeighbors, localConnectivity);\n const { rows, cols, vals } = this.computeMembershipStrengths(knnIndices, knnDistances, sigmas, rhos);\n const size = [X.length, X.length];\n const sparseMatrix = new matrix.SparseMatrix(rows, cols, vals, size);\n const transpose = matrix.transpose(sparseMatrix);\n const prodMatrix = matrix.pairwiseMultiply(sparseMatrix, transpose);\n const a = matrix.subtract(matrix.add(sparseMatrix, transpose), prodMatrix);\n const b = matrix.multiplyScalar(a, setOpMixRatio);\n const c = matrix.multiplyScalar(prodMatrix, 1.0 - setOpMixRatio);\n const result = matrix.add(b, c);\n return result;\n }\n /**\n * Combine a fuzzy simplicial set with another fuzzy simplicial set\n * generated from categorical data using categorical distances. The target\n * data is assumed to be categorical label data (a vector of labels),\n * and this will update the fuzzy simplicial set to respect that label data.\n */\n categoricalSimplicialSetIntersection(simplicialSet, target, farDist, unknownDist = 1.0) {\n let intersection = fastIntersection(simplicialSet, target, unknownDist, farDist);\n intersection = matrix.eliminateZeros(intersection);\n return resetLocalConnectivity(intersection);\n }\n /**\n * Compute a continuous version of the distance to the kth nearest\n * neighbor. That is, this is similar to knn-distance but allows continuous\n * k values rather than requiring an integral k. In esscence we are simply\n * computing the distance such that the cardinality of fuzzy set we generate\n * is k.\n */\n smoothKNNDistance(distances, k, localConnectivity = 1.0, nIter = 64, bandwidth = 1.0) {\n const target = (Math.log(k) / Math.log(2)) * bandwidth;\n const rho = utils.zeros(distances.length);\n const result = utils.zeros(distances.length);\n for (let i = 0; i < distances.length; i++) {\n let lo = 0.0;\n let hi = Infinity;\n let mid = 1.0;\n // TODO: This is very inefficient, but will do for now. FIXME\n const ithDistances = distances[i];\n const nonZeroDists = ithDistances.filter((d) => d > 0.0);\n if (nonZeroDists.length >= localConnectivity) {\n const index = Math.floor(localConnectivity);\n const interpolation = localConnectivity - index;\n if (index > 0) {\n rho[i] = nonZeroDists[index - 1];\n if (interpolation > SMOOTH_K_TOLERANCE) {\n rho[i] +=\n interpolation * (nonZeroDists[index] - nonZeroDists[index - 1]);\n }\n }\n else {\n rho[i] = interpolation * nonZeroDists[0];\n }\n }\n else if (nonZeroDists.length > 0) {\n rho[i] = utils.max(nonZeroDists);\n }\n for (let n = 0; n < nIter; n++) {\n let psum = 0.0;\n for (let j = 1; j < distances[i].length; j++) {\n const d = distances[i][j] - rho[i];\n if (d > 0)\n psum += Math.exp(-(d / mid));\n else\n psum += 1.0;\n }\n if (Math.abs(psum - target) < SMOOTH_K_TOLERANCE)\n break;\n if (psum > target) {\n hi = mid;\n mid = (lo + hi) / 2.0;\n }\n else {\n lo = mid;\n if (hi === Infinity)\n mid *= 2;\n else\n mid = (lo + hi) / 2.0;\n }\n }\n result[i] = mid;\n // TODO: This is very inefficient, but will do for now. FIXME\n if (rho[i] > 0.0) {\n const meanIthDistances = utils.mean(ithDistances);\n if (result[i] < MIN_K_DIST_SCALE * meanIthDistances)\n result[i] = MIN_K_DIST_SCALE * meanIthDistances;\n }\n else {\n const meanDistances = utils.mean(distances.map(utils.mean));\n if (result[i] < MIN_K_DIST_SCALE * meanDistances)\n result[i] = MIN_K_DIST_SCALE * meanDistances;\n }\n }\n return { sigmas: result, rhos: rho };\n }\n /**\n * Construct the membership strength data for the 1-skeleton of each local\n * fuzzy simplicial set -- this is formed as a sparse matrix where each row is\n * a local fuzzy simplicial set, with a membership strength for the\n * 1-simplex to each other data point.\n */\n computeMembershipStrengths(knnIndices, knnDistances, sigmas, rhos) {\n const nSamples = knnIndices.length;\n const nNeighbors = knnIndices[0].length;\n const rows = utils.zeros(nSamples * nNeighbors);\n const cols = utils.zeros(nSamples * nNeighbors);\n const vals = utils.zeros(nSamples * nNeighbors);\n for (let i = 0; i < nSamples; i++) {\n for (let j = 0; j < nNeighbors; j++) {\n let val = 0;\n if (knnIndices[i][j] === -1)\n continue; // We didn't get the full knn for i\n if (knnIndices[i][j] === i)\n val = 0.0;\n else if (knnDistances[i][j] - rhos[i] <= 0.0)\n val = 1.0;\n else\n val = Math.exp(-((knnDistances[i][j] - rhos[i]) / sigmas[i]));\n rows[i * nNeighbors + j] = i;\n cols[i * nNeighbors + j] = knnIndices[i][j];\n vals[i * nNeighbors + j] = val;\n }\n }\n return { rows, cols, vals };\n }\n /**\n * Initialize a fuzzy simplicial set embedding, using a specified\n * initialisation method and then minimizing the fuzzy set cross entropy\n * between the 1-skeletons of the high and low dimensional fuzzy simplicial\n * sets.\n */\n initializeSimplicialSetEmbedding() {\n const nEpochs = this.getNEpochs();\n const { nComponents } = this;\n const graphValues = this.graph.getValues();\n let graphMax = 0;\n for (let i = 0; i < graphValues.length; i++) {\n const value = graphValues[i];\n if (graphMax < graphValues[i])\n graphMax = value;\n }\n const graph = this.graph.map((value) => {\n if (value < graphMax / nEpochs)\n return 0;\n else\n return value;\n });\n // We're not computing the spectral initialization in this implementation\n // until we determine a better eigenvalue/eigenvector computation\n // approach\n this.embedding = utils.zeros(graph.nRows).map(() => {\n return utils.zeros(nComponents).map(() => {\n return utils.tauRand(this.random) * 20 + -10; // Random from -10 to 10\n });\n });\n // Get graph data in ordered way...\n const weights = [];\n const head = [];\n const tail = [];\n const rowColValues = graph.getAll();\n for (let i = 0; i < rowColValues.length; i++) {\n const entry = rowColValues[i];\n if (entry.value) {\n weights.push(entry.value);\n tail.push(entry.row);\n head.push(entry.col);\n }\n }\n const epochsPerSample = this.makeEpochsPerSample(weights, nEpochs);\n return { head, tail, epochsPerSample };\n }\n /**\n * Given a set of weights and number of epochs generate the number of\n * epochs per sample for each weight.\n */\n makeEpochsPerSample(weights, nEpochs) {\n const result = utils.filled(weights.length, -1.0);\n const max = utils.max(weights);\n const nSamples = weights.map((w) => (w / max) * nEpochs);\n nSamples.forEach((n, i) => {\n if (n > 0)\n result[i] = nEpochs / nSamples[i];\n });\n return result;\n }\n /**\n * Assigns optimization state parameters from a partial optimization state.\n */\n assignOptimizationStateParameters(state) {\n Object.assign(this.optimizationState, state);\n }\n /**\n * Sets a few optimization state parameters that are necessary before entering\n * the optimization step loop.\n */\n prepareForOptimizationLoop() {\n // Hyperparameters\n const { repulsionStrength, learningRate, negativeSampleRate } = this;\n const { epochsPerSample, headEmbedding, tailEmbedding, } = this.optimizationState;\n const dim = headEmbedding[0].length;\n const moveOther = headEmbedding.length === tailEmbedding.length;\n const epochsPerNegativeSample = epochsPerSample.map((e) => e / negativeSampleRate);\n const epochOfNextNegativeSample = [...epochsPerNegativeSample];\n const epochOfNextSample = [...epochsPerSample];\n this.assignOptimizationStateParameters({\n epochOfNextSample,\n epochOfNextNegativeSample,\n epochsPerNegativeSample,\n moveOther,\n initialAlpha: learningRate,\n alpha: learningRate,\n gamma: repulsionStrength,\n dim,\n });\n }\n /**\n * Initializes optimization state for stepwise optimization.\n */\n initializeOptimization() {\n // Algorithm state\n const headEmbedding = this.embedding;\n const tailEmbedding = this.embedding;\n // Initialized in initializeSimplicialSetEmbedding()\n const { head, tail, epochsPerSample } = this.optimizationState;\n const nEpochs = this.getNEpochs();\n const nVertices = this.graph.nCols;\n const { a, b } = findABParams(this.spread, this.minDist);\n this.assignOptimizationStateParameters({\n headEmbedding,\n tailEmbedding,\n head,\n tail,\n epochsPerSample,\n a,\n b,\n nEpochs,\n nVertices,\n });\n }\n /**\n * Improve an embedding using stochastic gradient descent to minimize the\n * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n * and low dimensional fuzzy simplicial sets. In practice this is done by\n * sampling edges based on their membership strength (with the (1-p) terms\n * coming from negative sampling similar to word2vec).\n */\n optimizeLayoutStep(n) {\n const { optimizationState } = this;\n const { head, tail, headEmbedding, tailEmbedding, epochsPerSample, epochOfNextSample, epochOfNextNegativeSample, epochsPerNegativeSample, moveOther, initialAlpha, alpha, gamma, a, b, dim, nEpochs, nVertices, } = optimizationState;\n const clipValue = 4.0;\n for (let i = 0; i < epochsPerSample.length; i++) {\n if (epochOfNextSample[i] > n)\n continue;\n const j = head[i];\n const k = tail[i];\n const current = headEmbedding[j];\n const other = tailEmbedding[k];\n const distSquared = rDist(current, other);\n let gradCoeff = 0;\n if (distSquared > 0) {\n gradCoeff = -2.0 * a * b * Math.pow(distSquared, b - 1.0);\n gradCoeff /= a * Math.pow(distSquared, b) + 1.0;\n }\n for (let d = 0; d < dim; d++) {\n const gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n current[d] += gradD * alpha;\n if (moveOther)\n other[d] += -gradD * alpha;\n }\n epochOfNextSample[i] += epochsPerSample[i];\n const nNegSamples = Math.floor((n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]);\n for (let p = 0; p < nNegSamples; p++) {\n const k = utils.tauRandInt(nVertices, this.random);\n const other = tailEmbedding[k];\n const distSquared = rDist(current, other);\n let gradCoeff = 0.0;\n if (distSquared > 0.0) {\n gradCoeff = 2.0 * gamma * b;\n gradCoeff /=\n (0.001 + distSquared) * (a * Math.pow(distSquared, b) + 1);\n }\n else if (j === k) {\n continue;\n }\n for (let d = 0; d < dim; d++) {\n let gradD = 4.0;\n if (gradCoeff > 0.0)\n gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n current[d] += gradD * alpha;\n }\n }\n epochOfNextNegativeSample[i] += nNegSamples * epochsPerNegativeSample[i];\n }\n optimizationState.alpha = initialAlpha * (1.0 - n / nEpochs);\n optimizationState.currentEpoch += 1;\n return headEmbedding;\n }\n /**\n * Improve an embedding using stochastic gradient descent to minimize the\n * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n * and low dimensional fuzzy simplicial sets. In practice this is done by\n * sampling edges based on their membership strength (with the (1-p) terms\n * coming from negative sampling similar to word2vec).\n */\n optimizeLayoutAsync(epochCallback = () => true) {\n return new Promise((resolve, reject) => {\n const step = async () => {\n try {\n const { nEpochs, currentEpoch } = this.optimizationState;\n this.embedding = this.optimizeLayoutStep(currentEpoch);\n const epochCompleted = this.optimizationState.currentEpoch;\n const shouldStop = epochCallback(epochCompleted) === false;\n const isFinished = epochCompleted === nEpochs;\n if (!shouldStop && !isFinished)\n setTimeout(() => step(), 0);\n else\n return resolve(isFinished);\n }\n catch (err) {\n reject(err);\n }\n };\n setTimeout(() => step(), 0);\n });\n }\n /**\n * Improve an embedding using stochastic gradient descent to minimize the\n * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n * and low dimensional fuzzy simplicial sets. In practice this is done by\n * sampling edges based on their membership strength (with the (1-p) terms\n * coming from negative sampling similar to word2vec).\n */\n optimizeLayout(epochCallback = () => true) {\n let isFinished = false;\n let embedding = [];\n while (!isFinished) {\n const { nEpochs, currentEpoch } = this.optimizationState;\n embedding = this.optimizeLayoutStep(currentEpoch);\n const epochCompleted = this.optimizationState.currentEpoch;\n const shouldStop = epochCallback(epochCompleted) === false;\n isFinished = epochCompleted === nEpochs || shouldStop;\n }\n return embedding;\n }\n /**\n * Gets the number of epochs for optimizing the projection.\n * NOTE: This heuristic differs from the python version\n */\n getNEpochs() {\n const graph = this.graph;\n if (this.nEpochs > 0)\n return this.nEpochs;\n if (!graph)\n return 200;\n const length = graph.nRows;\n if (length <= 2500)\n return 500;\n else if (length <= 5000)\n return 400;\n else if (length <= 7500)\n return 300;\n else\n return 200;\n }\n}\nexport function euclidean(x, y) {\n let result = 0;\n for (let i = 0; i < x.length; i++)\n result += (x[i] - y[i]) ** 2;\n return Math.sqrt(result);\n}\nexport function numeric(x, y) {\n const result = Math.abs(x - y);\n return result;\n}\nexport function cosine(x, y) {\n let result = 0.0;\n let normX = 0.0;\n let normY = 0.0;\n for (let i = 0; i < x.length; i++) {\n result += x[i] * y[i];\n normX += x[i] ** 2;\n normY += y[i] ** 2;\n }\n if (normX === 0 && normY === 0)\n return 0;\n else if (normX === 0 || normY === 0)\n return 1.0;\n else\n return 1.0 - result / Math.sqrt(normX * normY);\n}\n/**\n * An interface representing the optimization state tracked between steps of\n * the SGD optimization\n */\nclass OptimizationState {\n constructor() {\n this.currentEpoch = 0;\n // Data tracked during optimization steps.\n this.headEmbedding = [];\n this.tailEmbedding = [];\n this.head = [];\n this.tail = [];\n this.epochsPerSample = [];\n this.epochOfNextSample = [];\n this.epochOfNextNegativeSample = [];\n this.epochsPerNegativeSample = [];\n this.moveOther = true;\n this.initialAlpha = 1.0;\n this.alpha = 1.0;\n this.gamma = 1.0;\n this.a = 1.5769434603113077;\n this.b = 0.8950608779109733;\n this.dim = 2;\n this.nEpochs = 500;\n this.nVertices = 0;\n }\n}\n/**\n * Standard clamping of a value into a fixed range\n */\nfunction clip(x, clipValue) {\n if (x > clipValue)\n return clipValue;\n else if (x < -clipValue)\n return -clipValue;\n else\n return x;\n}\n/**\n * Reduced Euclidean distance.\n */\nfunction rDist(x, y) {\n let result = 0.0;\n for (let i = 0; i < x.length; i++)\n result += Math.pow(x[i] - y[i], 2);\n return result;\n}\n/**\n * Fit a, b params for the differentiable curve used in lower\n * dimensional fuzzy simplicial complex construction. We want the\n * smooth curve (from a pre-defined family with simple gradient) that\n * best matches an offset exponential decay.\n */\nexport function findABParams(spread, minDist) {\n const curve = ([a, b]) => (x) => {\n return 1.0 / (1.0 + a * x ** (2 * b));\n };\n const xv = utils\n .linear(0, spread * 3, 300)\n .map((val) => (val < minDist ? 1.0 : val));\n const yv = utils.zeros(xv.length).map((val, index) => {\n const gte = xv[index] >= minDist;\n return gte ? Math.exp(-(xv[index] - minDist) / spread) : val;\n });\n const initialValues = [0.5, 0.5];\n const data = { x: xv, y: yv };\n // Default options for the algorithm (from github example)\n const options = {\n damping: 1.5,\n initialValues,\n gradientDifference: 10e-2,\n maxIterations: 100,\n errorTolerance: 10e-3,\n };\n // eslint-disable-next-line new-cap\n const { parameterValues } = LM(data, curve, options);\n const [a, b] = parameterValues;\n return { a, b };\n}\n/**\n * Under the assumption of categorical distance for the intersecting\n * simplicial set perform a fast intersection.\n */\nexport function fastIntersection(graph, target, unknownDist = 1.0, farDist = 5.0) {\n return graph.map((value, row, col) => {\n if (target[row] === -1 || target[col] === -1)\n return value * Math.exp(-unknownDist);\n else if (target[row] !== target[col])\n return value * Math.exp(-farDist);\n else\n return value;\n });\n}\n/**\n * Reset the local connectivity requirement -- each data sample should\n * have complete confidence in at least one 1-simplex in the simplicial set.\n * We can enforce this by locally rescaling confidences, and then remerging the\n * different local simplicial sets together.\n */\nexport function resetLocalConnectivity(simplicialSet) {\n simplicialSet = matrix.normalize(simplicialSet, \"max\" /* matrix.NormType.max */);\n const transpose = matrix.transpose(simplicialSet);\n const prodMatrix = matrix.pairwiseMultiply(transpose, simplicialSet);\n simplicialSet = matrix.add(simplicialSet, matrix.subtract(transpose, prodMatrix));\n return matrix.eliminateZeros(simplicialSet);\n}\n/**\n * Given indices and weights and an original embeddings\n * initialize the positions of new points relative to the\n * indices and weights (of their neighbors in the source data).\n */\nexport function initTransform(indices, weights, embedding) {\n const result = utils\n .zeros(indices.length)\n .map((_z) => utils.zeros(embedding[0].length));\n for (let i = 0; i < indices.length; i++) {\n for (let j = 0; j < indices[0].length; j++) {\n for (let d = 0; d < embedding[0].length; d++) {\n const a = indices[i][j];\n result[i][d] += weights[i][j] * embedding[a][d];\n }\n }\n }\n return result;\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"umap.js","sourceRoot":"","sources":["umap.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\n/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n *   list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n *   this list of conditions and the following disclaimer in the documentation\n *   and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n *   contributors may be used to endorse or promote products derived from\n *   this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport * as heap from './heap';\nimport * as matrix from './matrix';\nimport * as nnDescent from './nn_descent';\nimport * as tree from './tree';\nimport * as utils from './utils';\nimport LM from 'ml-levenberg-marquardt';\n\nexport type DistanceFn = (x: number, y: number) => number;\nexport type RandomFn = () => number;\nexport type EpochCallback = (epoch: number) => boolean | void;\nexport type Vector = number[];\nexport type Vectors = Vector[];\nexport const enum TargetMetric {\n  categorical = 'categorical',\n  l1 = 'l1',\n  l2 = 'l2',\n}\n\nconst SMOOTH_K_TOLERANCE = 1e-5;\nconst MIN_K_DIST_SCALE = 1e-3;\n\nexport interface UMAPParameters {\n  /**\n   * The distance function with which to assess nearest neighbors, defaults\n   * to euclidean distance.\n   */\n  distanceFn?: DistanceFn;\n  /**\n   * The initial learning rate for the embedding optimization.\n   */\n  learningRate?: number;\n  /**\n   * The local connectivity required -- i.e. the number of nearest\n   * neighbors that should be assumed to be connected at a local level.\n   * The higher this value the more connected the manifold becomes\n   * locally. In practice this should be not more than the local intrinsic\n   * dimension of the manifold.\n   */\n  localConnectivity?: number;\n  /**\n   * The effective minimum distance between embedded points. Smaller values\n   * will result in a more clustered/clumped embedding where nearby points\n   * on the manifold are drawn closer together, while larger values will\n   * result on a more even dispersal of points. The value should be set\n   * relative to the ``spread`` value, which determines the scale at which\n   * embedded points will be spread out.\n   */\n  minDist?: number;\n  /**\n   * The dimension of the space to embed into. This defaults to 2 to\n   * provide easy visualization, but can reasonably be set to any\n   * integer value in the range 2 to 100.\n   */\n  nComponents?: number;\n  /**\n   * The number of training epochs to be used in optimizing the\n   * low dimensional embedding. Larger values result in more accurate\n   * embeddings. If None is specified a value will be selected based on\n   * the size of the input dataset (200 for large datasets, 500 for small).\n   */\n  nEpochs?: number;\n  /**\n   * The size of local neighborhood (in terms of number of neighboring\n   * sample points) used for manifold approximation. Larger values\n   * result in more global views of the manifold, while smaller\n   * values result in more local data being preserved. In general\n   * values should be in the range 2 to 100.\n   */\n  nNeighbors?: number;\n  /**\n   * The number of negative samples to select per positive sample\n   * in the optimization process. Increasing this value will result\n   * in greater repulsive force being applied, greater optimization\n   * cost, but slightly more accuracy.\n   */\n  negativeSampleRate?: number;\n  /**\n   * Weighting applied to negative samples in low dimensional embedding\n   * optimization. Values higher than one will result in greater weight\n   * being given to negative samples.\n   */\n  repulsionStrength?: number;\n  /**\n   * The pseudo-random number generator used by the stochastic parts of the\n   * algorithm.\n   */\n  random?: RandomFn;\n  /**\n   * Interpolate between (fuzzy) union and intersection as the set operation\n   * used to combine local fuzzy simplicial sets to obtain a global fuzzy\n   * simplicial sets. Both fuzzy set operations use the product t-norm.\n   * The value of this parameter should be between 0.0 and 1.0; a value of\n   * 1.0 will use a pure fuzzy union, while 0.0 will use a pure fuzzy\n   * intersection.\n   */\n  setOpMixRatio?: number;\n  /**\n   * The effective scale of embedded points. In combination with ``min_dist``\n   * this determines how clustered/clumped the embedded points are.\n   */\n  spread?: number;\n  /**\n   * For transform operations (embedding new points using a trained model)\n   * this will control how aggressively to search for nearest neighbors.\n   * Larger values will result in slower performance but more accurate\n   * nearest neighbor evaluation.\n   */\n  transformQueueSize?: number;\n}\n\nexport interface UMAPSupervisedParams {\n  /**\n   * The metric used to measure distance for a target array is using supervised\n   * dimension reduction. By default this is 'categorical' which will measure\n   * distance in terms of whether categories match or are different. Furthermore,\n   * if semi-supervised is required target values of -1 will be treated as\n   * unlabelled under the 'categorical' metric. If the target array takes\n   * continuous values (e.g. for a regression problem) then metric of 'l1'\n   * or 'l2' is probably more appropriate.\n   */\n  targetMetric?: TargetMetric;\n  /**\n   * Weighting factor between data topology and target topology. A value of\n   * 0.0 weights entirely on data, a value of 1.0 weights entirely on target.\n   * The default of 0.5 balances the weighting equally between data and target.\n   */\n  targetWeight?: number;\n  /**\n   * The number of nearest neighbors to use to construct the target simplcial\n   * set. Defaults to the `nearestNeighbors` parameter.\n   */\n  targetNNeighbors?: number;\n}\n\n/**\n * UMAP projection system, based on the python implementation from McInnes, L,\n * Healy, J, UMAP: Uniform Manifold Approximation and Projection for Dimension\n * Reduction (https://github.com/lmcinnes/umap).\n *\n * This implementation differs in a few regards:\n * a) The initialization of the embedding for optimization is not computed using\n *    a spectral method, rather it is initialized randomly. This avoids some\n *    computationally intensive matrix eigen computations that aren't easily\n *    ported to JavaScript.\n * b) A lot of \"extra\" functionality has been omitted from this implementation,\n *    most notably a great deal of alternate distance functions.\n *\n * This implementation provides three methods of reducing dimensionality:\n * 1) fit: fit the data synchronously\n * 2) fitAsync: fit the data asynchronously, with a callback function provided\n *      that is invoked on each optimization step.\n * 3) initializeFit / step: manually initialize the algorithm then explictly\n *      step through each epoch of the SGD optimization\n */\nexport class UMAP {\n  public learningRate = 1.0;\n  public localConnectivity = 1.0;\n  public minDist = 0.1;\n  public nComponents = 2;\n  private nEpochs = 0;\n  private nNeighbors = 15;\n  public negativeSampleRate = 5;\n  public random = Math.random;\n  public repulsionStrength = 1.0;\n  public setOpMixRatio = 1.0;\n  public spread = 1.0;\n  private transformQueueSize = 4.0;\n\n  // Supervised projection params\n  private targetMetric = TargetMetric.categorical;\n  private targetWeight = 0.5;\n  private targetNNeighbors = 15;\n\n  private distanceFn: DistanceFn = numeric;\n\n  // KNN state (can be precomputed and supplied via initializeFit)\n  private knnIndices?: number[][];\n  private knnDistances?: number[][];\n\n  // Internal graph connectivity representation\n  private graph!: matrix.SparseMatrix;\n  private X!: Vector;\n  private isInitialized = false;\n  private rpForest: tree.FlatTree[] = [];\n  private initFromRandom!: nnDescent.InitFromRandomFn;\n  private initFromTree!: nnDescent.InitFromTreeFn;\n  private search!: nnDescent.SearchFn;\n  private searchGraph!: matrix.SparseMatrix;\n\n  // Supervised projection labels / targets\n  private Y?: number[];\n\n  // Projected embedding\n  private embedding: number[][] = [];\n  private optimizationState = new OptimizationState();\n\n\n  get neighbors() {\n    return this.nNeighbors;\n  }\n  constructor(params: UMAPParameters = {}) {\n    const setParam = (key: keyof UMAPParameters) => {\n      //@ts-ignore\n      if (params[key] !== undefined) this[key] = params[key];\n    };\n\n    setParam('distanceFn');\n    setParam('learningRate');\n    setParam('localConnectivity');\n    setParam('minDist');\n    setParam('nComponents');\n    setParam('nEpochs');\n    setParam('nNeighbors');\n    setParam('negativeSampleRate');\n    setParam('random');\n    setParam('repulsionStrength');\n    setParam('setOpMixRatio');\n    setParam('spread');\n    setParam('transformQueueSize');\n    this.targetNNeighbors = params.nNeighbors || this.nNeighbors || this.targetNNeighbors;\n  }\n\n  /**\n   * Fit the data to a projected embedding space synchronously.\n   */\n  fit(X: Vector) {\n    this.initializeFit(X);\n    this.optimizeLayout();\n\n    return this.embedding;\n  }\n\n  /**\n   * Fit the data to a projected embedding space asynchronously, with a callback\n   * function invoked on every epoch of optimization.\n   */\n  async fitAsync(\n    X: Vector,\n    callback: (epochNumber: number) => void | boolean = () => true\n  ) {\n    this.initializeFit(X);\n\n    await this.optimizeLayoutAsync(callback);\n    return this.embedding;\n  }\n\n  /**\n   * Initializes parameters needed for supervised projection.\n   */\n  setSupervisedProjection(Y: number[], params: UMAPSupervisedParams = {}) {\n    this.Y = Y;\n    this.targetMetric = params.targetMetric || this.targetMetric;\n    this.targetWeight = params.targetWeight || this.targetWeight;\n    this.targetNNeighbors = params.targetNNeighbors || this.targetNNeighbors;\n  }\n\n  /**\n   * Initializes umap with precomputed KNN indices and distances.\n   */\n  setPrecomputedKNN(knnIndices: number[][], knnDistances: number[][]) {\n    this.knnIndices = knnIndices;\n    this.knnDistances = knnDistances;\n  }\n\n  /**\n   * Initializes fit by computing KNN and a fuzzy simplicial set, as well as\n   * initializing the projected embeddings. Sets the optimization state ahead\n   * of optimization steps. Returns the number of epochs to be used for the\n   * SGD optimization.\n   */\n  initializeFit(X: Vector): number {\n    if (X.length <= this.nNeighbors)\n      throw new Error(`Not enough data points (${X.length}) to create nNeighbors: ${this.nNeighbors}.  Add more data points or adjust the configuration.`);\n\n\n    // We don't need to reinitialize if we've already initialized for this data.\n    if (this.X === X && this.isInitialized)\n      return this.getNEpochs();\n\n\n    this.X = X;\n\n    if (!this.knnIndices && !this.knnDistances) {\n      const knnResults = this.nearestNeighbors(X);\n      this.knnIndices = knnResults.knnIndices;\n      this.knnDistances = knnResults.knnDistances;\n    }\n\n    this.graph = this.fuzzySimplicialSet(\n      X,\n      this.nNeighbors,\n      this.setOpMixRatio\n    );\n\n    // Set up the search graph for subsequent transformation.\n    this.makeSearchFns();\n    this.searchGraph = this.makeSearchGraph(X);\n\n    // Check if supervised projection, then adjust the graph.\n    this.processGraphForSupervisedProjection();\n\n    const {\n      head,\n      tail,\n      epochsPerSample,\n    } = this.initializeSimplicialSetEmbedding();\n\n    // Set the optimization routine state\n    this.optimizationState.head = head;\n    this.optimizationState.tail = tail;\n    this.optimizationState.epochsPerSample = epochsPerSample;\n\n    // Now, initialize the optimization steps\n    this.initializeOptimization();\n    this.prepareForOptimizationLoop();\n    this.isInitialized = true;\n\n    return this.getNEpochs();\n  }\n\n  private makeSearchFns() {\n    const {initFromTree, initFromRandom} = nnDescent.makeInitializations(\n      this.distanceFn\n    );\n    this.initFromTree = initFromTree;\n    this.initFromRandom = initFromRandom;\n    this.search = nnDescent.makeInitializedNNSearch(this.distanceFn);\n  }\n\n  private makeSearchGraph(X: Vector) {\n    const knnIndices = this.knnIndices!;\n    const knnDistances = this.knnDistances!;\n    const dims = [X.length, X.length];\n    const searchGraph = new matrix.SparseMatrix([], [], [], dims);\n    for (let i = 0; i < knnIndices.length; i++) {\n      const knn = knnIndices[i];\n      const distances = knnDistances[i];\n      for (let j = 0; j < knn.length; j++) {\n        const neighbor = knn[j];\n        const distance = distances[j];\n        if (distance > 0)\n          searchGraph.set(i, neighbor, distance);\n      }\n    }\n\n    const transpose = matrix.transpose(searchGraph);\n    return matrix.maximum(searchGraph, transpose);\n  }\n\n  /**\n   * Transforms data to the existing embedding space.\n   */\n  transform(toTransform: Vector) {\n    // Use the previous rawData\n    const rawData = this.X;\n    if (rawData === undefined || rawData.length === 0)\n      throw new Error('No data has been fit.');\n\n\n    let nNeighbors = Math.floor(this.nNeighbors * this.transformQueueSize);\n    nNeighbors = Math.min(rawData.length, nNeighbors);\n    const init = nnDescent.initializeSearch(\n      this.rpForest,\n      rawData,\n      toTransform,\n      nNeighbors,\n      this.initFromRandom,\n      this.initFromTree,\n      this.random\n    );\n\n    const result = this.search(rawData, this.searchGraph, init, toTransform);\n\n    let {indices, weights: distances} = heap.deheapSort(result);\n\n    indices = indices.map((x) => x.slice(0, this.nNeighbors));\n    distances = distances.map((x) => x.slice(0, this.nNeighbors));\n\n    const adjustedLocalConnectivity = Math.max(0, this.localConnectivity - 1);\n    const {sigmas, rhos} = this.smoothKNNDistance(\n      distances,\n      this.nNeighbors,\n      adjustedLocalConnectivity\n    );\n\n    const {rows, cols, vals} = this.computeMembershipStrengths(\n      indices,\n      distances,\n      sigmas,\n      rhos\n    );\n\n    const size = [toTransform.length, rawData.length];\n    let graph = new matrix.SparseMatrix(rows, cols, vals, size);\n\n    // This was a very specially constructed graph with constant degree.\n    // That lets us do fancy unpacking by reshaping the csr matrix indices\n    // and data. Doing so relies on the constant degree assumption!\n\n    const normed = matrix.normalize(graph, matrix.NormType.l1);\n\n    const csrMatrix = matrix.getCSR(normed);\n    const nPoints = toTransform.length;\n\n    const eIndices = utils.reshape2d(\n      csrMatrix.indices,\n      nPoints,\n      this.nNeighbors\n    );\n\n    const eWeights = utils.reshape2d(\n      csrMatrix.values,\n      nPoints,\n      this.nNeighbors\n    );\n\n    const embedding = initTransform(eIndices, eWeights, this.embedding);\n\n    const nEpochs = this.nEpochs ?\n      this.nEpochs / 3 :\n      graph.nRows <= 10000 ?\n        100 :\n        30;\n\n    const graphMax = graph\n      .getValues()\n      .reduce((max, val) => (val > max ? val : max), 0);\n    graph = graph.map((value) => (value < graphMax / nEpochs ? 0 : value));\n    graph = matrix.eliminateZeros(graph);\n\n    const epochsPerSample = this.makeEpochsPerSample(\n      graph.getValues(),\n      nEpochs\n    );\n    const head = graph.getRows();\n    const tail = graph.getCols();\n\n    // Initialize optimization slightly differently than the fit method.\n    this.assignOptimizationStateParameters({\n      headEmbedding: embedding,\n      tailEmbedding: this.embedding,\n      head,\n      tail,\n      currentEpoch: 0,\n      nEpochs,\n      nVertices: graph.getDims()[1],\n      epochsPerSample,\n    });\n    this.prepareForOptimizationLoop();\n\n    return this.optimizeLayout();\n  }\n\n  /**\n   * Checks if we're using supervised projection, then process the graph\n   * accordingly.\n   */\n  private processGraphForSupervisedProjection() {\n    const {Y, X} = this;\n    if (Y) {\n      if (Y.length !== X.length)\n        throw new Error('Length of X and y must be equal');\n\n\n      if (this.targetMetric === TargetMetric.categorical) {\n        const lt = this.targetWeight < 1.0;\n        const farDist = lt ? 2.5 * (1.0 / (1.0 - this.targetWeight)) : 1.0e12;\n        this.graph = this.categoricalSimplicialSetIntersection(\n          this.graph,\n          Y,\n          farDist\n        );\n      }\n      // TODO (andycoenen@): add non-categorical supervised embeddings.\n    }\n  }\n\n  /**\n   * Manually step through the optimization process one epoch at a time.\n   */\n  step() {\n    const {currentEpoch} = this.optimizationState;\n\n    if (currentEpoch < this.getNEpochs())\n      this.optimizeLayoutStep(currentEpoch);\n\n    return this.optimizationState.currentEpoch;\n  }\n\n  /**\n   * Returns the computed projected embedding.\n   */\n  getEmbedding() {\n    return this.embedding;\n  }\n\n  /**\n   * Compute the ``nNeighbors`` nearest points for each data point in ``X``\n   * This may be exact, but more likely is approximated via nearest neighbor\n   * descent.\n   */\n  private nearestNeighbors(X: Vector) {\n    const {distanceFn, nNeighbors} = this;\n    const log2 = (n: number) => Math.log(n) / Math.log(2);\n    const metricNNDescent = nnDescent.makeNNDescent(distanceFn, this.random);\n\n    // Handle python3 rounding down from 0.5 discrpancy\n    const round = (n: number) => {\n      return n === 0.5 ? 0 : Math.round(n);\n    };\n\n    const nTrees = 5 + Math.floor(round(X.length ** 0.5 / 20.0));\n    const nIters = Math.max(5, Math.floor(Math.round(log2(X.length))));\n\n    this.rpForest = tree.makeForest(X, nNeighbors, nTrees, this.random);\n\n    const leafArray = tree.makeLeafArray(this.rpForest);\n    const {indices, weights} = metricNNDescent(\n      X,\n      leafArray,\n      nNeighbors,\n      nIters\n    );\n    return {knnIndices: indices, knnDistances: weights};\n  }\n\n  /**\n   * Given a set of data X, a neighborhood size, and a measure of distance\n   * compute the fuzzy simplicial set (here represented as a fuzzy graph in\n   * the form of a sparse matrix) associated to the data. This is done by\n   * locally approximating geodesic distance at each point, creating a fuzzy\n   * simplicial set for each such point, and then combining all the local\n   * fuzzy simplicial sets into a global one via a fuzzy union.\n   */\n  private fuzzySimplicialSet(\n    X: Vector,\n    nNeighbors: number,\n    setOpMixRatio = 1.0\n  ) {\n    const {knnIndices = [], knnDistances = [], localConnectivity} = this;\n\n    const {sigmas, rhos} = this.smoothKNNDistance(\n      knnDistances,\n      nNeighbors,\n      localConnectivity\n    );\n\n    const {rows, cols, vals} = this.computeMembershipStrengths(\n      knnIndices,\n      knnDistances,\n      sigmas,\n      rhos\n    );\n\n    const size = [X.length, X.length];\n    const sparseMatrix = new matrix.SparseMatrix(rows, cols, vals, size);\n\n    const transpose = matrix.transpose(sparseMatrix);\n    const prodMatrix = matrix.pairwiseMultiply(sparseMatrix, transpose);\n\n    const a = matrix.subtract(matrix.add(sparseMatrix, transpose), prodMatrix);\n    const b = matrix.multiplyScalar(a, setOpMixRatio);\n    const c = matrix.multiplyScalar(prodMatrix, 1.0 - setOpMixRatio);\n    const result = matrix.add(b, c);\n\n    return result;\n  }\n\n  /**\n   * Combine a fuzzy simplicial set with another fuzzy simplicial set\n   * generated from categorical data using categorical distances. The target\n   * data is assumed to be categorical label data (a vector of labels),\n   * and this will update the fuzzy simplicial set to respect that label data.\n   */\n  private categoricalSimplicialSetIntersection(\n    simplicialSet: matrix.SparseMatrix,\n    target: number[],\n    farDist: number,\n    unknownDist = 1.0\n  ) {\n    let intersection = fastIntersection(\n      simplicialSet,\n      target,\n      unknownDist,\n      farDist\n    );\n    intersection = matrix.eliminateZeros(intersection);\n    return resetLocalConnectivity(intersection);\n  }\n\n  /**\n   * Compute a continuous version of the distance to the kth nearest\n   * neighbor. That is, this is similar to knn-distance but allows continuous\n   * k values rather than requiring an integral k. In esscence we are simply\n   * computing the distance such that the cardinality of fuzzy set we generate\n   * is k.\n   */\n  private smoothKNNDistance(\n    distances: Vectors,\n    k: number,\n    localConnectivity = 1.0,\n    nIter = 64,\n    bandwidth = 1.0\n  ) {\n    const target = (Math.log(k) / Math.log(2)) * bandwidth;\n    const rho = utils.zeros(distances.length);\n    const result = utils.zeros(distances.length);\n\n    for (let i = 0; i < distances.length; i++) {\n      let lo = 0.0;\n      let hi = Infinity;\n      let mid = 1.0;\n\n      // TODO: This is very inefficient, but will do for now. FIXME\n      const ithDistances = distances[i];\n      const nonZeroDists = ithDistances.filter((d) => d > 0.0);\n\n      if (nonZeroDists.length >= localConnectivity) {\n        const index = Math.floor(localConnectivity);\n        const interpolation = localConnectivity - index;\n        if (index > 0) {\n          rho[i] = nonZeroDists[index - 1];\n          if (interpolation > SMOOTH_K_TOLERANCE) {\n            rho[i] +=\n              interpolation * (nonZeroDists[index] - nonZeroDists[index - 1]);\n          }\n        } else {\n          rho[i] = interpolation * nonZeroDists[0];\n        }\n      } else if (nonZeroDists.length > 0) {\n        rho[i] = utils.max(nonZeroDists);\n      }\n\n      for (let n = 0; n < nIter; n++) {\n        let psum = 0.0;\n        for (let j = 1; j < distances[i].length; j++) {\n          const d = distances[i][j] - rho[i];\n          if (d > 0)\n            psum += Math.exp(-(d / mid));\n          else\n            psum += 1.0;\n        }\n\n        if (Math.abs(psum - target) < SMOOTH_K_TOLERANCE)\n          break;\n\n\n        if (psum > target) {\n          hi = mid;\n          mid = (lo + hi) / 2.0;\n        } else {\n          lo = mid;\n          if (hi === Infinity)\n            mid *= 2;\n          else\n            mid = (lo + hi) / 2.0;\n        }\n      }\n\n      result[i] = mid;\n\n      // TODO: This is very inefficient, but will do for now. FIXME\n      if (rho[i] > 0.0) {\n        const meanIthDistances = utils.mean(ithDistances);\n        if (result[i] < MIN_K_DIST_SCALE * meanIthDistances)\n          result[i] = MIN_K_DIST_SCALE * meanIthDistances;\n      } else {\n        const meanDistances = utils.mean(distances.map(utils.mean));\n        if (result[i] < MIN_K_DIST_SCALE * meanDistances)\n          result[i] = MIN_K_DIST_SCALE * meanDistances;\n      }\n    }\n\n    return {sigmas: result, rhos: rho};\n  }\n\n  /**\n   * Construct the membership strength data for the 1-skeleton of each local\n   * fuzzy simplicial set -- this is formed as a sparse matrix where each row is\n   * a local fuzzy simplicial set, with a membership strength for the\n   * 1-simplex to each other data point.\n   */\n  private computeMembershipStrengths(\n    knnIndices: Vectors,\n    knnDistances: Vectors,\n    sigmas: number[],\n    rhos: number[]\n  ): { rows: number[]; cols: number[]; vals: number[] } {\n    const nSamples = knnIndices.length;\n    const nNeighbors = knnIndices[0].length;\n\n    const rows = utils.zeros(nSamples * nNeighbors);\n    const cols = utils.zeros(nSamples * nNeighbors);\n    const vals = utils.zeros(nSamples * nNeighbors);\n\n    for (let i = 0; i < nSamples; i++) {\n      for (let j = 0; j < nNeighbors; j++) {\n        let val = 0;\n        if (knnIndices[i][j] === -1)\n          continue; // We didn't get the full knn for i\n\n        if (knnIndices[i][j] === i)\n          val = 0.0;\n        else if (knnDistances[i][j] - rhos[i] <= 0.0)\n          val = 1.0;\n        else\n          val = Math.exp(-((knnDistances[i][j] - rhos[i]) / sigmas[i]));\n\n\n        rows[i * nNeighbors + j] = i;\n        cols[i * nNeighbors + j] = knnIndices[i][j];\n        vals[i * nNeighbors + j] = val;\n      }\n    }\n\n    return {rows, cols, vals};\n  }\n\n  /**\n   * Initialize a fuzzy simplicial set embedding, using a specified\n   * initialisation method and then minimizing the fuzzy set cross entropy\n   * between the 1-skeletons of the high and low dimensional fuzzy simplicial\n   * sets.\n   */\n  private initializeSimplicialSetEmbedding() {\n    const nEpochs = this.getNEpochs();\n\n    const {nComponents} = this;\n    const graphValues = this.graph.getValues();\n    let graphMax = 0;\n    for (let i = 0; i < graphValues.length; i++) {\n      const value = graphValues[i];\n      if (graphMax < graphValues[i])\n        graphMax = value;\n    }\n\n    const graph = this.graph.map((value) => {\n      if (value < graphMax / nEpochs)\n        return 0;\n      else\n        return value;\n    });\n\n    // We're not computing the spectral initialization in this implementation\n    // until we determine a better eigenvalue/eigenvector computation\n    // approach\n    this.embedding = utils.zeros(graph.nRows).map(() => {\n      return utils.zeros(nComponents).map(() => {\n        return utils.tauRand(this.random) * 20 + -10; // Random from -10 to 10\n      });\n    });\n\n    // Get graph data in ordered way...\n    const weights: number[] = [];\n    const head: number[] = [];\n    const tail: number[] = [];\n    const rowColValues = graph.getAll();\n    for (let i = 0; i < rowColValues.length; i++) {\n      const entry = rowColValues[i];\n      if (entry.value) {\n        weights.push(entry.value);\n        tail.push(entry.row);\n        head.push(entry.col);\n      }\n    }\n    const epochsPerSample = this.makeEpochsPerSample(weights, nEpochs);\n\n    return {head, tail, epochsPerSample};\n  }\n\n  /**\n   * Given a set of weights and number of epochs generate the number of\n   * epochs per sample for each weight.\n   */\n  private makeEpochsPerSample(weights: number[], nEpochs: number) {\n    const result = utils.filled(weights.length, -1.0);\n    const max = utils.max(weights);\n    const nSamples = weights.map((w) => (w / max) * nEpochs);\n    nSamples.forEach((n, i) => {\n      if (n > 0) result[i] = nEpochs / nSamples[i];\n    });\n    return result;\n  }\n\n  /**\n   * Assigns optimization state parameters from a partial optimization state.\n   */\n  private assignOptimizationStateParameters(state: Partial<OptimizationState>) {\n    Object.assign(this.optimizationState, state);\n  }\n\n  /**\n   * Sets a few optimization state parameters that are necessary before entering\n   * the optimization step loop.\n   */\n  private prepareForOptimizationLoop() {\n    // Hyperparameters\n    const {repulsionStrength, learningRate, negativeSampleRate} = this;\n\n    const {\n      epochsPerSample,\n      headEmbedding,\n      tailEmbedding,\n    } = this.optimizationState;\n\n    const dim = headEmbedding[0].length;\n    const moveOther = headEmbedding.length === tailEmbedding.length;\n\n    const epochsPerNegativeSample = epochsPerSample.map(\n      (e) => e / negativeSampleRate\n    );\n    const epochOfNextNegativeSample = [...epochsPerNegativeSample];\n    const epochOfNextSample = [...epochsPerSample];\n\n    this.assignOptimizationStateParameters({\n      epochOfNextSample,\n      epochOfNextNegativeSample,\n      epochsPerNegativeSample,\n      moveOther,\n      initialAlpha: learningRate,\n      alpha: learningRate,\n      gamma: repulsionStrength,\n      dim,\n    });\n  }\n\n  /**\n   * Initializes optimization state for stepwise optimization.\n   */\n  private initializeOptimization() {\n    // Algorithm state\n    const headEmbedding = this.embedding;\n    const tailEmbedding = this.embedding;\n\n    // Initialized in initializeSimplicialSetEmbedding()\n    const {head, tail, epochsPerSample} = this.optimizationState;\n\n    const nEpochs = this.getNEpochs();\n    const nVertices = this.graph.nCols;\n\n    const {a, b} = findABParams(this.spread, this.minDist);\n\n    this.assignOptimizationStateParameters({\n      headEmbedding,\n      tailEmbedding,\n      head,\n      tail,\n      epochsPerSample,\n      a,\n      b,\n      nEpochs,\n      nVertices,\n    });\n  }\n\n  /**\n   * Improve an embedding using stochastic gradient descent to minimize the\n   * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n   * and low dimensional fuzzy simplicial sets. In practice this is done by\n   * sampling edges based on their membership strength (with the (1-p) terms\n   * coming from negative sampling similar to word2vec).\n   */\n  private optimizeLayoutStep(n: number) {\n    const {optimizationState} = this;\n    const {\n      head,\n      tail,\n      headEmbedding,\n      tailEmbedding,\n      epochsPerSample,\n      epochOfNextSample,\n      epochOfNextNegativeSample,\n      epochsPerNegativeSample,\n      moveOther,\n      initialAlpha,\n      alpha,\n      gamma,\n      a,\n      b,\n      dim,\n      nEpochs,\n      nVertices,\n    } = optimizationState;\n\n    const clipValue = 4.0;\n\n    for (let i = 0; i < epochsPerSample.length; i++) {\n      if (epochOfNextSample[i] > n)\n        continue;\n\n\n      const j = head[i];\n      const k = tail[i];\n\n      const current = headEmbedding[j];\n      const other = tailEmbedding[k];\n\n      const distSquared = rDist(current, other);\n\n      let gradCoeff = 0;\n      if (distSquared > 0) {\n        gradCoeff = -2.0 * a * b * Math.pow(distSquared, b - 1.0);\n        gradCoeff /= a * Math.pow(distSquared, b) + 1.0;\n      }\n\n      for (let d = 0; d < dim; d++) {\n        const gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n        current[d] += gradD * alpha;\n        if (moveOther)\n          other[d] += -gradD * alpha;\n      }\n\n      epochOfNextSample[i] += epochsPerSample[i];\n\n      const nNegSamples = Math.floor(\n        (n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]\n      );\n\n      for (let p = 0; p < nNegSamples; p++) {\n        const k = utils.tauRandInt(nVertices, this.random);\n        const other = tailEmbedding[k];\n\n        const distSquared = rDist(current, other);\n\n        let gradCoeff = 0.0;\n        if (distSquared > 0.0) {\n          gradCoeff = 2.0 * gamma * b;\n          gradCoeff /=\n            (0.001 + distSquared) * (a * Math.pow(distSquared, b) + 1);\n        } else if (j === k) {\n          continue;\n        }\n\n        for (let d = 0; d < dim; d++) {\n          let gradD = 4.0;\n          if (gradCoeff > 0.0)\n            gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n\n          current[d] += gradD * alpha;\n        }\n      }\n      epochOfNextNegativeSample[i] += nNegSamples * epochsPerNegativeSample[i];\n    }\n    optimizationState.alpha = initialAlpha * (1.0 - n / nEpochs);\n\n    optimizationState.currentEpoch += 1;\n    return headEmbedding;\n  }\n\n  /**\n   * Improve an embedding using stochastic gradient descent to minimize the\n   * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n   * and low dimensional fuzzy simplicial sets. In practice this is done by\n   * sampling edges based on their membership strength (with the (1-p) terms\n   * coming from negative sampling similar to word2vec).\n   */\n  private optimizeLayoutAsync(\n    epochCallback: (epochNumber: number) => void | boolean = () => true\n  ): Promise<boolean> {\n    return new Promise((resolve, reject) => {\n      const step = async () => {\n        try {\n          const {nEpochs, currentEpoch} = this.optimizationState;\n          this.embedding = this.optimizeLayoutStep(currentEpoch);\n          const epochCompleted = this.optimizationState.currentEpoch;\n          const shouldStop = epochCallback(epochCompleted) === false;\n          const isFinished = epochCompleted === nEpochs;\n          if (!shouldStop && !isFinished)\n            setTimeout(() => step(), 0);\n          else\n            return resolve(isFinished);\n        } catch (err) {\n          reject(err);\n        }\n      };\n      setTimeout(() => step(), 0);\n    });\n  }\n\n  /**\n   * Improve an embedding using stochastic gradient descent to minimize the\n   * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n   * and low dimensional fuzzy simplicial sets. In practice this is done by\n   * sampling edges based on their membership strength (with the (1-p) terms\n   * coming from negative sampling similar to word2vec).\n   */\n  private optimizeLayout(\n    epochCallback: (epochNumber: number) => void | boolean = () => true\n  ): Vectors {\n    let isFinished = false;\n    let embedding: Vectors = [];\n    while (!isFinished) {\n      const {nEpochs, currentEpoch} = this.optimizationState;\n      embedding = this.optimizeLayoutStep(currentEpoch);\n      const epochCompleted = this.optimizationState.currentEpoch;\n      const shouldStop = epochCallback(epochCompleted) === false;\n      isFinished = epochCompleted === nEpochs || shouldStop;\n    }\n    return embedding;\n  }\n\n  /**\n   * Gets the number of epochs for optimizing the projection.\n   * NOTE: This heuristic differs from the python version\n   */\n  public getNEpochs() {\n    const graph = this.graph;\n\n    if (this.nEpochs > 0)\n      return this.nEpochs;\n\n\n    if (!graph)\n      return 200;\n\n\n    const length = graph.nRows;\n    if (length <= 2500)\n      return 500;\n    else if (length <= 5000)\n      return 400;\n    else if (length <= 7500)\n      return 300;\n    else\n      return 200;\n  }\n}\n\nexport function euclidean(x: Vector, y: Vector) {\n  let result = 0;\n  for (let i = 0; i < x.length; i++)\n    result += (x[i] - y[i]) ** 2;\n\n  return Math.sqrt(result);\n}\n\nexport function numeric(x: number, y: number) {\n  const result = Math.abs(x - y);\n  return result;\n}\n\nexport function cosine(x: Vector, y: Vector) {\n  let result = 0.0;\n  let normX = 0.0;\n  let normY = 0.0;\n\n  for (let i = 0; i < x.length; i++) {\n    result += x[i] * y[i];\n    normX += x[i] ** 2;\n    normY += y[i] ** 2;\n  }\n\n  if (normX === 0 && normY === 0)\n    return 0;\n  else if (normX === 0 || normY === 0)\n    return 1.0;\n  else\n    return 1.0 - result / Math.sqrt(normX * normY);\n}\n\n/**\n * An interface representing the optimization state tracked between steps of\n * the SGD optimization\n */\nclass OptimizationState {\n  currentEpoch = 0;\n\n  // Data tracked during optimization steps.\n  headEmbedding: number[][] = [];\n  tailEmbedding: number[][] = [];\n  head: number[] = [];\n  tail: number[] = [];\n  epochsPerSample: number[] = [];\n  epochOfNextSample: number[] = [];\n  epochOfNextNegativeSample: number[] = [];\n  epochsPerNegativeSample: number[] = [];\n  moveOther = true;\n  initialAlpha = 1.0;\n  alpha = 1.0;\n  gamma = 1.0;\n  a = 1.5769434603113077;\n  b = 0.8950608779109733;\n  dim = 2;\n  nEpochs = 500;\n  nVertices = 0;\n}\n\n/**\n * Standard clamping of a value into a fixed range\n */\nfunction clip(x: number, clipValue: number) {\n  if (x > clipValue) return clipValue;\n  else if (x < -clipValue) return -clipValue;\n  else return x;\n}\n\n/**\n * Reduced Euclidean distance.\n */\nfunction rDist(x: number[], y: number[]) {\n  let result = 0.0;\n  for (let i = 0; i < x.length; i++)\n    result += Math.pow(x[i] - y[i], 2);\n\n  return result;\n}\n\n/**\n * Fit a, b params for the differentiable curve used in lower\n * dimensional fuzzy simplicial complex construction. We want the\n * smooth curve (from a pre-defined family with simple gradient) that\n * best matches an offset exponential decay.\n */\nexport function findABParams(spread: number, minDist: number) {\n  const curve = ([a, b]: number[]) => (x: number) => {\n    return 1.0 / (1.0 + a * x ** (2 * b));\n  };\n\n  const xv = utils\n    .linear(0, spread * 3, 300)\n    .map((val) => (val < minDist ? 1.0 : val));\n\n  const yv = utils.zeros(xv.length).map((val, index) => {\n    const gte = xv[index] >= minDist;\n    return gte ? Math.exp(-(xv[index] - minDist) / spread) : val;\n  });\n\n  const initialValues = [0.5, 0.5];\n  const data = {x: xv, y: yv};\n\n  // Default options for the algorithm (from github example)\n  const options = {\n    damping: 1.5,\n    initialValues,\n    gradientDifference: 10e-2,\n    maxIterations: 100,\n    errorTolerance: 10e-3,\n  };\n\n  // eslint-disable-next-line new-cap\n  const {parameterValues} = LM(data, curve, options);\n  const [a, b] = parameterValues as number[];\n  return {a, b};\n}\n\n/**\n * Under the assumption of categorical distance for the intersecting\n * simplicial set perform a fast intersection.\n */\nexport function fastIntersection(\n  graph: matrix.SparseMatrix,\n  target: number[],\n  unknownDist = 1.0,\n  farDist = 5.0\n) {\n  return graph.map((value, row, col) => {\n    if (target[row] === -1 || target[col] === -1)\n      return value * Math.exp(-unknownDist);\n    else if (target[row] !== target[col])\n      return value * Math.exp(-farDist);\n    else\n      return value;\n  });\n}\n\n/**\n * Reset the local connectivity requirement -- each data sample should\n * have complete confidence in at least one 1-simplex in the simplicial set.\n * We can enforce this by locally rescaling confidences, and then remerging the\n * different local simplicial sets together.\n */\nexport function resetLocalConnectivity(simplicialSet: matrix.SparseMatrix) {\n  simplicialSet = matrix.normalize(simplicialSet, matrix.NormType.max);\n  const transpose = matrix.transpose(simplicialSet);\n  const prodMatrix = matrix.pairwiseMultiply(transpose, simplicialSet);\n  simplicialSet = matrix.add(\n    simplicialSet,\n    matrix.subtract(transpose, prodMatrix)\n  );\n  return matrix.eliminateZeros(simplicialSet);\n}\n\n/**\n * Given indices and weights and an original embeddings\n * initialize the positions of new points relative to the\n * indices and weights (of their neighbors in the source data).\n */\nexport function initTransform(\n  indices: number[][],\n  weights: number[][],\n  embedding: Vectors\n) {\n  const result = utils\n    .zeros(indices.length)\n    .map((_z) => utils.zeros(embedding[0].length));\n\n  for (let i = 0; i < indices.length; i++) {\n    for (let j = 0; j < indices[0].length; j++) {\n      for (let d = 0; d < embedding[0].length; d++) {\n        const a = indices[i][j];\n        result[i][d] += weights[i][j] * embedding[a][d];\n      }\n    }\n  }\n  return result;\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n * contributors may be used to endorse or promote products derived from\n * this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\nimport * as heap from './heap';\nimport * as matrix from './matrix';\nimport * as tree from './tree';\nimport * as utils from './utils';\n/**\n * Create a version of nearest neighbor descent.\n */\nexport function makeNNDescent(distanceFn, random) {\n return function nNDescent(data, leafArray, nNeighbors, nIters = 10, maxCandidates = 50, delta = 0.001, rho = 0.5, rpTreeInit = true) {\n const nVertices = data.length;\n const currentGraph = heap.makeHeap(data.length, nNeighbors);\n for (let i = 0; i < data.length; i++) {\n const indices = heap.rejectionSample(nNeighbors, data.length, random);\n for (let j = 0; j < indices.length; j++) {\n const d = distanceFn(data[i], data[indices[j]]);\n heap.heapPush(currentGraph, i, d, indices[j], 1);\n heap.heapPush(currentGraph, indices[j], d, i, 1);\n }\n }\n if (rpTreeInit) {\n for (let n = 0; n < leafArray.length; n++) {\n for (let i = 0; i < leafArray[n].length; i++) {\n if (leafArray[n][i] < 0)\n break;\n for (let j = i + 1; j < leafArray[n].length; j++) {\n if (leafArray[n][j] < 0)\n break;\n const d = distanceFn(data[leafArray[n][i]], data[leafArray[n][j]]);\n heap.heapPush(currentGraph, leafArray[n][i], d, leafArray[n][j], 1);\n heap.heapPush(currentGraph, leafArray[n][j], d, leafArray[n][i], 1);\n }\n }\n }\n }\n for (let n = 0; n < nIters; n++) {\n const candidateNeighbors = heap.buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random);\n let c = 0;\n for (let i = 0; i < nVertices; i++) {\n for (let j = 0; j < maxCandidates; j++) {\n const p = Math.floor(candidateNeighbors[0][i][j]);\n if (p < 0 || utils.tauRand(random) < rho)\n continue;\n for (let k = 0; k < maxCandidates; k++) {\n const q = Math.floor(candidateNeighbors[0][i][k]);\n const cj = candidateNeighbors[2][i][j];\n const ck = candidateNeighbors[2][i][k];\n if (q < 0 || (!cj && !ck))\n continue;\n const d = distanceFn(data[p], data[q]);\n c += heap.heapPush(currentGraph, p, d, q, 1);\n c += heap.heapPush(currentGraph, q, d, p, 1);\n }\n }\n }\n if (c <= delta * nNeighbors * data.length)\n break;\n }\n const sorted = heap.deheapSort(currentGraph);\n return sorted;\n };\n}\nexport function makeInitializations(distanceFn) {\n function initFromRandom(nNeighbors, data, queryPoints, _heap, random) {\n for (let i = 0; i < queryPoints.length; i++) {\n const indices = utils.rejectionSample(nNeighbors, data.length, random);\n for (let j = 0; j < indices.length; j++) {\n if (indices[j] < 0)\n continue;\n const d = distanceFn(data[indices[j]], queryPoints[i]);\n heap.heapPush(_heap, i, d, indices[j], 1);\n }\n }\n }\n function initFromTree(_tree, data, queryPoints, _heap, random) {\n for (let i = 0; i < queryPoints.length; i++) {\n const indices = tree.searchFlatTree(queryPoints[i], _tree, random);\n for (let j = 0; j < indices.length; j++) {\n if (indices[j] < 0)\n return;\n const d = distanceFn(data[indices[j]], queryPoints[i]);\n heap.heapPush(_heap, i, d, indices[j], 1);\n }\n }\n return;\n }\n return { initFromRandom, initFromTree };\n}\nexport function makeInitializedNNSearch(distanceFn) {\n return function nnSearchFn(data, graph, initialization, queryPoints) {\n const { indices, indptr } = matrix.getCSR(graph);\n for (let i = 0; i < queryPoints.length; i++) {\n const tried = new Set(initialization[0][i]);\n while (true) {\n // Find smallest flagged vertex\n const vertex = heap.smallestFlagged(initialization, i);\n if (vertex === -1)\n break;\n const candidates = indices.slice(indptr[vertex], indptr[vertex + 1]);\n for (const candidate of candidates) {\n if (candidate === vertex ||\n candidate === -1 ||\n tried.has(candidate))\n continue;\n const d = distanceFn(data[candidate], queryPoints[i]);\n heap.uncheckedHeapPush(initialization, i, d, candidate, 1);\n tried.add(candidate);\n }\n }\n }\n return initialization;\n };\n}\nexport function initializeSearch(forest, data, queryPoints, nNeighbors, initFromRandom, initFromTree, random) {\n const results = heap.makeHeap(queryPoints.length, nNeighbors);\n initFromRandom(nNeighbors, data, queryPoints, results, random);\n if (forest) {\n for (const tree of forest)\n initFromTree(tree, data, queryPoints, results, random);\n }\n return results;\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nn_descent.js","sourceRoot":"","sources":["nn_descent.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n *   list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n *   this list of conditions and the following disclaimer in the documentation\n *   and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n *   contributors may be used to endorse or promote products derived from\n *   this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport * as heap from './heap';\nimport * as matrix from './matrix';\nimport * as tree from './tree';\nimport * as utils from './utils';\nimport {RandomFn, Vectors, DistanceFn, Vector} from './umap';\n\n/**\n * Create a version of nearest neighbor descent.\n */\nexport function makeNNDescent(distanceFn: DistanceFn, random: RandomFn) {\n  return function nNDescent(\n    data: Vector,\n    leafArray: Vectors,\n    nNeighbors: number,\n    nIters = 10,\n    maxCandidates = 50,\n    delta = 0.001,\n    rho = 0.5,\n    rpTreeInit = true\n  ) {\n    const nVertices = data.length;\n    const currentGraph = heap.makeHeap(data.length, nNeighbors);\n\n    for (let i = 0; i < data.length; i++) {\n      const indices = heap.rejectionSample(nNeighbors, data.length, random);\n      for (let j = 0; j < indices.length; j++) {\n        const d = distanceFn(data[i], data[indices[j]]);\n\n        heap.heapPush(currentGraph, i, d, indices[j], 1);\n        heap.heapPush(currentGraph, indices[j], d, i, 1);\n      }\n    }\n    if (rpTreeInit) {\n      for (let n = 0; n < leafArray.length; n++) {\n        for (let i = 0; i < leafArray[n].length; i++) {\n          if (leafArray[n][i] < 0)\n            break;\n\n          for (let j = i + 1; j < leafArray[n].length; j++) {\n            if (leafArray[n][j] < 0)\n              break;\n\n            const d = distanceFn(data[leafArray[n][i]], data[leafArray[n][j]]);\n            heap.heapPush(currentGraph, leafArray[n][i], d, leafArray[n][j], 1);\n            heap.heapPush(currentGraph, leafArray[n][j], d, leafArray[n][i], 1);\n          }\n        }\n      }\n    }\n\n    for (let n = 0; n < nIters; n++) {\n      const candidateNeighbors = heap.buildCandidates(\n        currentGraph,\n        nVertices,\n        nNeighbors,\n        maxCandidates,\n        random\n      );\n\n      let c = 0;\n      for (let i = 0; i < nVertices; i++) {\n        for (let j = 0; j < maxCandidates; j++) {\n          const p = Math.floor(candidateNeighbors[0][i][j]);\n          if (p < 0 || utils.tauRand(random) < rho)\n            continue;\n\n          for (let k = 0; k < maxCandidates; k++) {\n            const q = Math.floor(candidateNeighbors[0][i][k]);\n            const cj = candidateNeighbors[2][i][j];\n            const ck = candidateNeighbors[2][i][k];\n            if (q < 0 || (!cj && !ck))\n              continue;\n\n\n            const d = distanceFn(data[p], data[q]);\n            c += heap.heapPush(currentGraph, p, d, q, 1);\n            c += heap.heapPush(currentGraph, q, d, p, 1);\n          }\n        }\n      }\n      if (c <= delta * nNeighbors * data.length)\n        break;\n    }\n    const sorted = heap.deheapSort(currentGraph);\n    return sorted;\n  };\n}\n\nexport type InitFromRandomFn = (\n  nNeighbors: number,\n  data: Vector,\n  queryPoints: Vector,\n  _heap: heap.Heap,\n  random: RandomFn\n) => void;\n\nexport type InitFromTreeFn = (\n  _tree: tree.FlatTree,\n  data: Vector,\n  queryPoints: Vector,\n  _heap: heap.Heap,\n  random: RandomFn\n) => void;\n\nexport function makeInitializations(distanceFn: DistanceFn) {\n  function initFromRandom(\n    nNeighbors: number,\n    data: Vector,\n    queryPoints: Vector,\n    _heap: heap.Heap,\n    random: RandomFn\n  ) {\n    for (let i = 0; i < queryPoints.length; i++) {\n      const indices = utils.rejectionSample(nNeighbors, data.length, random);\n      for (let j = 0; j < indices.length; j++) {\n        if (indices[j] < 0)\n          continue;\n\n        const d = distanceFn(data[indices[j]], queryPoints[i]);\n        heap.heapPush(_heap, i, d, indices[j], 1);\n      }\n    }\n  }\n\n  function initFromTree(\n    _tree: tree.FlatTree,\n    data: Vector,\n    queryPoints: Vector,\n    _heap: heap.Heap,\n    random: RandomFn\n  ) {\n    for (let i = 0; i < queryPoints.length; i++) {\n      const indices = tree.searchFlatTree(queryPoints[i], _tree, random);\n\n      for (let j = 0; j < indices.length; j++) {\n        if (indices[j] < 0)\n          return;\n\n        const d = distanceFn(data[indices[j]], queryPoints[i]);\n        heap.heapPush(_heap, i, d, indices[j], 1);\n      }\n    }\n    return;\n  }\n\n  return {initFromRandom, initFromTree};\n}\n\nexport type SearchFn = (\n  data: Vector,\n  graph: matrix.SparseMatrix,\n  initialization: heap.Heap,\n  queryPoints: Vector\n) => heap.Heap;\n\nexport function makeInitializedNNSearch(distanceFn: DistanceFn) {\n  return function nnSearchFn(\n    data: Vector,\n    graph: matrix.SparseMatrix,\n    initialization: heap.Heap,\n    queryPoints: Vector\n  ) {\n    const {indices, indptr} = matrix.getCSR(graph);\n\n    for (let i = 0; i < queryPoints.length; i++) {\n      const tried = new Set(initialization[0][i]);\n      while (true) {\n        // Find smallest flagged vertex\n        const vertex = heap.smallestFlagged(initialization, i);\n\n        if (vertex === -1)\n          break;\n\n        const candidates = indices.slice(indptr[vertex], indptr[vertex + 1]);\n        for (const candidate of candidates) {\n          if (\n            candidate === vertex ||\n            candidate === -1 ||\n            tried.has(candidate)\n          )\n            continue;\n\n          const d = distanceFn(data[candidate], queryPoints[i]);\n          heap.uncheckedHeapPush(initialization, i, d, candidate, 1);\n          tried.add(candidate);\n        }\n      }\n    }\n    return initialization;\n  };\n}\n\nexport function initializeSearch(\n  forest: tree.FlatTree[],\n  data: Vector,\n  queryPoints: Vector,\n  nNeighbors: number,\n  initFromRandom: InitFromRandomFn,\n  initFromTree: InitFromTreeFn,\n  random: RandomFn\n) {\n  const results = heap.makeHeap(queryPoints.length, nNeighbors);\n  initFromRandom(nNeighbors, data, queryPoints, results, random);\n  if (forest) {\n    for (const tree of forest)\n      initFromTree(tree, data, queryPoints, results, random);\n  }\n  return results;\n}\n"]}","import isArray from 'is-any-array';\n\nimport errorCalculation from './errorCalculation';\nimport step from './step';\n\n/**\n * Curve fitting algorithm\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @param {object} [options] - Options object\n * @param {number} [options.damping] - Levenberg-Marquardt parameter\n * @param {number} [options.gradientDifference = 10e-2] - Adjustment for decrease the damping parameter\n * @param {Array<number>} [options.minValues] - Minimum allowed values for parameters\n * @param {Array<number>} [options.maxValues] - Maximum allowed values for parameters\n * @param {Array<number>} [options.initialValues] - Array of initial parameter values\n * @param {number} [options.maxIterations = 100] - Maximum of allowed iterations\n * @param {number} [options.errorTolerance = 10e-3] - Minimum uncertainty allowed for each point\n * @return {{parameterValues: Array<number>, parameterError: number, iterations: number}}\n */\nexport default function levenbergMarquardt(\n data,\n parameterizedFunction,\n options = {},\n) {\n let {\n maxIterations = 100,\n gradientDifference = 10e-2,\n damping = 0,\n errorTolerance = 10e-3,\n minValues,\n maxValues,\n initialValues,\n } = options;\n\n if (damping <= 0) {\n throw new Error('The damping option must be a positive number');\n } else if (!data.x || !data.y) {\n throw new Error('The data parameter must have x and y elements');\n } else if (\n !isArray(data.x) ||\n data.x.length < 2 ||\n !isArray(data.y) ||\n data.y.length < 2\n ) {\n throw new Error(\n 'The data parameter elements must be an array with more than 2 points',\n );\n } else if (data.x.length !== data.y.length) {\n throw new Error('The data parameter elements must have the same size');\n }\n\n let parameters =\n initialValues || new Array(parameterizedFunction.length).fill(1);\n let parLen = parameters.length;\n maxValues = maxValues || new Array(parLen).fill(Number.MAX_SAFE_INTEGER);\n minValues = minValues || new Array(parLen).fill(Number.MIN_SAFE_INTEGER);\n\n if (maxValues.length !== minValues.length) {\n throw new Error('minValues and maxValues must be the same size');\n }\n\n if (!isArray(parameters)) {\n throw new Error('initialValues must be an array');\n }\n\n let error = errorCalculation(data, parameters, parameterizedFunction);\n\n let converged = error <= errorTolerance;\n\n let iteration;\n for (iteration = 0; iteration < maxIterations && !converged; iteration++) {\n parameters = step(\n data,\n parameters,\n damping,\n gradientDifference,\n parameterizedFunction,\n );\n\n for (let k = 0; k < parLen; k++) {\n parameters[k] = Math.min(\n Math.max(minValues[k], parameters[k]),\n maxValues[k],\n );\n }\n\n error = errorCalculation(data, parameters, parameterizedFunction);\n if (isNaN(error)) break;\n converged = error <= errorTolerance;\n }\n\n return {\n parameterValues: parameters,\n parameterError: error,\n iterations: iteration,\n };\n}\n","import { dmLinearIndex } from '../distance-matrix';\nexport class TSNE {\n assert(condition, message) {\n if (!condition)\n throw message || 'Assertion failed';\n }\n // syntax sugar\n getopt(opt, field, defaultval) {\n if (opt.hasOwnProperty(field))\n return opt[field];\n else\n return defaultval;\n }\n gaussRandom() {\n if (this.returnV) {\n this.returnV = false;\n return this.vValue;\n }\n const u = 2 * this.random() - 1;\n const v = 2 * this.random() - 1;\n const r = u * u + v * v;\n if (r === 0 || r > 1)\n return this.gaussRandom();\n const c = Math.sqrt(-2 * Math.log(r) / r);\n this.vValue = v * c; // cache this for next function call for efficiency\n this.returnV = true;\n return u * c;\n }\n // return random normal number\n randn(mu, std) {\n return mu + this.gaussRandom() * std;\n }\n // utilitity that creates contiguous vector of zeros of size n\n zeros(n) {\n if (typeof (n) === 'undefined' || isNaN(n))\n return new Float32Array();\n if (typeof ArrayBuffer === 'undefined') {\n // lacking browser support\n const arr = new Float32Array(n);\n for (let i = 0; i < n; i++)\n arr[i] = 0;\n return arr;\n }\n else {\n return new Float32Array(n); // typed arrays are faster\n }\n }\n // utility that returns 2d array filled with random numbers\n // or with value s, if provided\n randn2d(n, d, s) {\n const uses = typeof s !== 'undefined';\n const x = (new Array(n)).fill(null).map(() => new Float32Array(d));\n if (uses) {\n for (let i = 0; i < n; i++)\n x[i] = new Float32Array(d).fill(s);\n }\n else {\n for (let i = 0; i < n; i++) {\n for (let j = 0; j < d; j++)\n x[i][j] = this.randn(0.0, 1e-4);\n }\n }\n return x;\n }\n // compute L2 distance between two vectors\n l2(x1, x2) {\n const D = x1.length;\n let d = 0;\n for (let i = 0; i < D; i++) {\n const x1i = x1[i];\n const x2i = x2[i];\n d += (x1i - x2i) * (x1i - x2i);\n }\n return d;\n }\n // compute pairwise distance in all vectors in X\n xtod(X) {\n const N = X.length;\n const dist = this.zeros(N * N); // allocate contiguous array\n for (let i = 0; i < N; i++) {\n for (let j = i + 1; j < N; j++) {\n const d = this.l2(X[i], X[j]);\n dist[i * N + j] = d;\n dist[j * N + i] = d;\n }\n }\n return dist;\n }\n getIterSize(rowSize) {\n if (rowSize <= 2000)\n return 100;\n else if (rowSize <= 3000)\n return 90;\n else if (rowSize <= 5000)\n return 80;\n else\n return 70;\n }\n // compute (p_{i|j} + p_{j|i})/(2n)\n d2p(D, perplexity, tol, rowSize) {\n // const nf = Math.sqrt(D.length); // this better be an integer\n // const n = Math.floor(nf);\n // this.assert(n === nf, 'D should have square number of elements.');\n const indexer = dmLinearIndex(rowSize);\n const distances = new Float32Array(rowSize * rowSize);\n for (let i = 0; i < rowSize; i++) {\n for (let j = i + 1; j < rowSize; j++)\n distances[i * rowSize + j] = distances[j * rowSize + i] = D[indexer(i, j)];\n }\n const n = rowSize;\n const hTarget = Math.log(perplexity); // target entropy of distribution\n const P = this.zeros(n * n); // temporary probability matrix\n const prow = this.zeros(n); // a temporary storage compartment\n for (let i = 0; i < n; i++) {\n let betamin = -Infinity;\n let betamax = Infinity;\n let beta = 1; // initial value of precision\n let done = false;\n const maxtries = Math.floor(this.getIterSize(rowSize) / 5);\n // perform binary search to find a suitable precision beta\n // so that the entropy of the distribution is appropriate\n let num = 0;\n while (!done) {\n //debugger;\n // compute entropy and kernel row with beta precision\n let psum = 0.0;\n for (let j = 0; j < n; j++) {\n const pj = i === j ? 0 : Math.exp(-distances[i * n + j] * beta);\n prow[j] = pj;\n psum += pj;\n }\n // normalize p and compute entropy\n let nHere = 0.0;\n for (let j = 0; j < n; j++) {\n let pj;\n if (psum === 0)\n pj = 0;\n else\n pj = prow[j] / psum;\n prow[j] = pj;\n if (pj > 1e-7)\n nHere -= pj * Math.log(pj);\n }\n // adjust beta based on result\n if (nHere > hTarget) {\n // entropy was too high (distribution too diffuse)\n // so we need to increase the precision for more peaky distribution\n betamin = beta; // move up the bounds\n if (betamax === Infinity)\n beta = beta * 2;\n else\n beta = (beta + betamax) / 2;\n }\n else {\n // converse case. make distrubtion less peaky\n betamax = beta;\n if (betamin === -Infinity)\n beta = beta / 2;\n else\n beta = (beta + betamin) / 2;\n }\n // stopping conditions: too many tries or got a good precision\n num++;\n if (Math.abs(nHere - hTarget) < tol)\n done = true;\n if (num >= maxtries)\n done = true;\n }\n // console.log('data point ' + i + ' gets precision ' + beta + ' after ' + num + ' binary search steps.');\n // copy over the final prow to P at row i\n for (let j = 0; j < n; j++)\n P[i * n + j] = prow[j];\n } // end loop over examples i\n // symmetrize P and normalize it to sum to 1 over all ij\n const pOut = this.zeros(n * n);\n const N2 = n * 2;\n for (let i = 0; i < n; i++) {\n for (let j = 0; j < n; j++)\n pOut[i * n + j] = Math.max((P[i * n + j] + P[j * n + i]) / N2, 1e-100);\n }\n return pOut;\n }\n // helper function\n sign(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }\n constructor(opt) {\n this.iter = 0;\n this.random = Math.random;\n // return 0 mean unit standard deviation random number\n this.returnV = false;\n this.vValue = 0.0;\n opt = opt || {};\n this.perplexity = this.getopt(opt, 'perplexity', 30); // effective number of nearest neighbors\n this.dim = this.getopt(opt, 'dim', 2); // by default 2-D tSNE\n this.epsilon = this.getopt(opt, 'epsilon', 10); // learning rate\n this.random = this.getopt(opt, 'random', Math.random); // random number generator\n }\n // this function takes a set of high-dimensional points\n // and creates matrix P from them using gaussian kernel\n initDataRaw(X) {\n const N = X.length;\n const D = X[0].length;\n this.assert(N > 0, ' X is empty? You must have some data!');\n this.assert(D > 0, ' X[0] is empty? Where is the data?');\n const dists = this.xtod(X); // convert X to distances using gaussian kernel\n this.P = this.d2p(dists, this.perplexity, 1e-4, D); // attach to object\n this.N = N; // back up the size of the dataset\n this.initSolution(); // refresh this\n }\n // this function takes a given distance matrix and creates\n // matrix P from them.\n // D is assumed to be provided as a list of lists, and should be symmetric\n initDataDist(D, rowSize) {\n const N = D.length;\n this.assert(N > 0, ' X is empty? You must have some data!');\n // convert D to a (fast) typed array version\n // dists.forEach((d) => console.log(d));\n console.time('distances to matrix');\n this.P = this.d2p(D, this.perplexity, 1e-4, rowSize);\n console.timeEnd('distances to matrix');\n this.N = rowSize;\n this.initSolution(); // refresh this\n }\n // (re)initializes the solution to random\n initSolution() {\n // generate random solution to t-SNE\n this.Y = this.randn2d(this.N, this.dim); // the solution\n this.gains = this.randn2d(this.N, this.dim, 1.0); // step gains to accelerate progress in unchanging directions\n this.ystep = this.randn2d(this.N, this.dim, 0.0); // momentum accumulator\n this.iter = 0;\n }\n // return pointer to current solution\n getSolution() {\n return this.Y;\n }\n // perform a single step of optimization to improve the embedding\n step() {\n this.iter += 1;\n const N = this.N;\n const cg = this.costGrad(this.Y); // evaluate gradient\n const cost = cg.cost;\n const grad = cg.grad;\n // perform gradient step\n const ymean = this.zeros(this.dim);\n for (let i = 0; i < N; i++) {\n for (let d = 0; d < this.dim; d++) {\n const gid = grad[i][d];\n const sid = this.ystep[i][d];\n const gainid = this.gains[i][d];\n // compute gain update\n let newgain = this.sign(gid) === this.sign(sid) ? gainid * 0.8 : gainid + 0.2;\n if (newgain < 0.01)\n newgain = 0.01; // clamp\n this.gains[i][d] = newgain; // store for next turn\n // compute momentum step direction\n const momval = this.iter < 250 ? 0.5 : 0.8;\n const newsid = momval * sid - this.epsilon * newgain * grad[i][d];\n this.ystep[i][d] = newsid; // remember the step we took\n // step!\n this.Y[i][d] += newsid;\n ymean[d] += this.Y[i][d]; // accumulate mean so that we can center later\n }\n }\n // reproject Y to be zero mean\n for (let i = 0; i < N; i++) {\n for (let d = 0; d < this.dim; d++)\n this.Y[i][d] -= ymean[d] / N;\n }\n //if(this.iter%100===0) console.log('iter ' + this.iter + ', cost: ' + cost);\n return cost; // return current cost\n }\n // for debugging: gradient check\n debugGrad() {\n const N = this.N;\n const cg = this.costGrad(this.Y); // evaluate gradient\n //const cost = cg.cost;\n const grad = cg.grad;\n const e = 1e-5;\n for (let i = 0; i < N; i++) {\n for (let d = 0; d < this.dim; d++) {\n const yold = this.Y[i][d];\n this.Y[i][d] = yold + e;\n const cg0 = this.costGrad(this.Y);\n this.Y[i][d] = yold - e;\n const cg1 = this.costGrad(this.Y);\n const analytic = grad[i][d];\n const numerical = (cg0.cost - cg1.cost) / (2 * e);\n console.log(i + ',' + d + ': gradcheck analytic: ' + analytic + ' vs. numerical: ' + numerical);\n this.Y[i][d] = yold;\n }\n }\n }\n // return cost and gradient, given an arrangement\n costGrad(Y) {\n const N = this.N;\n const dim = this.dim; // dim of output space\n const P = this.P;\n const pmul = this.iter < 100 ? 4 : 1; // trick that helps with local optima\n // compute current Q distribution, unnormalized first\n this.quArr ?? (this.quArr = this.zeros(N * N));\n let qsum = 0.0;\n for (let i = 0; i < N; i++) {\n for (let j = i + 1; j < N; j++) {\n const dsum = new Array(dim).reduce((prev, _, d) => prev + Math.pow(Y[i][d] - Y[j][d], 2), 0);\n const qu = 1.0 / (1.0 + dsum); // Student t-distribution\n this.quArr[i * N + j] = qu;\n this.quArr[j * N + i] = qu;\n qsum += 2 * qu;\n }\n }\n // normalize Q distribution to sum to 1\n //const NN = N * N;\n //const Q = this.zeros(NN);\n let cost = 0.0;\n const grad = new Array(N).fill(null).map(() => (new Float32Array(dim)).fill(0.0));\n for (let i = 0; i < N; i++) {\n // const gsum = new Float32Array(dim).fill(0.0); // init grad for point i\n for (let j = i + 1; j < N; j++) {\n const Q = Math.max(this.quArr[i * N + j] / qsum, 1e-100);\n cost += (-P[i * N + j] * Math.log(Q)) * 2; // accumulate cost (the non-constant portion at least...)\n const premult = 4 * (pmul * P[i * N + j] - Q) * this.quArr[i * N + j];\n //console.log(premult, Q, i, j);\n for (let d = 0; d < dim; d++) {\n grad[i][d] += premult * (Y[i][d] - Y[j][d]);\n grad[j][d] += premult * (Y[j][d] - Y[i][d]);\n }\n }\n //grad[i] = gsum;\n }\n return { cost, grad };\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"t-sne.js","sourceRoot":"","sources":["t-sne.ts"],"names":[],"mappings":"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","sourcesContent":["import {dmLinearIndex} from '../distance-matrix';\n\n\nexport class TSNE {\n  private perplexity: number;\n  private dim: number;\n  private epsilon: number;\n  private iter = 0;\n  private N!: number;\n  private P!: Float32Array;\n  private Y!: any[];\n  private gains!: any[];\n  private ystep!: any[];\n  private random: () => number = Math.random;\n  private assert(condition: any, message: any) {\n    if (!condition) throw message || 'Assertion failed';\n  }\n\n  // syntax sugar\n  private getopt(opt: {[_: string]: any}, field: string, defaultval: any) {\n    if (opt.hasOwnProperty(field))\n      return opt[field];\n    else\n      return defaultval;\n  }\n\n    // return 0 mean unit standard deviation random number\n    private returnV = false;\n    private vValue = 0.0;\n    gaussRandom(): number {\n      if (this.returnV) {\n        this.returnV = false;\n        return this.vValue;\n      }\n      const u = 2 * this.random() - 1;\n      const v = 2 * this.random() - 1;\n      const r = u * u + v * v;\n      if (r === 0 || r > 1) return this.gaussRandom();\n      const c = Math.sqrt(-2 * Math.log(r) / r);\n      this.vValue = v * c; // cache this for next function call for efficiency\n      this.returnV = true;\n      return u * c;\n    }\n\n    // return random normal number\n    private randn(mu: number, std: number) {\n      return mu + this.gaussRandom() * std;\n    }\n\n    // utilitity that creates contiguous vector of zeros of size n\n    private zeros(n: number) {\n      if (typeof (n) === 'undefined' || isNaN(n)) return new Float32Array();\n      if (typeof ArrayBuffer === 'undefined') {\n        // lacking browser support\n        const arr = new Float32Array(n);\n        for (let i = 0; i < n; i++) arr[i] = 0;\n        return arr;\n      } else {\n        return new Float32Array(n); // typed arrays are faster\n      }\n    }\n\n    // utility that returns 2d array filled with random numbers\n    // or with value s, if provided\n    private randn2d(n: number, d: number, s?: number) {\n      const uses = typeof s !== 'undefined';\n      const x = (new Array(n)).fill(null).map(() => new Float32Array(d));\n      if (uses) {\n        for (let i = 0; i < n; i++)\n          x[i] = new Float32Array(d).fill(s);\n      } else {\n        for (let i = 0; i < n; i++) {\n          for (let j = 0; j < d; j++)\n            x[i][j] = this.randn(0.0, 1e-4);\n        }\n      }\n      return x;\n    }\n\n    // compute L2 distance between two vectors\n    private l2(x1: number[], x2: number[]) {\n      const D = x1.length;\n      let d = 0;\n      for (let i = 0; i < D; i++) {\n        const x1i = x1[i];\n        const x2i = x2[i];\n        d += (x1i - x2i) * (x1i - x2i);\n      }\n      return d;\n    }\n\n    // compute pairwise distance in all vectors in X\n    private xtod(X: Array< Array<number> >) {\n      const N = X.length;\n      const dist = this.zeros(N * N); // allocate contiguous array\n      for (let i = 0; i < N; i++) {\n        for (let j = i + 1; j < N; j++) {\n          const d = this.l2(X[i], X[j]);\n          dist[i * N + j] = d;\n          dist[j * N + i] = d;\n        }\n      }\n      return dist;\n    }\n\n    public getIterSize(rowSize: number) {\n      if (rowSize <= 2000)\n        return 100;\n      else if (rowSize <= 3000)\n        return 90;\n      else if (rowSize <= 5000)\n        return 80;\n      else\n        return 70;\n    }\n\n    // compute (p_{i|j} + p_{j|i})/(2n)\n    private d2p(D: Float32Array, perplexity: number, tol: number, rowSize: number) {\n      // const nf = Math.sqrt(D.length); // this better be an integer\n      // const n = Math.floor(nf);\n      // this.assert(n === nf, 'D should have square number of elements.');\n      const indexer = dmLinearIndex(rowSize);\n      const distances = new Float32Array(rowSize * rowSize);\n      for (let i = 0; i < rowSize; i++) {\n        for (let j = i + 1; j < rowSize; j++)\n          distances[i * rowSize + j] = distances[j * rowSize + i] = D[indexer(i, j)];\n      }\n      const n = rowSize;\n      const hTarget = Math.log(perplexity); // target entropy of distribution\n      const P = this.zeros(n * n); // temporary probability matrix\n      const prow = this.zeros(n); // a temporary storage compartment\n      for (let i = 0; i < n; i++) {\n        let betamin = -Infinity;\n        let betamax = Infinity;\n        let beta = 1; // initial value of precision\n        let done = false;\n        const maxtries = Math.floor(this.getIterSize(rowSize) / 5);\n\n        // perform binary search to find a suitable precision beta\n        // so that the entropy of the distribution is appropriate\n        let num = 0;\n        while (!done) {\n          //debugger;\n\n          // compute entropy and kernel row with beta precision\n          let psum = 0.0;\n          for (let j = 0; j < n; j++) {\n            const pj = i === j ? 0 : Math.exp(- distances[i * n + j] * beta);\n            prow[j] = pj;\n            psum += pj;\n          }\n          // normalize p and compute entropy\n          let nHere = 0.0;\n          for (let j = 0; j < n; j++) {\n            let pj;\n            if (psum === 0)\n              pj = 0;\n            else\n              pj = prow[j] / psum;\n\n            prow[j] = pj;\n            if (pj > 1e-7) nHere -= pj * Math.log(pj);\n          }\n\n          // adjust beta based on result\n          if (nHere > hTarget) {\n            // entropy was too high (distribution too diffuse)\n            // so we need to increase the precision for more peaky distribution\n            betamin = beta; // move up the bounds\n            if (betamax === Infinity) beta = beta * 2; else beta = (beta + betamax) / 2;\n          } else {\n            // converse case. make distrubtion less peaky\n            betamax = beta;\n            if (betamin === -Infinity) beta = beta / 2; else beta = (beta + betamin) / 2;\n          }\n\n          // stopping conditions: too many tries or got a good precision\n          num++;\n          if (Math.abs(nHere - hTarget) < tol) done = true;\n          if (num >= maxtries) done = true;\n        }\n\n        // console.log('data point ' + i + ' gets precision ' + beta + ' after ' + num + ' binary search steps.');\n        // copy over the final prow to P at row i\n        for (let j = 0; j < n; j++) P[i * n + j] = prow[j];\n      } // end loop over examples i\n\n      // symmetrize P and normalize it to sum to 1 over all ij\n      const pOut = this.zeros(n * n);\n      const N2 = n * 2;\n      for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++)\n          pOut[i * n + j] = Math.max((P[i * n + j] + P[j * n + i]) / N2, 1e-100);\n      }\n\n      return pOut;\n    }\n\n    // helper function\n    private sign(x: number) { return x > 0 ? 1 : x < 0 ? -1 : 0; }\n\n    constructor(opt: {[_: string]: any}) {\n      opt = opt || {};\n      this.perplexity = this.getopt(opt, 'perplexity', 30); // effective number of nearest neighbors\n      this.dim = this.getopt(opt, 'dim', 2); // by default 2-D tSNE\n      this.epsilon = this.getopt(opt, 'epsilon', 10); // learning rate\n      this.random = this.getopt(opt, 'random', Math.random); // random number generator\n    }\n\n    // this function takes a set of high-dimensional points\n    // and creates matrix P from them using gaussian kernel\n    public initDataRaw(X: Array<Array<any>>) {\n      const N = X.length;\n      const D = X[0].length;\n      this.assert(N > 0, ' X is empty? You must have some data!');\n      this.assert(D > 0, ' X[0] is empty? Where is the data?');\n      const dists = this.xtod(X); // convert X to distances using gaussian kernel\n      this.P = this.d2p(dists, this.perplexity, 1e-4, D); // attach to object\n      this.N = N; // back up the size of the dataset\n      this.initSolution(); // refresh this\n    }\n\n    // this function takes a given distance matrix and creates\n    // matrix P from them.\n    // D is assumed to be provided as a list of lists, and should be symmetric\n    public initDataDist(D: Float32Array, rowSize: number) {\n      const N = D.length;\n      this.assert(N > 0, ' X is empty? You must have some data!');\n      // convert D to a (fast) typed array version\n      // dists.forEach((d) => console.log(d));\n      console.time('distances to matrix');\n      this.P = this.d2p(D, this.perplexity, 1e-4, rowSize);\n      console.timeEnd('distances to matrix');\n      this.N = rowSize;\n      this.initSolution(); // refresh this\n    }\n\n    // (re)initializes the solution to random\n    public initSolution() {\n      // generate random solution to t-SNE\n      this.Y = this.randn2d(this.N, this.dim); // the solution\n      this.gains = this.randn2d(this.N, this.dim, 1.0); // step gains to accelerate progress in unchanging directions\n      this.ystep = this.randn2d(this.N, this.dim, 0.0); // momentum accumulator\n      this.iter = 0;\n    }\n\n    // return pointer to current solution\n    public getSolution() {\n      return this.Y;\n    }\n\n    // perform a single step of optimization to improve the embedding\n    public step() {\n      this.iter += 1;\n      const N = this.N;\n      const cg = this.costGrad(this.Y); // evaluate gradient\n      const cost = cg.cost;\n      const grad = cg.grad;\n\n      // perform gradient step\n      const ymean = this.zeros(this.dim);\n      for (let i = 0; i < N; i++) {\n        for (let d = 0; d < this.dim; d++) {\n          const gid = grad[i][d];\n          const sid = this.ystep[i][d];\n          const gainid = this.gains[i][d];\n\n          // compute gain update\n          let newgain = this.sign(gid) === this.sign(sid) ? gainid * 0.8 : gainid + 0.2;\n          if (newgain < 0.01) newgain = 0.01; // clamp\n          this.gains[i][d] = newgain; // store for next turn\n\n          // compute momentum step direction\n          const momval = this.iter < 250 ? 0.5 : 0.8;\n          const newsid = momval * sid - this.epsilon * newgain * grad[i][d];\n          this.ystep[i][d] = newsid; // remember the step we took\n\n          // step!\n          this.Y[i][d] += newsid;\n\n          ymean[d] += this.Y[i][d]; // accumulate mean so that we can center later\n        }\n      }\n\n      // reproject Y to be zero mean\n      for (let i = 0; i < N; i++) {\n        for (let d = 0; d < this.dim; d++)\n          this.Y[i][d] -= ymean[d] / N;\n      }\n\n      //if(this.iter%100===0) console.log('iter ' + this.iter + ', cost: ' + cost);\n      return cost; // return current cost\n    }\n\n    // for debugging: gradient check\n    public debugGrad() {\n      const N = this.N;\n\n      const cg = this.costGrad(this.Y); // evaluate gradient\n      //const cost = cg.cost;\n      const grad = cg.grad;\n\n      const e = 1e-5;\n      for (let i = 0; i < N; i++) {\n        for (let d = 0; d < this.dim; d++) {\n          const yold = this.Y[i][d];\n\n          this.Y[i][d] = yold + e;\n          const cg0 = this.costGrad(this.Y);\n\n          this.Y[i][d] = yold - e;\n          const cg1 = this.costGrad(this.Y);\n\n          const analytic = grad[i][d];\n          const numerical = (cg0.cost - cg1.cost) / (2 * e);\n          console.log(i + ',' + d + ': gradcheck analytic: ' + analytic + ' vs. numerical: ' + numerical);\n\n          this.Y[i][d] = yold;\n        }\n      }\n    }\n\n    private quArr?: Float32Array;\n    // return cost and gradient, given an arrangement\n    public costGrad(Y: number[][]) {\n      const N = this.N;\n      const dim = this.dim; // dim of output space\n      const P = this.P;\n\n      const pmul = this.iter < 100 ? 4 : 1; // trick that helps with local optima\n\n      // compute current Q distribution, unnormalized first\n      this.quArr ??= this.zeros(N * N);\n      let qsum = 0.0;\n      for (let i = 0; i < N; i++) {\n        for (let j = i + 1; j < N; j++) {\n          const dsum = new Array(dim).reduce((prev, _, d) => prev + Math.pow(Y[i][d] - Y[j][d], 2), 0);\n          const qu = 1.0 / (1.0 + dsum); // Student t-distribution\n          this.quArr[i * N + j] = qu;\n          this.quArr[j * N + i] = qu;\n          qsum += 2 * qu;\n        }\n      }\n      // normalize Q distribution to sum to 1\n      //const NN = N * N;\n      //const Q = this.zeros(NN);\n      let cost = 0.0;\n      const grad = new Array(N).fill(null).map(() => (new Float32Array(dim)).fill(0.0));\n      for (let i = 0; i < N; i++) {\n        // const gsum = new Float32Array(dim).fill(0.0); // init grad for point i\n        for (let j = i + 1; j < N; j++) {\n          const Q = Math.max(this.quArr[i * N + j] / qsum, 1e-100);\n          cost += (- P[i * N + j] * Math.log(Q)) * 2; // accumulate cost (the non-constant portion at least...)\n          const premult = 4 * (pmul * P[i * N + j] - Q) * this.quArr[i * N + j];\n          //console.log(premult, Q, i, j);\n          for (let d = 0; d < dim; d++) {\n            grad[i][d] += premult * (Y[i][d] - Y[j][d]);\n            grad[j][d] += premult * (Y[j][d] - Y[i][d]);\n          }\n        }\n        //grad[i] = gsum;\n      }\n\n      return {cost, grad};\n    }\n}\n"]}","/** Proxy for DistanceMatrix class. Allows to index matrix as matrix[i][j]\n * Note: much slower than direct indexing, but still much faster than recalculating distances.\n * will be used for T-SNE mainly.\n * @param {Float32Array}condensedArray - array of distances between all pairs of objects\n * @param {number}size - number of comparebles in matrix\n * @return {Float32Array} - proxy for condensedArray\n*/\nexport function distanceMatrixProxy(condensedArray, size) {\n const linearFunc = dmLinearIndex(size);\n function linearIndex(i, j) {\n const iNum = Number(i);\n const jNum = Number(j);\n return linearFunc(iNum, jNum);\n }\n function idx2Handler(idx1) {\n return ({\n get(target, idx2, _receiver) {\n if (idx1 === idx2)\n return 0;\n const linearIdx = Number(idx1) > Number(idx2) ? linearIndex(idx2, idx1) : linearIndex(idx1, idx2);\n return target[linearIdx];\n },\n });\n }\n const idx1Handler = {\n get(target, idx1, _receiver) {\n if (idx1 === 'length')\n return size;\n return new Proxy(target, idx2Handler(idx1));\n },\n };\n return new Proxy(condensedArray, idx1Handler);\n}\nexport function dmLinearIndex(size) {\n return (i, j) => size * i + j - Math.floor(((i + 2) * (i + 1)) / 2);\n}\n//# sourceMappingURL=data:application/json;base64,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","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nlet gpuAdapter = null;\nlet gpuDevice = null;\nexport function getGPUDevice() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!navigator.gpu) {\n console.error('WebGPU is not supported in this browser');\n return null;\n }\n if (!gpuAdapter) {\n //reason: only here we get the gpuAdapter\n // eslint-disable-next-line no-restricted-syntax\n gpuAdapter = yield navigator.gpu.requestAdapter({ powerPreference: 'high-performance' });\n if (gpuAdapter == null)\n return null;\n }\n let isLost = false;\n if (gpuDevice) {\n gpuDevice.lost.then(() => {\n isLost = true;\n });\n yield new Promise((r) => setTimeout(r, 10)); // wait to see if the device is lost\n }\n if (!gpuDevice || isLost) {\n const requiredBufferSize = 1000000000; // ~1000MB\n const adapterLimits = gpuAdapter.limits;\n const buffferSizeLimit = adapterLimits.maxBufferSize;\n const storageBufferSizeLimit = adapterLimits.maxStorageBufferBindingSize;\n try {\n gpuDevice = yield gpuAdapter.requestDevice({ requiredLimits: {\n maxBufferSize: Math.min(buffferSizeLimit, requiredBufferSize),\n maxStorageBufferBindingSize: Math.min(storageBufferSizeLimit, requiredBufferSize)\n } });\n return gpuDevice;\n }\n catch (e) {\n console.error('Failed to create device with required limits', e);\n gpuDevice = yield gpuAdapter.requestDevice();\n return gpuDevice;\n }\n }\n return gpuDevice;\n });\n}\nexport function getGPUAdapterDescription() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!navigator.gpu) {\n console.error('WebGPU is not supported in this browser');\n return null;\n }\n if (!gpuAdapter) {\n // reason: only here we get the gpuAdapter\n // eslint-disable-next-line no-restricted-syntax\n gpuAdapter = yield navigator.gpu.requestAdapter();\n if (gpuAdapter == null)\n return null;\n }\n let info = null;\n if ('info' in gpuAdapter)\n info = gpuAdapter.info;\n // this option is sort of deprecated but still available in every initial release\n else if ('requestAdapterInfo' in gpuAdapter && typeof gpuAdapter.requestAdapterInfo === 'function')\n info = (yield gpuAdapter.requestAdapterInfo());\n if (!info)\n return null;\n const outString = replaceEmptyString(info.description, replaceEmptyString(info.vendor, 'No GPU description available'));\n return outString;\n });\n}\nfunction replaceEmptyString(str, replacement) {\n return !str || str == '' ? replacement : str;\n}\n//# sourceMappingURL=getGPUDevice.js.map","function euclideanAggregationWgsl(arraySize) {\n return `\n var sum = 0.0;\n for (var i = 0u; i < ${arraySize}; i = i + 1u) {\n sum = sum + distances[i] * distances[i] * computeInfo.weights[i] * computeInfo.weights[i];\n }\n return sqrt(sum);\n `;\n}\n;\nfunction manhattanAggregationWgsl(arraySize) {\n return `\n var sum = 0.0;\n for (var i = 0u; i < ${arraySize}; i = i + 1u) {\n sum = sum + abs(distances[i]) * computeInfo.weights[i];\n }\n return sum;\n `;\n}\nexport var WEBGSLAGGREGATION;\n(function (WEBGSLAGGREGATION) {\n WEBGSLAGGREGATION[\"EUCLIDEAN\"] = \"EUCLIDEAN\";\n WEBGSLAGGREGATION[\"MANHATTAN\"] = \"MANHATTAN\";\n})(WEBGSLAGGREGATION || (WEBGSLAGGREGATION = {}));\nexport const WEBGSLAGGREGATIONFUNCTIONS = {\n [WEBGSLAGGREGATION.EUCLIDEAN]: euclideanAggregationWgsl,\n [WEBGSLAGGREGATION.MANHATTAN]: manhattanAggregationWgsl\n};\n//# sourceMappingURL=webGPU-aggregation.js.map","/* eslint-disable max-len */\n// in all the functions below, the variables a and b are assumed to be arrays of uint32/f32\n//values which are infered from the code this chunk is injected into\n// also, we have access to computeInfo struct, which contains the following fields:\n// computeInfo.entrySizes: array of arrays of u32 containing the sizes of the entries\n// other fields are specific to the distance function should be injected from the main script that calls this function,\n// and should be available in the supplementaryInfo struct\n// like the similarity matrix for monomer chemical distance.\n// the getProcessInfo function should return correct buffer allocation mechanism for the supplementaryInfo,\n// for every entry list\n// the maxDistance variable is also assumed to be available in the\n// scope of the function, in case of knn it is the distance in the last postion of knn on this index,\n// in case of sparse matrix, it can be just the threshold for the distance.\n// hamming distance for sequnences of uint32 arrays of max length ${maxArraySize}\nexport function webGPUHamming(_maxArraySize, entryIndex) {\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n let maxLength: u32 = max(aLength, bLength);\n let minLength: u32 = min(aLength, bLength);\n let sizeDiff: u32 = maxLength - minLength;\n \n let maxIntDistance = ceil(maxDistance * f32(maxLength)) - f32(sizeDiff);\n\n var diff: f32 = 0.0;\n for (var i = 0u; i < ${_maxArraySize}; i = i + 1u) {\n diff = diff + f32(a[i] != b[i]);\n if (diff > maxIntDistance) {\n return 1.0;\n }\n }\n diff += f32(sizeDiff);\n return diff / ${_maxArraySize};\n `;\n}\nexport function webGPUMonomerChemicalDistance(_maxArraySize, entryIndex) {\n // it is assumet that suppInfo struct contains correct matrix called similarityMatrix${entryIndex}, (similarityMatrix0, similarityMatrix1, etc)\n // this should be guaranteed by the getProcessInfo function.\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n let maxLength: u32 = max(aLength, bLength);\n let minLength: u32 = min(aLength, bLength);\n let sizeDiff: u32 = maxLength - minLength;\n \n let maxIntDistance = ceil(maxDistance * f32(maxLength)) - f32(sizeDiff);\n\n let simMatrix = &(suppInfo.similarityMatrix${entryIndex}); // using pointers make things faster\n var diff: f32 = 0.0;\n for (var i = 0u; i < ${_maxArraySize}; i = i + 1u) {\n diff = diff + 1.0 - (*simMatrix)[u32(a[i])][u32(b[i])];\n if (diff > maxIntDistance) {\n return 1.0;\n }\n }\n diff += f32(sizeDiff);\n return diff / ${_maxArraySize};\n `;\n}\nexport function webGPULevenstein(maxArraySize, entryIndex) {\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n let maxLength: u32 = max(aLength, bLength);\n let minLength: u32 = min(aLength, bLength);\n\n let maxIntDistance = ceil(maxDistance * f32(maxLength));\n\n // we will store two arrays as matrix and swap the working indices per pass.\n // this way we can reduce memory usage per computation to just O(aLength)\n // the grid will have aLength + 1 columns and bLength + 1 rows\n // this will be guaranteed by iteration, but the array sizes must be known at compile time, so we will use a fixed size of maxArraySize\n var dynamicPassMat: array<array<f32, ${maxArraySize + 1}u>, 2>; // initialize to 0\n \n var prevIndex: u32 = 0;\n var curIndex: u32 = 1; // we will swap these indices per pass\n\n // initialize the first row\n for (var i = 0u; i <= aLength; i = i + 1u) {\n dynamicPassMat[prevIndex][i] = f32(i);\n }\n\n // iterate over the rows\n for (var i = 1u; i <= bLength; i = i + 1u) {\n dynamicPassMat[curIndex][0] = f32(i);\n var minEntry: f32 = f32(maxLength);\n let prevRow = &dynamicPassMat[prevIndex];\n let curRow = &dynamicPassMat[curIndex];\n let bMon = u32(b[i - 1]);\n for (var j = 1u; j <= aLength; j = j + 1u) {\n var cost: f32 = f32(a[j - 1] != bMon);\n var res: f32 = min(\n min(\n (*prevRow)[j] + 1.0, // deletion\n (*curRow)[j - 1] + 1.0, // insertion\n ),\n (*prevRow)[j - 1] + cost // substitution\n );\n (*curRow)[j] = res;\n if (res < minEntry) {\n minEntry = res;\n }\n }\n // swap the indices\n let temp: u32 = prevIndex;\n prevIndex = curIndex;\n curIndex = temp;\n if (minEntry > maxIntDistance) {\n return 1.0;\n }\n }\n\n return dynamicPassMat[prevIndex][aLength] / f32(maxLength);\n `;\n}\nexport function webGPUNeedlemanWunsch(maxArraySize, entryIndex) {\n // version of the levenshtain where the cost of substitution is customizable\n // it is assumet that suppInfo struct contains correct matrix called similarityMatrix${entryIndex}, (similarityMatrix0, similarityMatrix1, etc)\n // and gapOpenPenalty, gapExtensionPenalty\n // this should be guaranteed by the getProcessInfo function.\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n let maxLength: u32 = max(aLength, bLength);\n let minLength: u32 = min(aLength, bLength);\n \n let maxIntDistance = ceil(maxDistance * f32(maxLength));\n // we will store two arrays as matrix and swap the working indices per pass.\n // this way we can reduce memory usage per computation to just O(aLength)\n // the grid will have aLength + 1 columns and bLength + 1 rows\n // this will be guaranteed by iteration, but the array sizes must be known at compile time, so we will use a fixed size of maxArraySize\n var dynamicPassMat: array<array<f32, ${maxArraySize + 1}u>, 2>; // initialize to 0\n \n // we need to keep track of which operation led to the current cell\n // i.e. whether we came from the left, top or diagonal to assign gap open/gap extend penalty\n var verticalGaps: array<u32, ${maxArraySize + 1}u>;\n var horizontalGaps: array<u32, ${maxArraySize + 1}u>;\n\n let gapOpenPenalty: f32 = suppInfo.gapOpenPenalty${entryIndex};\n let gapExtensionPenalty: f32 = suppInfo.gapExtensionPenalty${entryIndex};\n var prevIndex: u32 = 0;\n var curIndex: u32 = 1; // we will swap these indices per pass\n // initialize the first row\n for (var i = 0u; i <= aLength; i = i + 1u) {\n dynamicPassMat[prevIndex][i] = gapExtensionPenalty + f32(i - 1) * gapExtensionPenalty; // accounting for the fact that left and right gaps are less costly\n dynamicPassMat[curIndex][i] = 0.0;\n }\n dynamicPassMat[0][0] = 0.0;\n\n let simMatrix = &suppInfo.similarityMatrix${entryIndex}; // using pointers make things faster\n // iterate over the rows\n for (var i = 1u; i <= bLength; i = i + 1u) {\n let prevRow = &dynamicPassMat[prevIndex];\n let curRow = &dynamicPassMat[curIndex];\n (*curRow)[0] = gapExtensionPenalty + f32(i - 1) * gapExtensionPenalty;\n var minEntry: f32 = f32(maxLength);\n let monB = u32(b[i - 1]);\n for (var j = 1u; j <= aLength; j = j + 1u) {\n let monA = u32(a[j - 1]);\n \n let cost: f32 = (*prevRow)[j - 1] + 1f - (*simMatrix)[monA][monB];\n var top = (*prevRow)[j]; // deletion\n if (verticalGaps[j] > 0 || i == 1 || i == bLength) {\n top = top + gapExtensionPenalty;\n } else {\n top = top + gapOpenPenalty;\n }\n var left = (*curRow)[j - 1]; // insertion\n if (horizontalGaps[j - 1] > 0 || j == 1 || j == aLength) {\n left = left + gapExtensionPenalty;\n } else {\n left = left + gapOpenPenalty;\n }\n var res: f32 = min(\n min(\n top, // deletion\n left, // insertion\n ),\n cost // substitution\n );\n (*curRow)[j] = res;\n if (res < minEntry) {\n minEntry = res;\n }\n // update the horizontal and vertical gaps\n if (res == cost) {\n verticalGaps[j] = 0;\n horizontalGaps[j] = 0;\n } else if (res == left) {\n verticalGaps[j] = 0;\n horizontalGaps[j] = 1;\n } else {\n verticalGaps[j] = 1;\n horizontalGaps[j] = 0;\n }\n }\n // swap the indices\n let temp: u32 = prevIndex;\n prevIndex = curIndex;\n curIndex = temp;\n if (minEntry > maxIntDistance) {\n return 1.0;\n }\n }\n return dynamicPassMat[prevIndex][aLength] / f32(minLength);\n\n `;\n}\nexport function webGPUEuclidean(maxArraySize, _entryIndex) {\n return `\n var dist: f32 = 0.0;\n for (var i = 0u; i < ${maxArraySize}; i = i + 1u) {\n dist = dist + f32(a[i] - b[i]) * f32(a[i] - b[i]);\n }\n return sqrt(dist);\n `;\n}\nexport function webGPUManhattan(maxArraySize, _entryIndex) {\n return `\n var dist: f32 = 0.0;\n for (var i = 0u; i < ${maxArraySize}; i = i + 1u) {\n dist = dist + abs(f32(a[i] - b[i]));\n }\n return dist;\n `;\n}\nexport function webGPUOneHotDistance(_maxArraySize, entryIndex) {\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n if (aLength != bLength) {\n return 1.0;\n }\n for (var i = 0u; i < aLength; i = i + 1u) {\n if(a[i] != b[i]) {\n return 1.0;\n }\n }\n return 0.0;\n `;\n}\nexport function webGPUNumericDistance(_maxArraySize, entryIndex) {\n // we assume that range${entryIndex} is available in the supplementaryInfo struct\n return `\n let range = suppInfo.range${entryIndex};\n return f32(abs(f32(a[0]) - f32(b[0])) / range);\n `;\n}\n// tanimoto distance for uint32 arrays of length ${maxArraySize}\nexport function webGPUTanimotoBitArray(maxArraySize, _entryIndex) {\n return `\n var onBitsa: u32 = 0u;\n var onBitsb: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n onBitsa = onBitsa + countOneBits(a[i]);\n onBitsb = onBitsb + countOneBits(b[i]);\n }\n\n if (onBitsa == 0u && onBitsb == 0u) {\n return 0.0;\n }\n\n let totalOnBits = onBitsa + onBitsb;\n var commonBits: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n commonBits = commonBits + countOneBits(a[i] & b[i]);\n }\n\n return 1.0 - f32(commonBits) / f32(totalOnBits - commonBits);\n `;\n}\nexport function webGPUAsymmetricBitArray(maxArraySize, _entryIndex) {\n return `\n var onBitsa: u32 = 0u;\n var onBitsb: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n onBitsa = onBitsa + countOneBits(a[i]);\n onBitsb = onBitsb + countOneBits(b[i]);\n }\n let min = min(onBitsa, onBitsb);\n if (min == 0u) {\n return 1.0;\n }\n var commonBits: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n commonBits = commonBits + countOneBits(a[i] & b[i]);\n }\n return 1.0 - f32(commonBits) / f32(min);\n `;\n}\nexport function webGPUCosineBitArray(maxArraySize, _entryIndex) {\n return `\n var onBitsa: u32 = 0u;\n var onBitsb: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n onBitsa = onBitsa + countOneBits(a[i]);\n onBitsb = onBitsb + countOneBits(b[i]);\n }\n let total = onBitsa * onBitsb; // p.s. here total is taken by multiplying\n if (total == 0u) {\n return 1.0;\n }\n var commonBits: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n commonBits = commonBits + countOneBits(a[i] & b[i]);\n }\n return 1.0 - f32(commonBits) / sqrt(f32(total));\n `;\n}\nexport function webGPUSokalBitArray(maxArraySize, _entryIndex) {\n return `\n var onBitsa: u32 = 0u;\n var onBitsb: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n onBitsa = onBitsa + countOneBits(a[i]);\n onBitsb = onBitsb + countOneBits(b[i]);\n }\n let total = onBitsa + onBitsb;\n if (total == 0u) {\n return 1.0;\n }\n var commonBits: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n commonBits = commonBits + countOneBits(a[i] & b[i]);\n }\n return 1.0 - f32(commonBits) / f32(total * 2 - commonBits * 3);\n `;\n}\nexport var WEBGPUDISTANCE;\n(function (WEBGPUDISTANCE) {\n WEBGPUDISTANCE[\"HAMMING\"] = \"Hamming\";\n WEBGPUDISTANCE[\"EUCLIDEAN\"] = \"Euclidean\";\n WEBGPUDISTANCE[\"MANHATTAN\"] = \"Manhattan\";\n WEBGPUDISTANCE[\"TANIMOTO\"] = \"Tanimoto\";\n WEBGPUDISTANCE[\"LEVENSTEIN\"] = \"Levenshtein\";\n WEBGPUDISTANCE[\"NEEDLEMAN_WUNSCH\"] = \"Needlemann-Wunsch\";\n WEBGPUDISTANCE[\"MONOMER_CHEMICAL_DISTANCE\"] = \"Monomer chemical distance\";\n WEBGPUDISTANCE[\"SOKAL\"] = \"Sokal\";\n WEBGPUDISTANCE[\"COSINE\"] = \"Cosine\";\n WEBGPUDISTANCE[\"ASYMMETRIC\"] = \"Asymmetric\";\n WEBGPUDISTANCE[\"Difference\"] = \"Difference\";\n WEBGPUDISTANCE[\"OneHot\"] = \"One-Hot\";\n})(WEBGPUDISTANCE || (WEBGPUDISTANCE = {}));\nexport const webGPUFunctions = {\n [WEBGPUDISTANCE.HAMMING]: webGPUHamming,\n [WEBGPUDISTANCE.EUCLIDEAN]: webGPUEuclidean,\n [WEBGPUDISTANCE.MANHATTAN]: webGPUManhattan,\n [WEBGPUDISTANCE.TANIMOTO]: webGPUTanimotoBitArray,\n [WEBGPUDISTANCE.LEVENSTEIN]: webGPULevenstein,\n [WEBGPUDISTANCE.NEEDLEMAN_WUNSCH]: webGPUNeedlemanWunsch,\n [WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE]: webGPUMonomerChemicalDistance,\n [WEBGPUDISTANCE.SOKAL]: webGPUSokalBitArray,\n [WEBGPUDISTANCE.COSINE]: webGPUCosineBitArray,\n [WEBGPUDISTANCE.ASYMMETRIC]: webGPUAsymmetricBitArray,\n [WEBGPUDISTANCE.Difference]: webGPUNumericDistance,\n [WEBGPUDISTANCE.OneHot]: webGPUOneHotDistance\n};\nexport const distanceFunctionComplexity = {\n [WEBGPUDISTANCE.HAMMING]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.EUCLIDEAN]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.MANHATTAN]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.TANIMOTO]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.SOKAL]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.COSINE]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.ASYMMETRIC]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.LEVENSTEIN]: (maxEntrySize) => Math.ceil(maxEntrySize * maxEntrySize / 60),\n [WEBGPUDISTANCE.NEEDLEMAN_WUNSCH]: (maxEntrySize) => Math.ceil(maxEntrySize * maxEntrySize / 60),\n [WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE]: (maxEntrySize) => Math.ceil(maxEntrySize / 25),\n [WEBGPUDISTANCE.Difference]: (_maxEntrySize) => 1,\n [WEBGPUDISTANCE.OneHot]: (_maxEntrySize) => Math.ceil(_maxEntrySize / 40),\n};\nexport const TypeSupportedDistances = {\n [\"STRING\" /* WGPUENTRYTYPE.STRING */]: new Set([WEBGPUDISTANCE.HAMMING, WEBGPUDISTANCE.LEVENSTEIN, WEBGPUDISTANCE.NEEDLEMAN_WUNSCH, WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE, WEBGPUDISTANCE.OneHot]),\n [\"UINT32ARRAY\" /* WGPUENTRYTYPE.UINT32ARRAY */]: new Set([WEBGPUDISTANCE.HAMMING, WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE, WEBGPUDISTANCE.LEVENSTEIN, WEBGPUDISTANCE.NEEDLEMAN_WUNSCH, WEBGPUDISTANCE.TANIMOTO, WEBGPUDISTANCE.COSINE, WEBGPUDISTANCE.SOKAL, WEBGPUDISTANCE.ASYMMETRIC, WEBGPUDISTANCE.OneHot, WEBGPUDISTANCE.Difference]),\n [\"INT32ARRAY\" /* WGPUENTRYTYPE.INT32ARRAY */]: new Set([WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.OneHot, WEBGPUDISTANCE.Difference]),\n [\"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */]: new Set([WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.Difference]),\n [\"NUMBER\" /* WGPUENTRYTYPE.NUMBER */]: new Set([WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.Difference]),\n [\"BITARRAY\" /* WGPUENTRYTYPE.BITARRAY */]: new Set([WEBGPUDISTANCE.TANIMOTO, WEBGPUDISTANCE.COSINE, WEBGPUDISTANCE.SOKAL, WEBGPUDISTANCE.ASYMMETRIC])\n};\n//# sourceMappingURL=webGPU-multicol-distances.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\n/* eslint-disable max-len */\nimport { getGPUDevice } from '../getGPUDevice';\nimport { WEBGSLAGGREGATION, WEBGSLAGGREGATIONFUNCTIONS } from '../multi-col-distances/webGPU-aggregation';\nimport { WEBGPUDISTANCE, webGPUFunctions } from '../multi-col-distances/webGPU-multicol-distances';\nimport { webGPUProcessInfo } from '../preprocessing/webGPU-process-info';\n/** generate KNN based on list of lists of entries.\n * these entries are each encoded as Uint32Array or FLOAT32Array (depending on their type).\n * for example, sequences would be encoded as Uint32Array based on char code of the letter at each position.\n * [65, 66, 67, 68, 69] would be a sequence of 5 letters.\n * for chemical fingerprints, it would be a binary array of 0s and 1s,\n * represented as Uint32Array(_data property of DG bitarray).\n *\n * Be ware that size of entryList, distanceMetrics, weights and options must be the same.\n * if there are no options for entries i, pass an empty object.\n * for now options are needed for:\n * needleman-wunsch and monomer chemical distances: see {@link BioDistanceFnOptions} as for how it should be passed\n * numeric distances (Difference): {range: number} where range is the range of the values in the column (max - min).\n * in both cases, if options are not provided, they will be calculated automatically.\n */\nexport function multiColWebGPUKNN(entryList, // list of lists of entries, for multiple columns\nknnSize = 15, // size of the k-nearest neighbors\ndistanceMetrics, // distance metrics for each column\naggregationFunction, // aggregation function for the distances\nweights, // weights for each column\noptions // supplementary options for each column\n) {\n return __awaiter(this, void 0, void 0, function* () {\n // first, check that all the supplementary options are provided and are the same length:\n if (options.length !== entryList.length ||\n options.length !== distanceMetrics.length || options.length !== weights.length)\n throw new Error('Options, weigths and distance functions must be provided for each column');\n // check that all the entry lists are the same length\n if (entryList.some((list) => list.length !== entryList[0].length))\n throw new Error('All entry lists must be the same length');\n const availableDistanceMetrics = Object.values(WEBGPUDISTANCE);\n if (distanceMetrics.some((metric) => !availableDistanceMetrics.includes(metric)))\n throw new Error('Invalid distance metrics provided: ' + distanceMetrics.join(', '));\n const availableAggregationFunctions = Object.values(WEBGSLAGGREGATION);\n if (!availableAggregationFunctions.includes(aggregationFunction))\n throw new Error('Invalid aggregation function provided: ' + aggregationFunction);\n const numOfColumns = entryList.length; // number of columns\n if (numOfColumns === 0)\n throw new Error('No columns provided. Please provide at least one column of data.');\n const device = yield getGPUDevice();\n if (!device)\n return null;\n // device may be lost\n let deviceLost = false;\n device.lost.then(() => {\n deviceLost = true;\n });\n const listSize = entryList[0].length; // size of each list (or column)\n const processInfo = entryList.map((entry, i) => {\n return webGPUProcessInfo(entry, distanceMetrics[i], i, options[i]);\n });\n if (numOfColumns === 1)\n aggregationFunction = WEBGSLAGGREGATION.MANHATTAN; // save a bit of time\n // combine all struct types into one to put into the suppInfo struct.\n let suppInfoWgsl = processInfo.map((info) => info.suppInfoStructWgsl)\n .filter((wgsl) => !!wgsl && wgsl != '').join(',\\n');\n // structures in wgsl must have at least one member, so if we have no structures, we need to add a dummy one\n let needsDummy = false;\n if (!suppInfoWgsl || suppInfoWgsl.trim() == '') {\n needsDummy = true;\n suppInfoWgsl = '\\ndummy: f32\\n';\n }\n // combine all complexities into one\n const combinedComplexity = processInfo.reduce((a, b) => a + b.complexity, 0);\n // combine all data wgsl struct code into one\n const dataWgsl = processInfo.map((info) => info.dataStructWgsl).filter((wgsl) => !!wgsl && wgsl != '').join(',\\n');\n // combine all array sizes into one array (easier for setting)\n const arraySizes = new Uint32Array(numOfColumns * listSize);\n processInfo.forEach((info, i) => {\n arraySizes.set(info.arraySizes, i * listSize);\n }); // array.flat is not as optimized as this\n // if we try to map large knn directly from GPU, sometimes, device disconnects. so we need to do it in chunks, a good number\n // we found is 10000. So we will perform computations in chunks of 10000.\n const computationsPerPass = 10000;\n // also, as the computation per thread takes some time, we also need to divide the work into smaller chunks. meaning\n // that we will divide nummper of pair computations per pass. start and end of the pair comparisons will be stored in startAtEndAt buffer (vec4<u32>) as z and w coordinates.\n const pairComparisonsPerPass = Math.ceil(10000 / combinedComplexity);\n const workGroupDivision = 10; // how many threads inside of one workgroup dimension (in this case 10 * 10 threads per workgroup)\n const threadsPerWorkgroup = workGroupDivision * workGroupDivision;\n const workgroupsDim = Math.ceil(Math.sqrt(Math.ceil(computationsPerPass / threadsPerWorkgroup))); // how many workgroups per 2d dimension\n const globalThreadDimSize = workgroupsDim * workGroupDivision; // how many threads per 2d dimension\n // console.log(getCombinedDistanceScript(distanceMetrics, processInfo.map((info) => info.maxEntryLen), knnSize, aggregationFunction));\n // return;\n const resultIndexes = new Array(listSize)\n .fill(null)\n .map(() => new Uint32Array(knnSize));\n const resultDistances = new Array(listSize)\n .fill(null)\n .map(() => new Float32Array(knnSize));\n const module = device.createShaderModule({\n label: 'KNN compute shader',\n code: `\n // this struct will contain all the info about the computation, startAtEndAt will contain the start and end of the knnDistances and knnIndexes.\n // array of sizes for each entries, and the main data as arrays of arrays called data0, data1 and so on. good thing is that because the first entry is vec4<u32>,\n // there will be no paddings, so no need to worry about padding data. also, arrays and matrices get stucked together, so no padding there as well.\n // what we need to worry about is the padding of overall struct. the size of overall struct will be factor of 16 bytes, so keep that in mind.\n struct ComputeInfo {\n // the x coordinate will contain the start index of the knnDistances and knnIndexes, while y will contain the end index \n // the z coordinate will contain the start of the pair comparisons, while w will contain the end of the pair comparisons\n // just keep in mind that this vec4 will be in first 16 bytes of corresponding buffer.\n startAtEndAt: vec4<u32>,\n // the ACTUALLY sizes of each entry\n entrySizes: array<array<u32, ${listSize}>, ${numOfColumns}>,\n // the weights for each entry\n weights: array<f32, ${numOfColumns}>,\n // the data for each entry\n ${dataWgsl} // an example of the dataWgsl would be:\n //data0: array<array<u32,20>,100>,\n //data1: array<array<u32,20>,100>\n };\n\n struct SuppInfo {\n // struct containing all the supplementary info, like scoring matrix, alphabet indexes, range, etc.\n ${suppInfoWgsl}\n };\n \n @group(0) @binding(0) var<storage, read_write> knnIndexes: array<array<u32, ${knnSize}>, ${computationsPerPass}>;\n @group(0) @binding(1) var<storage, read_write> knnDistances: array<array<f32, ${knnSize}>, ${computationsPerPass}>; // each time just compute for a subset of the list\n @group(0) @binding(2) var<storage, read_write> computeInfo: ComputeInfo;\n @group(0) @binding(3) var<storage, read_write> suppInfo: SuppInfo;\n \n @compute @workgroup_size(${workGroupDivision}, ${workGroupDivision}) fn calcKNN(\n @builtin(global_invocation_id) id: vec3<u32>\n ) {\n ${needsDummy ? `let otherDummy = suppInfo.dummy * 2;` : ''} // just to make sure that the suppInfo is not optimized out\n let col = id.x; //* ${workGroupDivision} + localId.x;\n let row = id.y; //* ${workGroupDivision} + localId.y;\n let graphIndex = row * ${globalThreadDimSize} + col;\n let index = graphIndex + computeInfo.startAtEndAt.x; // add the starting index of the knnDistances and knnIndexes\n \n if (index >= min(${listSize}u, computeInfo.startAtEndAt.y)) {return;}\n \n let pairComparisonStartAt = computeInfo.startAtEndAt.z;\n let pairComparisonEndAt = min(computeInfo.startAtEndAt.w, ${listSize}u);\n \n \n // only clear the knnDistances and knnIndexes if we are at the start of the pair comparison\n if (pairComparisonStartAt == 0u) {\n for (var i = 0u; i < ${knnSize}; i = i + 1u) {\n knnDistances[graphIndex][i] = 99999.0;\n knnIndexes[graphIndex][i] = 0u;\n }\n }\n \n for (var i: u32 = pairComparisonStartAt; i < pairComparisonEndAt; i = i + 1u) {\n if (i == index) {continue;}\n let dist = combinedDistance(index, i);\n insertKnn(graphIndex, dist, i);\n }\n \n }\n // this will generate the distance script for each distance metric and then combine them into one\n ${getCombinedDistanceScript(distanceMetrics, processInfo.map((info) => info.maxEntryLen), knnSize, aggregationFunction)}\n \n fn insertKnn(knnIndex: u32, dist: f32, index: u32) {\n // small optimization, if the distance is larger than the last element in the knnDistances, we can skip\n if (dist >= knnDistances[knnIndex][${knnSize} - 1u]) {return;}\n for (var i = 0u; i < ${knnSize}; i = i + 1u) {\n if (dist < knnDistances[knnIndex][i]) {\n for (var j = ${knnSize} - 1u; j > i; j = j - 1u) {\n knnDistances[knnIndex][j] = knnDistances[knnIndex][j - 1u];\n knnIndexes[knnIndex][j] = knnIndexes[knnIndex][j - 1u];\n }\n knnDistances[knnIndex][i] = dist;\n knnIndexes[knnIndex][i] = index;\n return;\n }\n }\n }\n `,\n });\n const pipeline = device.createComputePipeline({\n label: 'hamming compute pipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'calcKNN',\n },\n });\n // calculate the size of computeInfo struct buffer in terms of 32bit values\n // startAtEndAt=4, entrySizes, weights, data0 + data1 + ...\n const computeInfo32Size = 4 + numOfColumns * listSize + numOfColumns + processInfo.reduce((a, b) => a + b.sourceArraySize, 0);\n // calculate the size of suppInfo struct buffer in terms of 32bit values\n const suppInfo32Size = processInfo.reduce((a, b) => a + b.suppInfoSize, 0);\n // create a buffer on the GPU to hold computeInfo\n // beware that struct must be padded to 16 bytes, so we need to calculate the size of the struct in 32bit values\n const computeInfoBufferSize = computeInfo32Size * Uint32Array.BYTES_PER_ELEMENT;\n let paddedComputeInfoBufferSize = computeInfoBufferSize;\n const remainder = computeInfoBufferSize & 15; // check if the size is a multiple of 16\n if (remainder !== 0)\n paddedComputeInfoBufferSize += 16 - remainder; // pad the size accordingly\n const computeInfoBuffer = device.createBuffer({\n label: 'compute info buffer',\n size: paddedComputeInfoBufferSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedComputeInfoArrayBuffer = computeInfoBuffer.getMappedRange(); // get full buffer\n // create vars to hold startAtEndAt\n let startAt = 0;\n let endAt = computationsPerPass;\n let pairComparisonStartAt = 0;\n let pairComparisonEndAt = pairComparisonsPerPass;\n const startAtEndAtSize = 4;\n // copy the data into the buffer at correct places\n let computeInfoOffSet = 0;\n const startAtEndAtView = new Uint32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, startAtEndAtSize); //new Uint32Array(computeInfoBuffer.getMappedRange(computeInfoOffSet, 4 * Uint32Array.BYTES_PER_ELEMENT));\n startAtEndAtView.set([startAt, endAt, pairComparisonStartAt, pairComparisonEndAt]);\n // write entry sizes\n computeInfoOffSet += startAtEndAtSize * Uint32Array.BYTES_PER_ELEMENT;\n const entrySizesView = new Uint32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, arraySizes.length); //new Uint32Array(computeInfoBuffer.getMappedRange(computeInfoOffSet, arraySizes.byteLength));\n entrySizesView.set(arraySizes);\n // write weights\n computeInfoOffSet += arraySizes.byteLength; // arraySizes.length * Uint32Array.BYTES_PER_ELEMENT;\n const weightsView = new Float32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, numOfColumns); //new Float32Array(computeInfoBuffer.getMappedRange(computeInfoOffSet, numOfColumns * Float32Array.BYTES_PER_ELEMENT));\n weightsView.set(weights);\n // write data\n computeInfoOffSet += numOfColumns * Float32Array.BYTES_PER_ELEMENT;\n for (const info of processInfo) {\n //device.queue.writeBuffer(computeInfoBuffer, computeInfoOffSet, info.flatSourceArray, 0, chunkByteSize);\n const ArrayConstructor = info.EncodedArrayConstructor;\n const chunkSize = info.sourceArraySize;\n const dataView = new ArrayConstructor(mappedComputeInfoArrayBuffer, computeInfoOffSet, chunkSize); //new ArrayConstructor(computeInfoBuffer.getMappedRange(computeInfoOffSet, chunkByteSize));\n dataView.set(info.flatSourceArray);\n computeInfoOffSet += chunkSize * ArrayConstructor.BYTES_PER_ELEMENT;\n }\n // we are done at this point.\n computeInfoBuffer.unmap();\n // create a buffer on the GPU to hold suppInfo\n // same here, we need to pad the size of the struct to 16 bytes\n const suppInfoBufferSize = suppInfo32Size * Uint32Array.BYTES_PER_ELEMENT;\n let paddedSuppInfoBufferSize = suppInfoBufferSize;\n const suppInfoRemainder = suppInfoBufferSize & 15; // check if the size is a multiple of 16\n if (suppInfoRemainder !== 0)\n paddedSuppInfoBufferSize += 16 - suppInfoRemainder; // pad the size accordingly\n paddedSuppInfoBufferSize = Math.max(paddedSuppInfoBufferSize, 16);\n const suppInfoBuffer = device.createBuffer({\n label: 'supp info buffer',\n size: paddedSuppInfoBufferSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedSuppInfoArrayBuffer = suppInfoBuffer.getMappedRange(); // get full buffer\n let suppInfoOffSet = 0;\n for (const info of processInfo) {\n if (info.suppInfoBuffer && info.suppInfoBuffer.byteLength > 0 && info.suppInfoSize > 0) {\n const ArrayConstructor = info.suppInfoType === \"UINT32ARRAY\" /* WGPUENTRYTYPE.UINT32ARRAY */ ? Uint32Array : Float32Array;\n const suppInfoView = new ArrayConstructor(mappedSuppInfoArrayBuffer, suppInfoOffSet, info.suppInfoBuffer.length); //new ArrayConstructor(suppInfoBuffer.getMappedRange(suppInfoOffSet, info.suppInfoBuffer.byteLength));\n suppInfoView.set(info.suppInfoBuffer);\n suppInfoOffSet += info.suppInfoBuffer.byteLength; // info.suppInfoBuffer.length * ArrayConstructor.BYTES_PER_ELEMENT;\n }\n }\n if (suppInfoOffSet === 0) {\n const dummyView = new Uint32Array(mappedSuppInfoArrayBuffer, 0, 4); //new Uint32Array(suppInfoBuffer.getMappedRange(0, 16));\n dummyView.set([1, 1, 1, 1]);\n }\n suppInfoBuffer.unmap();\n const outKnnArraySize = knnSize * Uint32Array.BYTES_PER_ELEMENT * computationsPerPass; // size of the slice of the knnIndexes and knnDistances\n // create a buffer on the GPU to hold knnIndexes and knnDistances\n const bufferDistances = device.createBuffer({\n label: 'buffer distances',\n size: outKnnArraySize,\n usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,\n });\n const bufferIndexes = device.createBuffer({\n label: 'buffer indexes',\n size: outKnnArraySize,\n usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,\n });\n // no need to copy anything to the knn buffers.\n const bytesPerOutArrayRow = knnSize * Uint32Array.BYTES_PER_ELEMENT; // how many bytes one row of the knnDistances and knnIndexes will take\n // Setup a bindGroup to tell the shader which\n // buffer to use for the computation\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for knn buffer',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: bufferIndexes } },\n { binding: 1, resource: { buffer: bufferDistances } },\n { binding: 2, resource: { buffer: computeInfoBuffer } },\n { binding: 3, resource: { buffer: suppInfoBuffer } },\n // { binding: 4, resource: { buffer: arraySizesBuffer } },\n ],\n });\n //create a buffer on the GPU to get a copy of the results\n const resultBufferDistances = device.createBuffer({\n label: 'result buffer distances',\n size: bufferDistances.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n const resultBufferIndexes = device.createBuffer({\n label: 'result buffer indexes',\n size: bufferIndexes.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n for (let iter = 0; iter < Math.ceil(listSize / computationsPerPass); iter++) {\n startAt = iter * computationsPerPass;\n endAt = Math.min((iter + 1) * computationsPerPass, listSize);\n const pairComparisonPasses = Math.ceil(listSize / pairComparisonsPerPass);\n for (let pairIter = 0; pairIter < pairComparisonPasses; pairIter++) {\n pairComparisonStartAt = pairIter * pairComparisonsPerPass;\n pairComparisonEndAt = Math.min((pairIter + 1) * pairComparisonsPerPass, listSize);\n // write only four values to the buffer, startAt, endAt, pairComparisonStartAt, pairComparisonEndAt, corresponding to vec4<u32> at the start of info struct\n device.queue.writeBuffer(computeInfoBuffer, 0, new Uint32Array([\n startAt,\n endAt,\n pairComparisonStartAt,\n pairComparisonEndAt,\n ]));\n // Encode commands to do the computation\n const encoder = device.createCommandEncoder({\n label: 'distance encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'distance compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(workgroupsDim, \n //workgroupsDim,\n Math.ceil(computationsPerPass / workgroupsDim / threadsPerWorkgroup));\n pass.end();\n // if we are at the last pair comparison pass, we need to read the results\n if (pairIter === pairComparisonPasses - 1) {\n // Encode a command to copy the results to a mappable buffer.\n encoder.copyBufferToBuffer(bufferDistances, 0, resultBufferDistances, 0, resultBufferDistances.size);\n encoder.copyBufferToBuffer(bufferIndexes, 0, resultBufferIndexes, 0, resultBufferIndexes.size);\n // Finish encoding and submit the commands\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n // Read the results\n //console.time('pass end');\n yield device.queue.onSubmittedWorkDone();\n // console.timeEnd('pass end');\n // console.time(\"read\");\n //const offsetBytes = startAt * bytesPerOutArrayRow;\n //const sizeBytes = (endAt - startAt) * bytesPerOutArrayRow;\n yield resultBufferDistances.mapAsync(GPUMapMode.READ);\n yield resultBufferIndexes.mapAsync(GPUMapMode.READ);\n // console.timeEnd(\"read\");\n const indexes = resultBufferIndexes.getMappedRange();\n const distances = resultBufferDistances.getMappedRange();\n // console.time(\"decode\");\n for (let i = 0; i < endAt - startAt; i++) {\n const index = new Uint32Array(indexes, i * bytesPerOutArrayRow, knnSize);\n const distance = new Float32Array(distances, i * bytesPerOutArrayRow, knnSize);\n resultIndexes[startAt + i].set(index);\n resultDistances[startAt + i].set(distance);\n }\n resultBufferIndexes.unmap();\n resultBufferDistances.unmap();\n }\n else {\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n // Read the results\n // console.time('pass between');\n yield device.queue.onSubmittedWorkDone();\n // console.timeEnd('pass between');\n }\n // device may get lost during opperation, so in this case, we need to return null\n if (deviceLost)\n return null;\n }\n }\n bufferDistances.destroy();\n bufferIndexes.destroy();\n computeInfoBuffer.destroy();\n suppInfoBuffer.destroy();\n resultBufferDistances.destroy();\n resultBufferIndexes.destroy();\n if (deviceLost)\n return null;\n return { knnIndexes: resultIndexes, knnDistances: resultDistances };\n });\n}\nfunction getCombinedDistanceScript(distanceMetrics, maxEntryLens, knnSize, aggregation) {\n const distanceWgsls = distanceMetrics.map((metric, i) => {\n return `\n fn distanceScript${i}(aIndex: u32, bIndex: u32) -> f32 {\n let a = computeInfo.data${i}[aIndex];\n let b = computeInfo.data${i}[bIndex];\n let maxDistance: f32 = knnDistances[aIndex - computeInfo.startAtEndAt.x][${knnSize} - 1u];\n ${webGPUFunctions[metric](maxEntryLens[i], i)}\n }\n `;\n });\n const allDistanceScripts = distanceWgsls.join('\\n');\n const combineDistancesScript = `\n fn combinedDistance(aIndex: u32, bIndex: u32) -> f32 {\n var distances: array<f32, ${distanceMetrics.length}>;\n ${distanceMetrics.map((_, i) => `distances[${i}] = distanceScript${i}(aIndex, bIndex);`).join('\\n')}\n ${WEBGSLAGGREGATIONFUNCTIONS[aggregation](distanceMetrics.length)}\n }\n \n `;\n return allDistanceScripts + '\\n' + combineDistancesScript;\n}\n//# sourceMappingURL=multiCol-KNN.js.map","export var MatrixMatrixOpType;\n(function (MatrixMatrixOpType) {\n MatrixMatrixOpType[\"ADD\"] = \"ADD\";\n MatrixMatrixOpType[\"SUB\"] = \"SUB\";\n MatrixMatrixOpType[\"MULT\"] = \"MULT\";\n})(MatrixMatrixOpType || (MatrixMatrixOpType = {}));\nexport var MatrixOpType;\n(function (MatrixOpType) {\n MatrixOpType[\"SQUARE\"] = \"SQUARE\";\n MatrixOpType[\"INVERSE\"] = \"INVERSE\";\n MatrixOpType[\"TRANSPOSE\"] = \"TRANSPOSE\";\n MatrixOpType[\"NORM\"] = \"NORM\";\n MatrixOpType[\"COLUMN_NORM\"] = \"COLUMN_NORM\";\n})(MatrixOpType || (MatrixOpType = {}));\nexport var MatrixScalarOpType;\n(function (MatrixScalarOpType) {\n MatrixScalarOpType[\"SCALARMULT\"] = \"SCALARMULT\";\n MatrixScalarOpType[\"SCALARADD\"] = \"SCALARADD\";\n MatrixScalarOpType[\"SCALARPOW\"] = \"SCALARPOW\";\n})(MatrixScalarOpType || (MatrixScalarOpType = {}));\n//# sourceMappingURL=types.js.map","/* eslint-disable max-len */\nimport { distanceFunctionComplexity, TypeSupportedDistances, WEBGPUDISTANCE } from '../multi-col-distances/webGPU-multicol-distances';\nexport function webGPUProcessInfo(entryList, distanceMetric = WEBGPUDISTANCE.HAMMING, entryIndex, // index of the entries in the list of lists that we want to process\noptions = { gapOpenPenalty: 1.0, gapExtensionPenalty: 0.6 }) {\n var _a, _b;\n let entryType = null;\n const encodedList = (() => {\n if (entryList.some((e) => typeof e === 'string')) {\n entryType = \"STRING\" /* WGPUENTRYTYPE.STRING */;\n return entryList.map((entry) => new Uint32Array(entry.split('').map((c) => c.charCodeAt(0))));\n }\n if (entryList.some((e) => typeof e === 'number')) {\n entryType = \"NUMBER\" /* WGPUENTRYTYPE.NUMBER */;\n return entryList.map((entry) => new Float32Array([entry]));\n }\n if (typeof entryList[0] == 'object' && entryList.some((e) => '_data' in e && '_length' in e)) {\n entryType = \"BITARRAY\" /* WGPUENTRYTYPE.BITARRAY */;\n return entryList.map((entry) => entry._data);\n }\n if (entryList.some((e) => e instanceof Float32Array)) {\n entryType = \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */;\n return entryList;\n }\n if (entryList.some((e) => e instanceof Uint32Array)) {\n entryType = \"UINT32ARRAY\" /* WGPUENTRYTYPE.UINT32ARRAY */;\n return entryList;\n }\n if (entryList.some((e) => e instanceof Int32Array)) {\n entryType = \"INT32ARRAY\" /* WGPUENTRYTYPE.INT32ARRAY */;\n return entryList;\n }\n //return entryList as Uint32Array[];\n })();\n if (!encodedList || !entryType)\n throw new Error('Invalid entry type, could not determine entry type from input list');\n const encodedListType = encodedList[0] instanceof Int32Array ? \"INT32ARRAY\" /* WGPUENTRYTYPE.INT32ARRAY */ :\n encodedList[0] instanceof Float32Array ? \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */ : \"UINT32ARRAY\" /* WGPUENTRYTYPE.UINT32ARRAY */;\n // sizes of each entries might differ, so we need to keep track of that for some distance metrics, like hamming for example\n const arraySizes = new Uint32Array(encodedList.map((arr) => arr.length));\n if (!TypeSupportedDistances[entryType] || !TypeSupportedDistances[entryType].has(distanceMetric))\n throw new Error(`Distance metric '${distanceMetric}' not supported for entry type '${entryType}'`);\n const maxEntryLen = arraySizes.reduce((a, b) => Math.max(a, b), 0);\n // get the complexity of used algorithm\n const complexity = distanceFunctionComplexity[distanceMetric](maxEntryLen);\n const EncodedArrayConstructor = encodedListType === \"INT32ARRAY\" /* WGPUENTRYTYPE.INT32ARRAY */ ? Int32Array :\n (encodedListType === \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */ ? Float32Array : Uint32Array);\n const flatSourceArray = new EncodedArrayConstructor(encodedList.length * maxEntryLen);\n // when setting, we need to set each array at a specific offset, which is controlled by maxArrayLen because each array might have different sizes.\n // this way we will get correct matrix representation in the compute shader\n encodedList.forEach((seq, i) => {\n flatSourceArray.set(seq, i * maxEntryLen);\n });\n // NB! all this before the line was generic, now we need to calculate some specific things for some specific distance metrics\n // initialize supp info line that will be included in the final shader;\n let suppInfoStructWgsl = ''; // the code that will be included in the struct of suppInfo\n let suppInfoSize = 0;\n let suppInfoType = \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */;\n let suppInfoBuffer = null;\n if (distanceMetric === WEBGPUDISTANCE.NEEDLEMAN_WUNSCH || distanceMetric === WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE) {\n let maxMonomerIndex = options.scoringMatrix && options.alphabetIndexes ?\n Object.keys(options.alphabetIndexes).reduce((prev, n) => Math.max(prev, n.charCodeAt(0)), 0) : -1;\n // generate default similarity matrix if it is not provided\n if (!options.alphabetIndexes || !options.scoringMatrix) {\n for (let i = 0; i < flatSourceArray.length; i++) {\n if (flatSourceArray[i] > maxMonomerIndex)\n maxMonomerIndex = flatSourceArray[i];\n }\n options.scoringMatrix =\n new Array(maxMonomerIndex + 1).fill(null).map(() => new Array(maxMonomerIndex + 1).fill(0));\n options.alphabetIndexes = {};\n for (let i = 0; i < options.scoringMatrix.length; i++) {\n options.scoringMatrix[i][i] = 1;\n options.alphabetIndexes[String.fromCharCode(i)] = i;\n }\n }\n const similarityMatrixSize = (maxMonomerIndex + 1) * (maxMonomerIndex + 1);\n const transferedSimilarityMatrix = new Array(maxMonomerIndex + 1).fill(null).map(() => new Float32Array(maxMonomerIndex + 1));\n // set diagonal to 1\n for (let i = 0; i < maxMonomerIndex + 1; i++)\n transferedSimilarityMatrix[i][i] = 1;\n const alphabetIndexes = options.alphabetIndexes;\n for (const key of Object.keys(alphabetIndexes)) {\n for (const key2 of Object.keys(alphabetIndexes)) {\n if (key === key2)\n continue;\n transferedSimilarityMatrix[key.charCodeAt(0)][key2.charCodeAt(0)] =\n options.scoringMatrix[alphabetIndexes[key]][alphabetIndexes[key2]];\n }\n }\n // in memory layout, we will have 2 float32 s for gapOpen and gapExtension penalties, and then f32 array<array<f32>> for similarity matrix.\n // because of primitives, there will be no padding, so we can calculate the size directly\n suppInfoSize = 2 + similarityMatrixSize;\n suppInfoType = \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */;\n suppInfoBuffer = new Float32Array(suppInfoSize);\n suppInfoBuffer[0] = (_a = options.gapOpenPenalty) !== null && _a !== void 0 ? _a : 1.0;\n suppInfoBuffer[1] = (_b = options.gapExtensionPenalty) !== null && _b !== void 0 ? _b : 0.6;\n let offset = 2;\n for (let i = 0; i < transferedSimilarityMatrix.length; i++) {\n suppInfoBuffer.set(transferedSimilarityMatrix[i], offset);\n offset += transferedSimilarityMatrix[i].length;\n }\n suppInfoStructWgsl = `\n gapOpenPenalty${entryIndex}: f32,\n gapExtensionPenalty${entryIndex}: f32,\n similarityMatrix${entryIndex}: array<array<f32, ${maxMonomerIndex + 1}>, ${maxMonomerIndex + 1}>`;\n }\n else if (distanceMetric === WEBGPUDISTANCE.Difference) {\n // for difference, we need range of values for normalization of the difference\n if (!options.range || typeof options.range !== 'number' || options.range <= 0) {\n const min = flatSourceArray.reduce((a, b) => Math.min(a, b), flatSourceArray[0]);\n const max = flatSourceArray.reduce((a, b) => Math.max(a, b), flatSourceArray[0]);\n options.range = max - min;\n }\n if (options.range <= 0)\n options.range = 1.0; // this means that all values are the same, and all distances will produce 0.\n suppInfoSize = 1;\n suppInfoType = \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */;\n suppInfoBuffer = new Float32Array([options.range]);\n suppInfoStructWgsl = `\n range${entryIndex}: f32`;\n }\n const dataTypeWGSL = flatSourceArray instanceof Int32Array ? 'i32' : (flatSourceArray instanceof Float32Array ? 'f32' : 'u32');\n const dataStructWgsl = `data${entryIndex}: array<array<${dataTypeWGSL}, ${maxEntryLen}>, ${encodedList.length}>`;\n // for now, other distances do not require any additional information, so we can skip that\n return {\n flatSourceArray,\n sourceArraySize: flatSourceArray.length,\n maxEntryLen,\n arraySizes,\n complexity,\n suppInfoBuffer,\n suppInfoSize,\n suppInfoType: suppInfoType,\n suppInfoStructWgsl,\n entryType,\n dataTypeWGSL,\n dataStructWgsl,\n EncodedArrayConstructor\n };\n}\n//# sourceMappingURL=webGPU-process-info.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\nimport { knnMatrixOpInfoWGSL } from './wgsl/knn-sparse-info.wgsl';\n/**\n * this will get all the info needed for subsequent operation in umap\n * like sizes of each array of transposed knn and sizes of union of knn and its transpose rows.\n * after this point, all knn structures will be in single array form, with corresponding offsets.\n * @param knnIndexes\n * @returns\n */\nexport function getKnnSparseOpInfo(knnIndexes) {\n return __awaiter(this, void 0, void 0, function* () {\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const numOfEntries = knnIndexes.length;\n const requiredWorkgroups = Math.ceil(numOfEntries / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const knnSize = knnIndexes[0].length;\n const processWgsl = knnMatrixOpInfoWGSL(threadsPerWorkgroupDim, threadsPerWorkgroupDim * numOfWorkgroupsPerDim, numOfEntries, knnSize);\n const indexesBuffer32Size = numOfEntries * knnIndexes[0].length;\n const device = yield getGPUDevice();\n if (device == null)\n return;\n const module = device.createShaderModule({\n label: 'transposedSizesCalulation',\n code: processWgsl\n });\n const pipeline = device.createComputePipeline({\n label: 'transposedSizesPipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'countTransposedCols',\n },\n });\n const indexBuffer = device.createBuffer({\n label: 'indexes buffer',\n size: indexesBuffer32Size * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedIndexesBuffer = indexBuffer.getMappedRange();\n const mappedIndexesArray = new Int32Array(mappedIndexesBuffer);\n for (let i = 0; i < knnIndexes.length; i++)\n mappedIndexesArray.set(knnIndexes[i], i * knnIndexes[i].length);\n indexBuffer.unmap();\n const sizesBuffer = device.createBuffer({\n label: 'transpose sizes buffer',\n size: knnIndexes.length * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n });\n const unionSizesBuffer = device.createBuffer({\n label: 'union sizes buffer',\n size: knnIndexes.length * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedUnionSizesBuffer = unionSizesBuffer.getMappedRange();\n const mappedUnionSizesArray = new Uint32Array(mappedUnionSizesBuffer);\n mappedUnionSizesArray.fill(knnSize);\n unionSizesBuffer.unmap();\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for count ops',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: indexBuffer } },\n { binding: 1, resource: { buffer: sizesBuffer } },\n { binding: 2, resource: { buffer: unionSizesBuffer } }\n // { binding: 4, resource: { buffer: arraySizesBuffer } },\n ],\n });\n const encoder = device.createCommandEncoder({\n label: 'matrix ops encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'matrix ops compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n const resultTransposeSizesBuffer = device.createBuffer({\n label: 'result transpose sizes',\n size: sizesBuffer.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n const resultUnionSizesBuffer = device.createBuffer({\n label: 'result union sizes',\n size: unionSizesBuffer.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n encoder.copyBufferToBuffer(sizesBuffer, 0, resultTransposeSizesBuffer, 0, resultTransposeSizesBuffer.size);\n encoder.copyBufferToBuffer(unionSizesBuffer, 0, resultUnionSizesBuffer, 0, resultUnionSizesBuffer.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n yield resultTransposeSizesBuffer.mapAsync(GPUMapMode.READ);\n yield resultUnionSizesBuffer.mapAsync(GPUMapMode.READ);\n const resultTransposeSizesArrayBuffer = resultTransposeSizesBuffer.getMappedRange();\n const resultUnionSizesArrayBuffer = resultUnionSizesBuffer.getMappedRange();\n const resultTransposeSizesArray = new Uint32Array(knnIndexes.length);\n resultTransposeSizesArray.set(new Uint32Array(resultTransposeSizesArrayBuffer, 0, knnIndexes.length));\n resultTransposeSizesBuffer.unmap();\n const resultUnionSizesArray = new Uint32Array(knnIndexes.length);\n resultUnionSizesArray.set(new Uint32Array(resultUnionSizesArrayBuffer, 0, knnIndexes.length));\n resultUnionSizesBuffer.unmap();\n const unionMatrixSize = resultUnionSizesArray.reduce((old, val) => old + val, 0);\n resultUnionSizesBuffer.destroy();\n resultTransposeSizesBuffer.destroy();\n sizesBuffer.destroy();\n indexBuffer.destroy();\n unionSizesBuffer.destroy();\n // sizes of each transposed knn row, sizes of each union of knn and its transpose row, total size of union matrix\n return { resultTransposeSizesArray, resultUnionSizesArray, unionMatrixSize };\n //counteTransposedCols\n });\n}\n//# sourceMappingURL=knn-sparse-info.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\n/* eslint-disable max-len */\n/**\n * wgsl code for pairwise operation on two sparse matrices.\n * @param indexes1 - indexes of first sparse matrix\n * @param distances1 - values1 of first sparse matrix\n * @param offsets1 - 32 bit offsets of first sparse matrix\n * @param indexes2 - indexes of second sparse matrix\n * @param distances2 - values of second sparse matrix\n * @param offsets2 - 32 bit offsets of second sparse matrix\n * @param numOfEntries - number of entries in original data\n * @param unionMatrixOffsets - offsets of union matrix, used to store result\n * @param op - operation to perform\n * @returns\n */\nexport function pairwiseOpSparse(indexes1, distances1, offsets1, indexes2, distances2, offsets2, numOfEntries, unionMatrixOffsets, // array of size numOfEntries + 1\nop) {\n return __awaiter(this, void 0, void 0, function* () {\n // this function is only meant for regular knn matrix, not for sparse matrix for of knn.\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const requiredWorkgroups = Math.ceil(numOfEntries / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const threadsPerYDimension = threadsPerWorkgroupDim * numOfWorkgroupsPerDim;\n const sparseSize1 = offsets1[offsets1.length - 1];\n const sparseSize2 = offsets2[offsets2.length - 1];\n // this array will have offsets of each row in union matrix with length of numOfEntries + 1\n const unionMatrixSize = unionMatrixOffsets[unionMatrixOffsets.length - 1]; // last index will be last offset i.e. full size\n const processWgsl = `\n struct SparseKNNStorage1 {\n indexes:array<i32, ${sparseSize1}>,\n knnDistances: array<f32, ${sparseSize1}>,\n offsets: array<u32, ${numOfEntries + 1}>\n }\n\n struct SparseKNNStorage2 {\n indexes:array<i32, ${sparseSize2}>,\n knnDistances: array<f32, ${sparseSize2}>,\n offsets: array<u32, ${numOfEntries + 1}>\n }\n\n struct ResKnn {\n knnIndexes: array<i32, ${unionMatrixSize}>,\n knnDistances: array<f32, ${unionMatrixSize}>\n }\n\n @group(0) @binding(0) var<storage, read_write> source1: SparseKNNStorage1;\n @group(0) @binding(1) var<storage, read_write> source2: SparseKNNStorage2;\n @group(0) @binding(2) var<storage, read_write> result: ResKnn;\n @group(0) @binding(3) var<storage, read_write> unionMatrixOffsets: array<u32, ${numOfEntries + 1}>;\n @compute @workgroup_size(${threadsPerWorkgroupDim}, ${threadsPerWorkgroupDim}) fn pairwiseOp(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n\n let col: u32 = id.x;\n let row: u32 = id.y;\n let workingIndex: u32 = row * ${threadsPerYDimension} + col;\n\n if (workingIndex >= ${numOfEntries}) {\n return;\n }\n var curUnionOffset: u32 = unionMatrixOffsets[workingIndex]; // offset at which to start writing in union matrix\n\n let start1 = source1.offsets[workingIndex];\n let end1 = source1.offsets[workingIndex + 1];\n let start2 = source2.offsets[workingIndex];\n let end2 = source2.offsets[workingIndex + 1];\n // TODO: sort a copy of these arrays, will make operation faster\n for (var i: u32 = start1; i < end1; i++) {\n let val1: f32 = source1.knnDistances[i];\n var val2: f32 = 0.0;\n let curIndex: i32 = source1.indexes[i];\n for (var j: u32 = start2; j < end2; j++) {\n if (source2.indexes[j] == curIndex) {\n val2 = source2.knnDistances[j];\n break;\n }\n }\n \n result.knnIndexes[curUnionOffset] = curIndex;\n result.knnDistances[curUnionOffset] = val1 ${op} val2;\n curUnionOffset += 1;\n }\n\n if (curUnionOffset >= unionMatrixOffsets[workingIndex + 1]) {\n // small optimization applicable only to our case, but saves a good amount of time\n return;\n }\n\n // do the same for source2 but skip the indexes where they are already present in source1\n for (var i: u32 = start2; i < end2; i++) {\n let val1: f32 = source2.knnDistances[i];\n let curIndex: i32 = source2.indexes[i];\n var found = false;\n for (var j: u32 = start1; j < end1; j++) {\n if (source1.indexes[j] == curIndex) {\n found = true;\n break;\n }\n }\n if (!found) {\n result.knnIndexes[curUnionOffset] = curIndex;\n result.knnDistances[curUnionOffset] = val1 ${op} 0.0;\n curUnionOffset += 1;\n }\n }\n }\n`;\n const storage32Size1 = sparseSize1 * 2 + numOfEntries + 1;\n const storage32Size2 = sparseSize2 * 2 + numOfEntries + 1;\n const resStorage32Size = unionMatrixSize * 2;\n // standard stuff to pad the storage size to multiple of 16 bytes\n let paddedStorage1ByteSize = storage32Size1 * 4;\n const remainder1 = paddedStorage1ByteSize & 15;\n if (remainder1 !== 0)\n paddedStorage1ByteSize += 16 - remainder1;\n let paddedStorage2ByteSize = storage32Size2 * 4;\n const remainder2 = paddedStorage2ByteSize & 15;\n if (remainder2 !== 0)\n paddedStorage2ByteSize += 16 - remainder2;\n let paddedResStorageByteSize = resStorage32Size * 4;\n const remainder3 = paddedResStorageByteSize & 15;\n if (remainder3 !== 0)\n paddedResStorageByteSize += 16 - remainder3;\n const device = yield getGPUDevice();\n if (device == null)\n return;\n const module = device.createShaderModule({\n label: 'pairwiseOpShader',\n code: processWgsl\n });\n const pipeline = device.createComputePipeline({\n label: 'pairwiseOpPipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'pairwiseOp',\n },\n });\n // input params\n const source1Buffer = device.createBuffer({\n label: 'source 1 buffer',\n size: paddedStorage1ByteSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedSource1Buffer = source1Buffer.getMappedRange();\n const source1IndexesArray = new Int32Array(mappedSource1Buffer, 0, sparseSize1);\n source1IndexesArray.set(indexes1);\n const source1DistancesArray = new Float32Array(mappedSource1Buffer, sparseSize1 * 4, sparseSize1);\n source1DistancesArray.set(distances1);\n const source1OffsetsArray = new Uint32Array(mappedSource1Buffer, sparseSize1 * 8, numOfEntries + 1);\n source1OffsetsArray.set(offsets1);\n source1Buffer.unmap();\n const source2Buffer = device.createBuffer({\n label: 'source 2 buffer',\n size: paddedStorage2ByteSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedSource2Buffer = source2Buffer.getMappedRange();\n const source2IndexesArray = new Int32Array(mappedSource2Buffer, 0, sparseSize2);\n source2IndexesArray.set(indexes2);\n const source2DistancesArray = new Float32Array(mappedSource2Buffer, sparseSize2 * 4, sparseSize2);\n source2DistancesArray.set(distances2);\n const source2OffsetsArray = new Uint32Array(mappedSource2Buffer, sparseSize2 * 8, numOfEntries + 1);\n source2OffsetsArray.set(offsets2);\n source2Buffer.unmap();\n const resBuffer = device.createBuffer({\n label: 'res buffer',\n size: paddedResStorageByteSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n });\n const unionMatrixOffsetsBuffer = device.createBuffer({\n label: 'union matrix offsets buffer',\n size: (numOfEntries + 1) * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedUnionMatrixOffsetsBuffer = unionMatrixOffsetsBuffer.getMappedRange();\n const unionMatrixOffsetsArray = new Uint32Array(mappedUnionMatrixOffsetsBuffer);\n unionMatrixOffsetsArray.set(unionMatrixOffsets);\n unionMatrixOffsetsBuffer.unmap();\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for pairwise ops',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: source1Buffer } },\n { binding: 1, resource: { buffer: source2Buffer } },\n { binding: 2, resource: { buffer: resBuffer } },\n { binding: 3, resource: { buffer: unionMatrixOffsetsBuffer } }\n ],\n });\n const encoder = device.createCommandEncoder({\n label: 'matrix ops encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'matrix ops compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n const resultBuffer = device.createBuffer({\n label: 'result buffer',\n size: paddedResStorageByteSize,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n encoder.copyBufferToBuffer(resBuffer, 0, resultBuffer, 0, resultBuffer.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n yield resultBuffer.mapAsync(GPUMapMode.READ);\n const resultArrayBuffer = resultBuffer.getMappedRange();\n const resultKnnIndexes = new Int32Array(unionMatrixSize);\n const resultKnnDistances = new Float32Array(unionMatrixSize);\n // its actually a sparse matrix.\n resultKnnIndexes.set(new Int32Array(resultArrayBuffer, 0, unionMatrixSize));\n resultKnnDistances.set(new Float32Array(resultArrayBuffer, unionMatrixSize * 4, unionMatrixSize));\n resultBuffer.unmap();\n resultBuffer.destroy();\n source1Buffer.destroy();\n source2Buffer.destroy();\n resBuffer.destroy();\n unionMatrixOffsetsBuffer.destroy();\n return { resultKnnIndexes, resultKnnDistances };\n });\n}\n//# sourceMappingURL=pairwise-sparse-ops.js.map","/**\n * the sum of the weighted squares of the errors (or weighted residuals) between the data.y\n * and the curve-fit function.\n * @ignore\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {ArrayLike<number>} parameters - Array of current parameter values\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @param {ArrayLike<number>} weightSquare - Square of weights\n * @return {number}\n */\nexport default function errorCalculation(data, parameters, parameterizedFunction, weightSquare) {\n let error = 0;\n const func = parameterizedFunction(parameters);\n for (let i = 0; i < data.x.length; i++) {\n error += Math.pow(data.y[i] - func(data.x[i]), 2) / weightSquare[i];\n }\n return error;\n}\n//# sourceMappingURL=errorCalculation.js.map","import { inverse, Matrix } from 'ml-matrix';\nimport gradientFunction from './gradientFunction';\n/**\n * Matrix function over the samples\n * @ignore\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {ArrayLike<number>} evaluatedData - Array of previous evaluated function values\n * @return {Matrix}\n */\nfunction matrixFunction(data, evaluatedData) {\n const m = data.x.length;\n let ans = new Matrix(m, 1);\n for (let point = 0; point < m; point++) {\n ans.set(point, 0, data.y[point] - evaluatedData[point]);\n }\n return ans;\n}\n/**\n * Iteration for Levenberg-Marquardt\n * @ignore\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} damping - Levenberg-Marquardt parameter\n * @param {number|array} gradientDifference - The step size to approximate the jacobian matrix\n * @param {boolean} centralDifference - If true the jacobian matrix is approximated by central differences otherwise by forward differences\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n */\nexport default function step(data, params, damping, gradientDifference, parameterizedFunction, centralDifference, weights) {\n let value = damping;\n let identity = Matrix.eye(params.length, params.length, value);\n const func = parameterizedFunction(params);\n let evaluatedData = new Float64Array(data.x.length);\n for (let i = 0; i < data.x.length; i++) {\n evaluatedData[i] = func(data.x[i]);\n }\n let gradientFunc = gradientFunction(data, evaluatedData, params, gradientDifference, parameterizedFunction, centralDifference);\n let residualError = matrixFunction(data, evaluatedData);\n let inverseMatrix = inverse(identity.add(gradientFunc.mmul(gradientFunc.transpose().scale('row', { scale: weights }))));\n let jacobianWeightResidualError = gradientFunc.mmul(residualError.scale('row', { scale: weights }));\n let perturbations = inverseMatrix.mmul(jacobianWeightResidualError);\n return {\n perturbations,\n jacobianWeightResidualError,\n };\n}\n//# sourceMappingURL=step.js.map","import { Matrix } from 'ml-matrix';\n/**\n * Difference of the matrix function over the parameters\n * @ignore\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {ArrayLike<number>} evaluatedData - Array of previous evaluated function values\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number|array} gradientDifference - The step size to approximate the jacobian matrix\n * @param {boolean} centralDifference - If true the jacobian matrix is approximated by central differences otherwise by forward differences\n * @param {function} paramFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Matrix}\n */\nexport default function gradientFunction(data, evaluatedData, params, gradientDifference, paramFunction, centralDifference) {\n const nbParams = params.length;\n const nbPoints = data.x.length;\n let ans = Matrix.zeros(nbParams, nbPoints);\n let rowIndex = 0;\n for (let param = 0; param < nbParams; param++) {\n if (gradientDifference[param] === 0)\n continue;\n let delta = gradientDifference[param];\n let auxParams = params.slice();\n auxParams[param] += delta;\n let funcParam = paramFunction(auxParams);\n if (!centralDifference) {\n for (let point = 0; point < nbPoints; point++) {\n ans.set(rowIndex, point, (evaluatedData[point] - funcParam(data.x[point])) / delta);\n }\n }\n else {\n auxParams = params.slice();\n auxParams[param] -= delta;\n delta *= 2;\n let funcParam2 = paramFunction(auxParams);\n for (let point = 0; point < nbPoints; point++) {\n ans.set(rowIndex, point, (funcParam2(data.x[point]) - funcParam(data.x[point])) / delta);\n }\n }\n rowIndex++;\n }\n return ans;\n}\n//# sourceMappingURL=gradientFunction.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { levenbergMarquardt } from 'ml-levenberg-marquardt';\nexport function linear(x1, x2, n) {\n const step = (x2 - x1) / (n - 1);\n return Array.from({ length: n }, (_, i) => x1 + step * i);\n}\n/**\n * Fit a, b params for the differentiable curve used in lower\n * dimensional fuzzy simplicial complex construction. We want the\n * smooth curve (from a pre-defined family with simple gradient) that\n * best matches an offset exponential decay.\n */\nexport function findABParams(spread, minDist) {\n const curve = ([a, b]) => (x) => {\n return 1.0 / (1.0 + a * Math.pow(x, (2 * b)));\n };\n const xv = linear(0, spread * 3, 300)\n .map((val) => (val < minDist ? 1.0 : val));\n const yv = new Array(xv.length).fill(0).map((val, index) => {\n const gte = xv[index] >= minDist;\n return gte ? Math.exp(-(xv[index] - minDist) / spread) : val;\n });\n const initialValues = [0.5, 0.5];\n const data = { x: xv, y: yv };\n // Default options for the algorithm (from github example)\n const options = {\n damping: 1.5,\n initialValues,\n gradientDifference: 10e-2,\n maxIterations: 100,\n errorTolerance: 10e-3,\n };\n // eslint-disable-next-line new-cap\n const { parameterValues } = levenbergMarquardt(data, curve, options);\n const [a, b] = parameterValues;\n return { a, b };\n}\n/**\n * heuristic for number of epochs of umap, differs from cpu version, because of the way gpu passes data\n * @param entryLen number of entries\n * @returns\n */\nexport function getNEpochs(entryLen) {\n //\n const length = entryLen;\n if (length <= 2500)\n return 1000;\n else if (length <= 5000)\n return 800;\n else if (length <= 7500)\n return 650;\n else\n return 400;\n}\n/** helper function that transforms array of sizes to offset form */\nexport function toOffsetForm(ar) {\n const res = new Uint32Array(ar.length + 1);\n let offset = 0;\n for (let i = 0; i < ar.length; i++) {\n res[i] = offset;\n offset += ar[i];\n }\n res[ar.length] = offset;\n return res;\n}\n/** multiplies flat representation of sparse knn info by scalar.\n * also no point of doing this on gpu, can be done on cpu pretty quickly.\n * if there will be need for it, it can be done on gpu as well very very easily.\n * @param values values array\n * @param scalar\n */\nexport function multiplyScalar(values, scalar) {\n for (let i = 0; i < values.length; i++)\n values[i] = values[i] * scalar;\n}\n/**\n * generate transpose of knn from the transposition info taken from sparse knn info\n * using this information avoids billions of array.push calls, is much cleaner, allows typed array use and is faster.\n * no point of doing this on gpu, can be done on cpu as we already have all the info needed.\n * @param knnIndexes\n * @param knnDistances\n * @param knnSparseInfo\n * @param knnSize\n * @returns\n */\nexport function transposeKNN(knnIndexes, knnDistances, knnSparseInfo, knnSize = 15) {\n return __awaiter(this, void 0, void 0, function* () {\n const numOfEntries = knnIndexes.length;\n const fullKnnEntrySize = knnSize * numOfEntries;\n const transposeSizes = knnSparseInfo.resultTransposeSizesArray;\n const transposeOffsets = toOffsetForm(transposeSizes);\n const offsetsCopy = new Uint32Array(transposeOffsets.length);\n offsetsCopy.set(transposeOffsets); // will be used for dynamic indexing\n const transposeKNNIndexes = new Int32Array(fullKnnEntrySize).fill(0);\n const transposeKNNDistances = new Float32Array(fullKnnEntrySize).fill(0);\n for (let i = 0; i < numOfEntries; i++) {\n for (let j = 0; j < knnSize; j++) {\n const otherIndex = knnIndexes[i][j];\n const otherIndexOffset = offsetsCopy[otherIndex];\n transposeKNNIndexes[otherIndexOffset] = i;\n transposeKNNDistances[otherIndexOffset] = knnDistances[i][j];\n offsetsCopy[otherIndex] += 1;\n }\n }\n return { transposeKNNIndexes, transposeKNNDistances, transposeOffsets };\n });\n}\n//# sourceMappingURL=utils.js.map","import checkOptions from './checkOptions';\nimport errorCalculation from './errorCalculation';\nimport step from './step';\n/**\n * Curve fitting algorithm\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {function} parameterizedFunction - Takes an array of parameters and returns a function with the independent variable as its sole argument\n * @param {object} options - Options object\n * @param {ArrayLike<number>} options.initialValues - Array of initial parameter values\n * @param {number|ArrayLike<number>} [options.weights = 1] - weighting vector, if the length does not match with the number of data points, the vector is reconstructed with first value.\n * @param {number} [options.damping = 1e-2] - Levenberg-Marquardt parameter, small values of the damping parameter λ result in a Gauss-Newton update and large\nvalues of λ result in a gradient descent update\n * @param {number} [options.dampingStepDown = 9] - factor to reduce the damping (Levenberg-Marquardt parameter) when there is not an improvement when updating parameters.\n * @param {number} [options.dampingStepUp = 11] - factor to increase the damping (Levenberg-Marquardt parameter) when there is an improvement when updating parameters.\n * @param {number} [options.improvementThreshold = 1e-3] - the threshold to define an improvement through an update of parameters\n * @param {number|ArrayLike<number>} [options.gradientDifference = 10e-2] - The step size to approximate the jacobian matrix\n * @param {boolean} [options.centralDifference = false] - If true the jacobian matrix is approximated by central differences otherwise by forward differences\n * @param {ArrayLike<number>} [options.minValues] - Minimum allowed values for parameters\n * @param {ArrayLike<number>} [options.maxValues] - Maximum allowed values for parameters\n * @param {number} [options.maxIterations = 100] - Maximum of allowed iterations\n * @param {number} [options.errorTolerance = 10e-3] - Minimum uncertainty allowed for each point.\n * @param {number} [options.timeout] - maximum time running before throw in seconds.\n * @return {{parameterValues: Array<number>, parameterError: number, iterations: number}}\n */\nexport function levenbergMarquardt(data, parameterizedFunction, options) {\n let { checkTimeout, minValues, maxValues, parameters, weightSquare, damping, dampingStepUp, dampingStepDown, maxIterations, errorTolerance, centralDifference, gradientDifference, improvementThreshold, } = checkOptions(data, parameterizedFunction, options);\n let error = errorCalculation(data, parameters, parameterizedFunction, weightSquare);\n let optimalError = error;\n let optimalParameters = parameters.slice();\n let converged = error <= errorTolerance;\n let iteration = 0;\n for (; iteration < maxIterations && !converged; iteration++) {\n let previousError = error;\n let { perturbations, jacobianWeightResidualError } = step(data, parameters, damping, gradientDifference, parameterizedFunction, centralDifference, weightSquare);\n for (let k = 0; k < parameters.length; k++) {\n parameters[k] = Math.min(Math.max(minValues[k], parameters[k] - perturbations.get(k, 0)), maxValues[k]);\n }\n error = errorCalculation(data, parameters, parameterizedFunction, weightSquare);\n if (isNaN(error))\n break;\n if (error < optimalError - errorTolerance) {\n optimalError = error;\n optimalParameters = parameters.slice();\n }\n let improvementMetric = (previousError - error) /\n perturbations\n .transpose()\n .mmul(perturbations.mul(damping).add(jacobianWeightResidualError))\n .get(0, 0);\n if (improvementMetric > improvementThreshold) {\n damping = Math.max(damping / dampingStepDown, 1e-7);\n }\n else {\n damping = Math.min(damping * dampingStepUp, 1e7);\n }\n if (checkTimeout()) {\n throw new Error(`The execution time is over to ${options.timeout} seconds`);\n }\n converged = error <= errorTolerance;\n }\n return {\n parameterValues: optimalParameters,\n parameterError: optimalError,\n iterations: iteration,\n };\n}\n//# sourceMappingURL=index.js.map","import { isAnyArray } from 'is-any-array';\nexport default function checkOptions(data, parameterizedFunction, options) {\n let { timeout, minValues, maxValues, initialValues, weights = 1, damping = 1e-2, dampingStepUp = 11, dampingStepDown = 9, maxIterations = 100, errorTolerance = 1e-7, centralDifference = false, gradientDifference = 10e-2, improvementThreshold = 1e-3, } = options;\n if (damping <= 0) {\n throw new Error('The damping option must be a positive number');\n }\n else if (!data.x || !data.y) {\n throw new Error('The data parameter must have x and y elements');\n }\n else if (!isAnyArray(data.x) ||\n data.x.length < 2 ||\n !isAnyArray(data.y) ||\n data.y.length < 2) {\n throw new Error('The data parameter elements must be an array with more than 2 points');\n }\n else if (data.x.length !== data.y.length) {\n throw new Error('The data parameter elements must have the same size');\n }\n if (!(initialValues && initialValues.length > 0)) {\n throw new Error('The initialValues option is mandatory and must be an array');\n }\n let parameters = initialValues;\n let nbPoints = data.y.length;\n let parLen = parameters.length;\n maxValues = maxValues || new Array(parLen).fill(Number.MAX_SAFE_INTEGER);\n minValues = minValues || new Array(parLen).fill(Number.MIN_SAFE_INTEGER);\n if (maxValues.length !== minValues.length) {\n throw new Error('minValues and maxValues must be the same size');\n }\n if (typeof gradientDifference === 'number') {\n gradientDifference = new Array(parameters.length).fill(gradientDifference);\n }\n else if (isAnyArray(gradientDifference)) {\n if (gradientDifference.length !== parLen) {\n gradientDifference = new Array(parLen).fill(gradientDifference[0]);\n }\n }\n else {\n throw new Error('gradientDifference should be a number or array with length equal to the number of parameters');\n }\n let filler;\n if (typeof weights === 'number') {\n let value = 1 / weights ** 2;\n filler = () => value;\n }\n else if (isAnyArray(weights)) {\n if (weights.length < data.x.length) {\n let value = 1 / weights[0] ** 2;\n filler = () => value;\n }\n else {\n filler = (i) => 1 / weights[i] ** 2;\n }\n }\n else {\n throw new Error('weights should be a number or array with length equal to the number of data points');\n }\n let checkTimeout;\n if (timeout !== undefined) {\n if (typeof timeout !== 'number') {\n throw new Error('timeout should be a number');\n }\n let endTime = Date.now() + timeout * 1000;\n checkTimeout = () => Date.now() > endTime;\n }\n else {\n checkTimeout = () => false;\n }\n let weightSquare = new Array(data.x.length);\n for (let i = 0; i < nbPoints; i++) {\n weightSquare[i] = filler(i);\n }\n return {\n checkTimeout,\n minValues,\n maxValues,\n parameters,\n weightSquare,\n damping,\n dampingStepUp,\n dampingStepDown,\n maxIterations,\n errorTolerance,\n centralDifference,\n gradientDifference,\n improvementThreshold,\n };\n}\n//# sourceMappingURL=checkOptions.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getKnnSparseOpInfo } from './knn-sparse-info';\nimport { pairwiseOpSparse } from './pairwise-sparse-ops';\nimport { multiplyScalar, toOffsetForm, transposeKNN } from './utils';\nexport function performMatrixOps(knnIndexes, knnDistances, setOpMixRatio = 1.0) {\n return __awaiter(this, void 0, void 0, function* () {\n const flatKnnIndexes = new Int32Array(knnIndexes.length * knnIndexes[0].length);\n const flatKnnDistances = new Float32Array(knnDistances.length * knnDistances[0].length);\n for (let i = 0; i < knnIndexes.length; i++) {\n flatKnnIndexes.set(knnIndexes[i], i * knnIndexes[i].length);\n flatKnnDistances.set(knnDistances[i], i * knnDistances[i].length);\n }\n const unionInfo = yield getKnnSparseOpInfo(knnIndexes);\n const numOfEntries = knnIndexes.length;\n const transposed = yield transposeKNN(knnIndexes, knnDistances, unionInfo, knnDistances[0].length);\n const sourceOffsets = toOffsetForm(new Uint32Array(numOfEntries).fill(knnIndexes[0].length));\n const unionMatrixOffsets = toOffsetForm(unionInfo.resultUnionSizesArray);\n const transposeMultRes = yield pairwiseOpSparse(flatKnnIndexes, flatKnnDistances, sourceOffsets, transposed.transposeKNNIndexes, transposed.transposeKNNDistances, transposed.transposeOffsets, numOfEntries, unionMatrixOffsets, '*');\n const addRes = yield pairwiseOpSparse(flatKnnIndexes, flatKnnDistances, sourceOffsets, transposed.transposeKNNIndexes, transposed.transposeKNNDistances, transposed.transposeOffsets, numOfEntries, unionMatrixOffsets, '+');\n // these offsets will be same as union matrix offsets\n const subtRes = yield pairwiseOpSparse(addRes.resultKnnIndexes, addRes.resultKnnDistances, unionMatrixOffsets, transposeMultRes.resultKnnIndexes, transposeMultRes.resultKnnDistances, unionMatrixOffsets, numOfEntries, unionMatrixOffsets, '-');\n if (setOpMixRatio !== 1.0) {\n multiplyScalar(subtRes.resultKnnDistances, setOpMixRatio);\n multiplyScalar(transposeMultRes.resultKnnDistances, 1.0 - setOpMixRatio);\n const res = yield pairwiseOpSparse(subtRes.resultKnnIndexes, subtRes.resultKnnDistances, unionMatrixOffsets, transposeMultRes.resultKnnIndexes, transposeMultRes.resultKnnDistances, unionMatrixOffsets, numOfEntries, unionMatrixOffsets, '+');\n return { res, unionMatrixOffsets };\n }\n return { res: subtRes, unionMatrixOffsets, unionSizes: unionInfo.resultUnionSizesArray };\n });\n}\n//# sourceMappingURL=fuzzy-simplical-set.js.map","/* eslint-disable max-len */\nexport function knnMatrixOpInfoWGSL(threadsPerWorkgroupDim, threadsPerYDimension, entryLen, knnSize = 15) {\n return `\n\n @group(0) @binding(0) var<storage, read_write> knnIndexes: array<array<i32, ${knnSize}>, ${entryLen}>;\n @group(0) @binding(1) var<storage, read_write> resTransposedSizes: array<atomic<u32>, ${entryLen}>;\n // this array will store the union of knn and its transpose sizes per index. should be initialized to knnSize each.\n @group(0) @binding(2) var<storage, read_write> resUnionMatrixSizes: array<atomic<u32>, ${entryLen}>;\n\n @compute @workgroup_size(${threadsPerWorkgroupDim}, ${threadsPerWorkgroupDim}) fn countTransposedCols(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n let col: u32 = id.x;\n let row: u32 = id.y;\n let workingIndex: u32 = row * ${threadsPerYDimension} + col;\n\n if (workingIndex >= ${entryLen}) {\n return;\n }\n \n for (var i = 0u; i < ${knnSize}u; i++) {\n let otherIndex: i32 = knnIndexes[workingIndex][i];\n if (otherIndex != -1 && otherIndex < ${entryLen}) {\n atomicAdd(&resTransposedSizes[otherIndex], 1u);\n atomicAdd(&resUnionMatrixSizes[otherIndex], 1u);\n let otherIndexes = &knnIndexes[otherIndex];\n for(var j = 0u; j < ${knnSize}; j++) {\n if ((*otherIndexes)[j] == i32(workingIndex)) {\n atomicSub(&resUnionMatrixSizes[workingIndex], 1u);\n // if same is found in other array, decrement by one;\n break;\n }\n }\n }\n\n }\n }\n `;\n}\n//# sourceMappingURL=knn-sparse-info.wgsl.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\nimport { smoothKNNDistanceWGSL } from './wgsl/smooth-knn-distance.wgsl';\nexport function smoothKNNDistance(knnDistances, nNeighbors = 15, localConnectivity = 1.0, nIter = 64, bandwidth = 1.0) {\n return __awaiter(this, void 0, void 0, function* () {\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const numOfEntries = knnDistances.length;\n const requiredWorkgroups = Math.ceil(numOfEntries / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const processWgsl = smoothKNNDistanceWGSL(threadsPerWorkgroupDim, threadsPerWorkgroupDim * numOfWorkgroupsPerDim, knnDistances, nNeighbors, localConnectivity, nIter, bandwidth);\n const distanceBuffer32Size = numOfEntries * knnDistances[0].length;\n // const flatDistanceArray = new Float32Array(distanceBuffer32Size);\n // for (let i = 0; i < knnDistances.length; i ++) {\n // flatDistanceArray.set(knnDistances[i], i * knnDistances[i].length);\n // }\n const device = yield getGPUDevice();\n if (device == null)\n return;\n const resultSigmas = new Float32Array(numOfEntries);\n const resultRhos = new Float32Array(numOfEntries);\n const module = device.createShaderModule({\n label: 'sigmaRhoCalulation',\n code: processWgsl\n });\n const pipeline = device.createComputePipeline({\n label: 'sigmaRhoPipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'smoothKNNDistance',\n },\n });\n const distancesBuffer = device.createBuffer({\n label: 'distance buffer',\n size: distanceBuffer32Size * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedDistanceBuffer = distancesBuffer.getMappedRange();\n const mappedDistanceArray = new Float32Array(mappedDistanceBuffer);\n for (let i = 0; i < knnDistances.length; i++)\n mappedDistanceArray.set(knnDistances[i], i * knnDistances[i].length);\n distancesBuffer.unmap();\n const bufferSigmas = device.createBuffer({\n label: 'buffer sigmas',\n size: numOfEntries * 4,\n usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,\n });\n const bufferRhos = device.createBuffer({\n label: 'buffer Rhos',\n size: numOfEntries * 4,\n usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,\n });\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for sigmarho buffers',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: bufferSigmas } },\n { binding: 1, resource: { buffer: bufferRhos } },\n { binding: 2, resource: { buffer: distancesBuffer } },\n // { binding: 4, resource: { buffer: arraySizesBuffer } },\n ],\n });\n const encoder = device.createCommandEncoder({\n label: 'sigmarho encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'sigmarho compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n const resultBufferRhos = device.createBuffer({\n label: 'result buffer rhos',\n size: bufferRhos.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n const resultBufferSigmas = device.createBuffer({\n label: 'result buffer sigmas',\n size: bufferSigmas.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n encoder.copyBufferToBuffer(bufferRhos, 0, resultBufferRhos, 0, resultBufferRhos.size);\n encoder.copyBufferToBuffer(bufferSigmas, 0, resultBufferSigmas, 0, resultBufferSigmas.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n yield resultBufferRhos.mapAsync(GPUMapMode.READ);\n yield resultBufferSigmas.mapAsync(GPUMapMode.READ);\n resultRhos.set(new Float32Array(resultBufferRhos.getMappedRange()));\n resultSigmas.set(new Float32Array(resultBufferSigmas.getMappedRange()));\n resultBufferRhos.unmap();\n resultBufferSigmas.unmap();\n distancesBuffer.destroy();\n bufferSigmas.destroy();\n bufferRhos.destroy();\n resultBufferRhos.destroy();\n resultBufferSigmas.destroy();\n return { resultRhos, resultSigmas };\n });\n}\n//# sourceMappingURL=smooth-knn-distance.js.map","export function smoothKNNDistanceWGSL(threadsPerWorkgroupDim = 10, threadsPerYDimension, knnDistances, nNeighbors = 15, localConnectivity = 1.0, nIter = 64, bandwidth = 1.0) {\n const numOfEntries = knnDistances.length;\n let meanDistancesSum = 0.0;\n for (let i = 0; i < numOfEntries; i++) {\n let currentMean = 0.0;\n for (let j = 0; j < nNeighbors; j++)\n currentMean += knnDistances[i][j];\n meanDistancesSum += currentMean / nNeighbors;\n }\n const meanDistances = meanDistancesSum / numOfEntries;\n const target = Math.log(nNeighbors) / Math.log(2) * bandwidth;\n return ` \n var<private> SMOOTH_K_TOLERANCE: f32 = 1e-5;\n var<private> MIN_K_DIST_SCALE: f32 = 1e-3;\n var<private> nNeighbors: u32 = ${nNeighbors};\n var<private> localConnectivity: f32 = ${localConnectivity}; \n var<private> nIter: u32 = ${nIter};\n var<private> bandwidth: u32 = ${bandwidth};\n var<private> meanDistances: f32 = ${meanDistances};\n var<private> targetValue: f32 = ${target};\n @group(0) @binding(0) var<storage, read_write> sigmas: array<f32, ${numOfEntries}>;\n @group(0) @binding(1) var<storage, read_write> rhos: array<f32, ${numOfEntries}>;\n @group(0) @binding(2) var<storage, read> distances: array<array<f32, ${nNeighbors}>, ${numOfEntries}>;\n @compute @workgroup_size(${threadsPerWorkgroupDim}, ${threadsPerWorkgroupDim}) fn smoothKNNDistance(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n let col: u32 = id.x;\n let row: u32 = id.y;\n let workingIndex: u32 = row * ${threadsPerYDimension} + col;\n\n if (workingIndex >= ${numOfEntries}) {\n return;\n }\n\n var lo: f32 = 0.0;\n var hi: f32 = 1.0e+30; // treated as Infinity\n var mid: f32 = 1.0;\n\n var nonZeroDists: array<f32, ${nNeighbors}>;\n var nonZeroDistsSize: u32 = 0;\n for (var j = 0u; j < nNeighbors; j = j + 1u) {\n if (distances[workingIndex][j] > 0.0) {\n nonZeroDists[nonZeroDistsSize] = distances[workingIndex][j];\n nonZeroDistsSize = nonZeroDistsSize + 1u;\n }\n }\n\n if (f32(nonZeroDistsSize) >= localConnectivity) {\n let index: u32 = u32(floor(localConnectivity));\n let interpolation: f32 = localConnectivity - f32(index);\n if (index > 0) {\n rhos[workingIndex] = nonZeroDists[index - 1];\n if (interpolation > SMOOTH_K_TOLERANCE) {\n rhos[workingIndex] += interpolation * (nonZeroDists[index] - nonZeroDists[index - 1]);\n }\n }\n else {\n rhos[workingIndex] = interpolation * nonZeroDists[0];\n }\n }\n else if (nonZeroDistsSize > 0u) {\n var maxDist: f32 = 0.0;\n for (var j = 0u; j < nonZeroDistsSize; j = j + 1u) {\n maxDist = max(nonZeroDists[j], maxDist);\n }\n rhos[workingIndex] = maxDist;\n }\n\n for (var n = 0u; n < nIter; n = n + 1u) {\n var psum: f32 = 0.0;\n for (var j = 1u; j < ${nNeighbors}; j = j + 1u) {\n let d: f32 = distances[workingIndex][j] - rhos[workingIndex];\n if (d > 0.0) {\n psum += exp(0.0 - (d / mid));\n }\n else {\n psum += 1.0;\n }\n }\n\n if (abs(psum - targetValue) < SMOOTH_K_TOLERANCE) {\n break;\n }\n\n if (psum > targetValue) {\n hi = mid;\n mid = (lo + hi) / 2.0;\n }\n else {\n lo = mid;\n if (hi == 1.0e+30) {\n mid *= 2.0;\n }\n else {\n mid = (lo + hi) / 2.0;\n }\n }\n }\n\n sigmas[workingIndex] = mid;\n\n if (rhos[workingIndex] > 0.0) {\n var sum: f32 = 0.0;\n for (var j = 0u; j < ${nNeighbors}; j = j + 1u) {\n sum += distances[workingIndex][j];\n }\n let meanIthDistances: f32 = sum / ${nNeighbors}.0;\n if (sigmas[workingIndex] < MIN_K_DIST_SCALE * meanIthDistances) {\n sigmas[workingIndex] = MIN_K_DIST_SCALE * meanIthDistances;\n }\n }\n else {\n if (sigmas[workingIndex] < MIN_K_DIST_SCALE * meanDistances) {\n sigmas[workingIndex] = MIN_K_DIST_SCALE * meanDistances;\n }\n }\n }\n `;\n}\n//# sourceMappingURL=smooth-knn-distance.wgsl.js.map","/* eslint-disable max-len */\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { performMatrixOps } from './fuzzy-simplical-set';\nimport { computeMembershipStrengths } from './membership-strengths';\nimport { optimizationLoop } from './optimization-loop';\nimport { initializeSimplicialSetEmbedding } from './simplical-set-embedding';\nimport { smoothKNNDistance } from './smooth-knn-distance';\n// TODO: FIT ASYNC METHOD WITH CALLBACKS on each step\n// TODO: random function passing in params\nexport class UmapParams {\n constructor() {\n this.nComponents = 2;\n this.gamma = 1;\n this.alpha = 1;\n this.entryLen = 0;\n this.nNeighbours = 15;\n this.spread = 1;\n this.minDist = 0.1;\n this.negativeSampleRate = 5;\n this.localConnectivity = 1.0;\n this.setOpMixRatio = 1.0;\n }\n}\nexport class WebGPUUMAP {\n constructor(entryLen, params) {\n this.params = new UmapParams();\n this.knnIndexes = null;\n this.knnDistances = null;\n this.rhos = null;\n this.sigmas = null;\n this.membershipStrengths = null;\n this.params.entryLen = entryLen;\n Object.assign(this.params, params);\n }\n setPrecomputedKNN(knnIndexes, knnDistances) {\n this.knnIndexes = knnIndexes;\n this.knnDistances = knnDistances;\n }\n // for now, not sure if we should include this, maybe webGPU UMAP should be stand alone.\n // eslint-disable-next-line max-len\n // async calcKNN(entryList: SupportedEntryTypes[][], distanceMetrics: WEBGPUDISTANCE[], aggregationFunction: WEBGSLAGGREGATION, weights: number[], options: {\n // [key: string]: any;\n // }[]) {\n // try {\n // const knnRes = await multiColWebGPUKNN(entryList, this.params.nNeighbours, distanceMetrics, aggregationFunction, weights, options);\n // if (knnRes) {\n // this.knnIndexes = knnRes.knnIndexes;\n // this.knnDistances = knnRes.knnDistances;\n // }\n // } catch (e) {\n // console.error(e);\n // }\n // if (!this.knnIndexes || !this.knnDistances)\n // throw new Error('failed to compute knn indexes and distances');\n // }\n // async calcKNNSingle(entryList: SupportedEntryTypes[], distanceMetrics: WEBGPUDISTANCE, options?: {\n // [key: string]: any;\n // }) {\n // if (!options)\n // options = {};\n // await this.calcKNN([entryList], [distanceMetrics], WEBGSLAGGREGATION.MANHATTAN, [1], [options]);\n // }\n initializeFit() {\n return __awaiter(this, void 0, void 0, function* () {\n yield this.calcSmoothKNNDistances();\n yield this.calcMembershipStrengths();\n });\n }\n fit() {\n return __awaiter(this, void 0, void 0, function* () {\n yield this.initializeFit();\n const umapParams = yield this.initializeSimplicialSetEmbedding();\n if (!umapParams)\n throw new Error('failed to compute umap simplistical set embeddings');\n const { head, tail, epochsPerSample, epochsPerNegativeSample, a, b, gamma, initialAlpha, nComponents, nEpochs, entryLen } = umapParams;\n const resEmbeddings = yield optimizationLoop(head, tail, entryLen, epochsPerSample, epochsPerNegativeSample, initialAlpha, gamma, a, b, nComponents, nEpochs, entryLen);\n return resEmbeddings;\n });\n }\n calcSmoothKNNDistances() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!this.knnIndexes || !this.knnDistances)\n throw new Error('knn indexes and distances must be set before calling fit');\n const res = yield smoothKNNDistance(this.knnDistances, this.params.nNeighbours, this.params.localConnectivity, 64);\n if (!res)\n throw new Error('failed to compute smooth knn distances');\n this.rhos = res.resultRhos;\n this.sigmas = res.resultSigmas;\n });\n }\n calcMembershipStrengths() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!this.knnIndexes || !this.knnDistances || !this.rhos || !this.sigmas)\n throw new Error('knn indexes, distances, rhos, and sigmas must be set before calling fit');\n const res = yield computeMembershipStrengths(this.knnDistances, this.sigmas, this.rhos);\n if (!res)\n throw new Error('failed to compute membership strengths');\n this.membershipStrengths = res;\n });\n }\n fuzzySimplicialSet() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!this.knnIndexes || !this.knnDistances || !this.rhos || !this.sigmas || !this.membershipStrengths)\n throw new Error('knn indexes, distances, rhos, sigmas, and membership strengths must be set before calling fit');\n const res = yield performMatrixOps(this.knnIndexes, this.membershipStrengths, this.params.setOpMixRatio);\n if (!res)\n throw new Error('failed to compute pairwise multiply with transpose');\n return res;\n });\n }\n initializeSimplicialSetEmbedding() {\n return __awaiter(this, void 0, void 0, function* () {\n const fuzzySimplicialSetRes = yield this.fuzzySimplicialSet();\n if (!fuzzySimplicialSetRes || !fuzzySimplicialSetRes.res || !fuzzySimplicialSetRes.unionMatrixOffsets || !fuzzySimplicialSetRes.unionSizes)\n throw new Error('failed to compute fuzzy simplicial set');\n const eRes = yield initializeSimplicialSetEmbedding(fuzzySimplicialSetRes, this.params.entryLen, this.params.spread, this.params.minDist, this.params.negativeSampleRate);\n if (!eRes)\n throw new Error('failed to compute umap simplistical set embeddings');\n return eRes;\n });\n }\n}\n//# sourceMappingURL=WEBGPU-UMAP.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\nimport { optimizeLayoutWGSL } from './wgsl/optimization-loop.wgsl';\nexport function optimizationLoop(head, tail, embeddingSize, epochsPerSample, epochsPerNegativeSample, initialAlpha, gamma, a, b, dim, nEpochs, nVertices) {\n return __awaiter(this, void 0, void 0, function* () {\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const requiredWorkgroups = Math.ceil(head.length / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const threadsPerYDimension = threadsPerWorkgroupDim * numOfWorkgroupsPerDim;\n const device = yield getGPUDevice();\n if (!device)\n return;\n const divisionFactor = 10000000;\n const headSize = head.length;\n const processWGSL = optimizeLayoutWGSL(headSize, embeddingSize, true, initialAlpha, gamma, a, b, dim, nEpochs, nVertices, threadsPerWorkgroupDim, threadsPerYDimension, divisionFactor);\n // head/tail\n const matrixStorage32Size = headSize * 2;\n let paddedMatrixStorageSize = matrixStorage32Size * 4;\n const remainder1 = paddedMatrixStorageSize & 15;\n if (remainder1 !== 0)\n paddedMatrixStorageSize += 16 - remainder1;\n const epochStorage32Size = headSize * 4;\n let paddedepochStorageSize = epochStorage32Size * 4;\n const remainder2 = paddedepochStorageSize & 15;\n if (remainder2 !== 0)\n paddedepochStorageSize += 16 - remainder2;\n const embedStorage32Size = embeddingSize * 2 * 2;\n let paddedembedStorageSize = embedStorage32Size * 4;\n const remainder3 = paddedembedStorageSize & 15;\n if (remainder3 !== 0)\n paddedembedStorageSize += 16 - remainder3;\n const comuteInfo32Size = 2 + headSize;\n let paddedComputeInfoSize = comuteInfo32Size * 4;\n const remainder4 = paddedComputeInfoSize & 15;\n if (remainder4 !== 0)\n paddedComputeInfoSize += 16 - remainder4;\n const module = device.createShaderModule({\n label: 'optimizeShader',\n code: processWGSL\n });\n const pipeline = device.createComputePipeline({\n label: 'optimizePipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'optimizeStep',\n },\n });\n const matrixStorageBuffer = device.createBuffer({\n label: 'matrix storage buffer',\n size: paddedMatrixStorageSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const matrixStorageArrayBuffer = matrixStorageBuffer.getMappedRange();\n const headView = new Uint32Array(matrixStorageArrayBuffer, 0, headSize);\n headView.set(head);\n const tailView = new Uint32Array(matrixStorageArrayBuffer, headSize * 4, headSize);\n tailView.set(tail);\n matrixStorageBuffer.unmap();\n const epochStorageBuffer = device.createBuffer({\n label: 'epoch storage buffer',\n size: paddedepochStorageSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const epochStorageArrayBuffer = epochStorageBuffer.getMappedRange();\n // all are float32 so we get the whole view\n const epochStorageArrayView = new Float32Array(epochStorageArrayBuffer);\n // first epochsPerSample\n epochStorageArrayView.set(epochsPerSample, 0);\n //epochOfNextSample, set to same\n epochStorageArrayView.set(epochsPerSample, headSize);\n //epochsPerNegativeSample\n epochStorageArrayView.set(epochsPerNegativeSample, headSize * 2);\n //epochOfNextNegativeSample\n epochStorageArrayView.set(epochsPerNegativeSample, headSize * 3);\n epochStorageBuffer.unmap();\n const headEmbeddings = new Int32Array(embeddingSize * dim).map(() => Math.floor((Math.random() * 2 - 1) * divisionFactor));\n const tailEmbeddings = new Int32Array(embeddingSize * dim);\n tailEmbeddings.set(headEmbeddings);\n const embeddingStorageBuffer = device.createBuffer({\n label: 'embedding storage buffer',\n size: paddedembedStorageSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedEmbeddingStorageBuffer = embeddingStorageBuffer.getMappedRange();\n const mappedEmbeddingStorageArray = new Int32Array(mappedEmbeddingStorageBuffer);\n mappedEmbeddingStorageArray.set(headEmbeddings, 0);\n mappedEmbeddingStorageArray.set(headEmbeddings, headEmbeddings.length);\n embeddingStorageBuffer.unmap();\n const computeInfoBuffer = device.createBuffer({\n label: 'compute info buffer',\n size: paddedComputeInfoSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const randomNumbers = new Uint32Array(headSize).map(() => Math.floor(Math.random() * divisionFactor));\n const computeInfoArrayBuffer = computeInfoBuffer.getMappedRange();\n const computeInfoMappedArray = new Float32Array(computeInfoArrayBuffer, 0, 2);\n computeInfoMappedArray.set([0.0, initialAlpha]);\n const randomNumbersView = new Uint32Array(computeInfoArrayBuffer, 8, headSize);\n randomNumbersView.set(randomNumbers);\n computeInfoBuffer.unmap();\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for optimize',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: matrixStorageBuffer } },\n { binding: 1, resource: { buffer: epochStorageBuffer } },\n { binding: 2, resource: { buffer: embeddingStorageBuffer } },\n { binding: 3, resource: { buffer: computeInfoBuffer } }\n ],\n });\n let alpha = initialAlpha;\n const outEmbedViewBuffer = device.createBuffer({\n label: 'result buffer',\n size: embeddingStorageBuffer.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n for (let iter = 0; iter < nEpochs; iter++) {\n // write n and alpha\n device.queue.writeBuffer(computeInfoBuffer, 0, new Float32Array([iter, alpha]), 0);\n const encoder = device.createCommandEncoder({\n label: 'matrix ops encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'matrix ops compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n // here, we copy the head/tail views to their correct places in embeddings.\n if (iter === nEpochs - 1)\n encoder.copyBufferToBuffer(embeddingStorageBuffer, 0, outEmbedViewBuffer, 0, outEmbedViewBuffer.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n alpha = initialAlpha * (1.0 - iter / nEpochs);\n }\n yield outEmbedViewBuffer.mapAsync(GPUMapMode.READ);\n const resArrayBuffer = outEmbedViewBuffer.getMappedRange();\n const headEmbeddingsView = new Int32Array(resArrayBuffer, 0, headEmbeddings.length);\n headEmbeddings.set(headEmbeddingsView);\n outEmbedViewBuffer.unmap();\n const result = new Array(dim).fill(null).map((_) => new Float32Array(embeddingSize));\n for (let i = 0; i < embeddingSize; i++) {\n for (let j = 0; j < dim; j++)\n result[j][i] = headEmbeddings[i * dim + j] / divisionFactor;\n }\n matrixStorageBuffer.destroy();\n epochStorageBuffer.destroy();\n embeddingStorageBuffer.destroy();\n computeInfoBuffer.destroy();\n outEmbedViewBuffer.destroy();\n return result;\n });\n}\n//# sourceMappingURL=optimization-loop.js.map","/* eslint-disable max-len */\nexport function optimizeLayoutWGSL(headSize, embedSize, moveOther, initialAlpha, gamma, a, b, dim, nEpochs, nVertices, workgroupDim, threadsPerRow, divisionFactor = 100000) {\n return `\n// first define some functions\n\nfn rDist(ar1: array<f32, ${dim}>, ar2: array<f32, ${dim}>) -> f32 {\n var res = 0.0;\n for (var i1 = 0u; i1 < ${dim}; i1++) {\n let diff = ar1[i1] - ar2[i1];\n res += pow(diff, 2);\n }\n return res;\n}\n\nfn clip(x: f32, clipValue: f32) -> f32 {\n if (x > clipValue) {\n return clipValue;\n }\n else if (x < 0.0 - clipValue) {\n return 0.0 - clipValue;\n }\n return x;\n}\n\nvar<private> randomSeedInt: u32 = 0;\nvar<private> nVertices: u32 = ${nVertices};\nvar<private> initialAlpha: f32 = ${initialAlpha};\nvar<private> gamma: f32 = ${gamma};\nvar<private> a: f32 = ${a};\nvar<private> b: f32 = ${b};\nvar<private> dim: u32 = ${dim};\nvar<private> nEpochs: f32 = ${nEpochs};\nvar<private> moveOther: u32 = ${moveOther === true ? 1 : 0};\n\nfn random() -> u32 {\n randomSeedInt = (randomSeedInt ^ 61) ^ (randomSeedInt >> 16);\n randomSeedInt *= 9;\n randomSeedInt = randomSeedInt ^ (randomSeedInt >> 4);\n randomSeedInt *= 0x27d4eb2d;\n randomSeedInt = randomSeedInt ^ (randomSeedInt >> 15);\n return randomSeedInt;\n}\n\nfn randInt(maxVal: u32) -> u32 {\n let nextRandomNum = random();\n return u32(floor((f32(nextRandomNum) * (f32(maxVal) / 4294967296.0))));\n}\n\nstruct MatrixStorage {\n head: array<u32, ${headSize}>,\n tail: array<u32, ${headSize}>,\n}\n\nstruct EpochStorage {\n epochsPerSample: array<f32, ${headSize}>,\n epochOfNextSample: array<f32, ${headSize}>,\n epochsPerNegativeSample: array<f32, ${headSize}>,\n epochOfNextNegativeSample: array<f32, ${headSize}>\n}\n\nstruct EmbeddingStorage {\n // embeddings will be in range of -10 to 10, as atomics only can store i32 or u32, we will store them as floor(f32 * 100_000)\n headEmbeddings: array<array<atomic<i32>, ${dim}>, ${embedSize}>,\n tailEmbeddings: array<array<atomic<i32>, ${dim}>, ${embedSize}>\n}\n\nstruct ComputeInfo {\n n: f32,\n alpha: f32,\n randomNumbers: array<u32, ${headSize}>,\n //tailOffsets: array<u32, ${embedSize + 1}>\n}\n @group(0) @binding(0) var<storage, read_write> matrixStorage: MatrixStorage;\n @group(0) @binding(1) var<storage, read_write> epochStorage: EpochStorage;\n @group(0) @binding(2) var<storage, read_write> embedStorage: EmbeddingStorage;\n @group(0) @binding(3) var<storage, read_write> computeInfo: ComputeInfo;\n @compute @workgroup_size(${workgroupDim}, ${workgroupDim}) fn optimizeStep(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n let divisionFactor: f32 = ${divisionFactor};\n let col: u32 = id.x;\n let row: u32 = id.y;\n let threadIndex: u32 = row * ${threadsPerRow} + col;\n let clipValue: f32 = 4.0;\n\n if (threadIndex >= ${headSize}) {\n return;\n }\n\n let workingIndex = threadIndex;\n //let startAtOffset = computeInfo.tailOffsets[threadIndex];\n //let endAtOffset = computeInfo.tailOffsets[threadIndex + 1];\n //for (var workingIndex = startAtOffset; workingIndex < endAtOffset; workingIndex++) {\n randomSeedInt = computeInfo.randomNumbers[workingIndex] * u32(computeInfo.n);\n\n let epochOfNextSample = epochStorage.epochOfNextSample[workingIndex];\n if (epochOfNextSample > computeInfo.n) {\n return;\n }\n\n let j = matrixStorage.head[workingIndex];\n let k = matrixStorage.tail[workingIndex];\n\n // as said before, we will store embeddings as floor(f32 * 100_000)\n var current: array<f32, ${dim}>;\n var other: array<f32, ${dim}>;\n for (var i = 0u; i < ${dim}u; i++) {\n current[i] = f32(atomicLoad(&embedStorage.headEmbeddings[j][i])) / divisionFactor;\n other[i] = f32(atomicLoad(&embedStorage.tailEmbeddings[k][i])) / divisionFactor;\n }\n\n let distSquared = rDist(current, other);\n \n var gradCoeff: f32 = 0.0;\n if (distSquared > 0.0) {\n gradCoeff = (0.0 - 2.0) * ${a} * ${b} * pow(distSquared, b - 1.0);\n gradCoeff /= (a * pow(distSquared, b) + 1.0);\n }\n\n var gradBuff: array<i32, ${dim}>;\n for (var d = 0u; d < ${dim}u; d++) {\n let gradD = clip((gradCoeff * (current[d] - other[d])), clipValue);\n let toAdd = gradD * computeInfo.alpha;\n gradBuff[d] = i32(floor(toAdd * divisionFactor));\n current[d] += toAdd;\n other[d] -= toAdd;\n }\n\n for (var d = 0u; d < ${dim}u; d++) {\n atomicAdd(&embedStorage.headEmbeddings[j][d], gradBuff[d]);\n atomicSub(&embedStorage.tailEmbeddings[k][d], gradBuff[d]);\n }\n\n epochStorage.epochOfNextSample[workingIndex] += epochStorage.epochsPerSample[workingIndex];\n var nNegSamples: i32 = i32(floor((computeInfo.n - epochStorage.epochOfNextNegativeSample[workingIndex]) / epochStorage.epochsPerNegativeSample[workingIndex]));\n\n for (var p = 0i; p < nNegSamples; p++) {\n let k1 = randInt(nVertices);\n var other1: array<f32, ${dim}>;\n for (var i = 0u; i < ${dim}u; i++) {\n other1[i] = f32(atomicLoad(&embedStorage.tailEmbeddings[k1][i])) / divisionFactor;\n }\n\n let distSquared1 = rDist(current, other1);\n\n var gradCoeff1: f32 = 0.0;\n if (distSquared1 > 0.0) {\n gradCoeff1 = 2.0 * gamma * b;\n gradCoeff1 /= (0.001 + distSquared1) * (a * pow(distSquared1, b) + 1);\n }\n else if (j == k1) {\n continue;\n }\n\n var gradDBuff: array<i32, ${dim}>;\n for (var d = 0u; d < ${dim}u; d++) {\n var gradD: f32 = 4.0;\n if (gradCoeff1 > 0.0) {\n gradD = clip(gradCoeff1 * (current[d] - other1[d]), clipValue);\n }\n\n gradDBuff[d] = i32(floor(gradD * computeInfo.alpha * divisionFactor));\n \n }\n for (var d = 0u; d < ${dim}u; d++) {\n atomicAdd(&embedStorage.headEmbeddings[j][d], gradDBuff[d]);\n }\n }\n epochStorage.epochOfNextNegativeSample[workingIndex] += f32(nNegSamples) * epochStorage.epochsPerNegativeSample[workingIndex];\n //}\n }\n`;\n}\n//# sourceMappingURL=optimization-loop.wgsl.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\nimport { computeMembershipStrengthsWGSL } from './wgsl/membership-strengths.wgsl';\nexport function computeMembershipStrengths(knnDistances, sigmas, rhos) {\n return __awaiter(this, void 0, void 0, function* () {\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const numOfEntries = knnDistances.length;\n const requiredWorkgroups = Math.ceil(numOfEntries / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const processWgsl = computeMembershipStrengthsWGSL(threadsPerWorkgroupDim, threadsPerWorkgroupDim * numOfWorkgroupsPerDim, knnDistances, sigmas, rhos);\n const distanceBuffer32Size = numOfEntries * knnDistances[0].length;\n const device = yield getGPUDevice();\n if (device == null)\n return;\n const module = device.createShaderModule({\n label: 'rowsColsValsCalulation',\n code: processWgsl\n });\n const pipeline = device.createComputePipeline({\n label: 'rowsColsValsPipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'computeMembershipStrengths',\n },\n });\n const rhos32Size = rhos.length;\n const sigmas32Size = sigmas.length;\n const combinedMembershipStrengthsInfo32Size = rhos32Size + sigmas32Size + distanceBuffer32Size;\n let paddedCombinedMembershipStructByteSize = combinedMembershipStrengthsInfo32Size * 4;\n const remainder = paddedCombinedMembershipStructByteSize & 15;\n if (remainder != 0)\n paddedCombinedMembershipStructByteSize += 16 - remainder;\n // input params\n const membershipStrengthsInfoBuffer = device.createBuffer({\n label: 'info buffer',\n size: paddedCombinedMembershipStructByteSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedInfoBuffer = membershipStrengthsInfoBuffer.getMappedRange();\n const mappedInfoArray = new Float32Array(mappedInfoBuffer);\n // first set knn distances\n for (let i = 0; i < knnDistances.length; i++)\n mappedInfoArray.set(knnDistances[i], i * knnDistances[i].length);\n let offset = knnDistances[0].length * knnDistances.length;\n // now set sigmas\n mappedInfoArray.set(sigmas, offset);\n offset += sigmas.length;\n // now set rhos\n mappedInfoArray.set(rhos, offset);\n membershipStrengthsInfoBuffer.unmap();\n const knnDistancesBuffer = device.createBuffer({\n label: 'knn distance buffer',\n size: knnDistances[0].length * knnDistances.length * Float32Array.BYTES_PER_ELEMENT,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n });\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for membership strhegths buffers',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: membershipStrengthsInfoBuffer } },\n { binding: 1, resource: { buffer: knnDistancesBuffer } },\n // { binding: 4, resource: { buffer: arraySizesBuffer } },\n ],\n });\n const encoder = device.createCommandEncoder({\n label: 'membership strengths encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'membership strengths compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n const resultBufferDistances = device.createBuffer({\n label: 'result buffer distances',\n size: knnDistancesBuffer.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n encoder.copyBufferToBuffer(knnDistancesBuffer, 0, resultBufferDistances, 0, resultBufferDistances.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n yield resultBufferDistances.mapAsync(GPUMapMode.READ);\n const resultKnnDistancesArrayBuffer = resultBufferDistances.getMappedRange();\n const bytesPerKnnRow = knnDistances[0].length * Float32Array.BYTES_PER_ELEMENT;\n const resKnnDistances = new Array(knnDistances.length).fill(null).map((_, i) => {\n const dataView = new Float32Array(resultKnnDistancesArrayBuffer, bytesPerKnnRow * i, knnDistances[0].length);\n const out = new Float32Array(knnDistances[0].length);\n out.set(dataView);\n return out;\n });\n resultBufferDistances.unmap();\n resultBufferDistances.destroy();\n knnDistancesBuffer.destroy();\n membershipStrengthsInfoBuffer.destroy();\n return resKnnDistances;\n });\n}\n//# sourceMappingURL=membership-strengths.js.map","/* eslint-disable max-len */\nexport function computeMembershipStrengthsWGSL(threadsPerWorkgroupDim = 10, threadsPerYDimension, knnDistances, sigmas, rhos) {\n const numOfEntries = knnDistances.length;\n const sigmasLength = sigmas.length;\n const rhosLength = rhos.length;\n // TODO: do it with structs\n return `\n struct MembershipStrengthsInfo {\n knnDistances: array<array<f32, ${knnDistances[0].length}>, ${numOfEntries}>,\n sigmas: array<f32, ${sigmasLength}>,\n rhos: array<f32, ${rhosLength}>\n };\n var<private> nNeighbors: u32 = ${knnDistances[0].length};\n @group(0) @binding(0) var<storage, read> membershipStrengthsInfo: MembershipStrengthsInfo;\n @group(0) @binding(1) var<storage, read_write> resultKnnDistances: array<array<f32, ${knnDistances[0].length}>, ${numOfEntries}>;\n @compute @workgroup_size(${threadsPerWorkgroupDim}, ${threadsPerWorkgroupDim}) fn computeMembershipStrengths(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n let col: u32 = id.x;\n let row: u32 = id.y;\n let workingIndex: u32 = row * ${threadsPerYDimension} + col;\n\n if (workingIndex >= ${numOfEntries}) {\n return;\n }\n\n let workingResKnnDistances = &resultKnnDistances[workingIndex];\n let knnDistances = &membershipStrengthsInfo.knnDistances[workingIndex];\n for (var j = 0u; j < nNeighbors; j = j + 1u) {\n var val: f32 = 0.0;\n\n if ((*knnDistances)[j] - membershipStrengthsInfo.rhos[workingIndex] <= 0.0) {\n val = 1.0;\n } else {\n val = exp(0.0 - ((knnDistances[j] - membershipStrengthsInfo.rhos[workingIndex]) / membershipStrengthsInfo.sigmas[workingIndex])); \n }\n\n (*workingResKnnDistances)[j] = val;\n }\n }\n `;\n}\n//# sourceMappingURL=membership-strengths.wgsl.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { findABParams, getNEpochs, toOffsetForm } from './utils';\nexport function initializeSimplicialSetEmbedding(graph, entryLen, spread, minDist, negativeSampleRate = 5) {\n return __awaiter(this, void 0, void 0, function* () {\n if (!graph.unionSizes)\n return;\n const nEpochs = getNEpochs(entryLen);\n const nComponents = 2; // todo: support mult dims\n // get max value:\n const maxVal = graph.res.resultKnnDistances.reduce((prev, cur) => Math.max(prev, cur));\n //let offsetAccum = 0;\n // for (let i = 0; i < graph.unionSizes.length; i++) {\n // for (let j = 0; j < graph.unionSizes)\n // }\n const minGraphVal = maxVal / nEpochs;\n // this will hold the sizes of arrays with all zeros removed.\n const unionSizesCopy = new Uint32Array(graph.unionSizes.length);\n unionSizesCopy.set(graph.unionSizes);\n let offsetAccum = 0;\n for (let i = 0; i < graph.unionSizes.length; i++) {\n for (let j = 0; j < graph.unionSizes[i]; j++) {\n const index = offsetAccum + j;\n if (graph.res.resultKnnDistances[index] < minGraphVal) {\n graph.res.resultKnnDistances[index] = 0;\n unionSizesCopy[i]--;\n }\n }\n offsetAccum += graph.unionSizes[i];\n }\n const nonZeroGraphOffsets = toOffsetForm(unionSizesCopy);\n const nonZeroGraphSize = nonZeroGraphOffsets[nonZeroGraphOffsets.length - 1];\n const weights = new Float32Array(nonZeroGraphSize);\n const head = new Uint32Array(nonZeroGraphSize);\n const tail = new Uint32Array(nonZeroGraphSize);\n offsetAccum = 0;\n for (let i = 0; i < graph.unionSizes.length; i++) {\n for (let j = 0; j < graph.unionSizes[i]; j++) {\n const index = graph.unionMatrixOffsets[i] + j;\n if (graph.res.resultKnnDistances[index] != 0) {\n weights[offsetAccum] = graph.res.resultKnnDistances[index];\n head[offsetAccum] = graph.res.resultKnnIndexes[index];\n tail[offsetAccum] = i;\n offsetAccum += 1;\n }\n }\n }\n const epochsPerSample = new Float32Array(weights.length).fill(-1);\n const nSamples = weights.map((w) => (w / maxVal) * nEpochs);\n nSamples.forEach((n, i) => {\n if (n > 0)\n epochsPerSample[i] = nEpochs / nSamples[i];\n });\n const { a, b } = findABParams(spread, minDist);\n const epochsPerNegativeSample = epochsPerSample.map((e) => e / negativeSampleRate);\n const gamma = 1.0;\n const initialAlpha = 1.0;\n return { epochsPerSample, epochsPerNegativeSample, a, b,\n head, tail, entryLen, nEpochs, nComponents, initialAlpha, gamma };\n });\n}\n//# sourceMappingURL=simplical-set-embedding.js.map","import { Vector } from '@datagrok-libraries/utils/src/type-declarations';\nimport { AvailableMetrics, Measure, isBitArrayMetric } from '../typed-metrics';\nimport { DistanceMatrixService } from '../distance-matrix';\nimport { UMAP } from '../umap';\nimport { assert, transposeMatrix } from '@datagrok-libraries/utils/src/vector-operations';\nimport { SparseMatrixService } from '../distance-matrix/sparse-matrix-service';\nimport BitArray from '@datagrok-libraries/utils/src/bit-array';\nimport seedRandom from 'seedrandom';\n//import {TSNE} from '@keckelt/tsne';\nimport { TSNE } from '../t-sne/t-sne';\nimport { multiColWebGPUKNN } from '@datagrok-libraries/math';\nimport { WebGPUUMAP } from '@datagrok-libraries/math/src/webGPU/umap';\nclass MultiColumnReducer {\n constructor(options) {\n this.data = options.data;\n this.weights = options.weights;\n this.aggregationMethod = options.aggregationMethod;\n }\n}\nclass TSNEReducer extends MultiColumnReducer {\n /**\n * Creates an instance of TSNEReducer.\n * @param {Options} options Options to pass to the constructor.\n * @memberof TSNEReducer\n */\n constructor(options) {\n super(options);\n const randomSeed = options.randomSeed ?? Date();\n const randomFn = seedRandom(randomSeed);\n options.dim = 2; // TODO: make it configurable\n options.random = randomFn;\n this.reducer = new TSNE(options);\n this.iterations = options?.iterations ?? this.reducer.getIterSize(this.data[0].length);\n this.distanceFnames = options.distanceFnames;\n this.distanceFns = options.distanceFns;\n this.distanceFnArgs = options.distanceFnArgs;\n this.progressFunc = options.progressFunc;\n }\n /**\n * Embeds the data given into the two-dimensional space using t-SNE method.\\\n * @param {boolean} [parallelDistanceWorkers] Whether to use parallel distance workers.\n * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable.\n */\n async transform() {\n if (this.data[0].length > 10000)\n throw new Error('Maximum number of samples for T-SNE is 10000');\n const matrixService = new DistanceMatrixService(true, false);\n try {\n // const aggregate = getAggregationFunction(this.aggregationMethod, this.weights);\n // const distances: Array<Float32Array> = [];\n // for (let i = 0; i < this.data.length; ++i) {\n // const dist = await matrixService.calc(this.data[i], this.distanceFnames[i], false, this.distanceFnArgs[i]);\n // distances.push(dist);\n // }\n // const distance = new Float32Array(distances[0].length).fill(0);\n // for (let i = 0; i < distances[0].length; ++i)\n // distance[i] = aggregate(distances.map((d) => d[i]));\n const distance = await matrixService.calcMulti(this.data, this.distanceFnames, false, this.distanceFnArgs, this.weights, this.aggregationMethod);\n matrixService.terminate();\n // const matrixProxy = distanceMatrixProxy(distance, this.data[0].length);\n this.reducer.initDataDist(distance, this.data[0].length);\n for (let i = 0; i < this.iterations; ++i) {\n this.reducer.step(); // every time you call this, solution gets better\n if (this.progressFunc)\n this.progressFunc(i, this.iterations, []);\n }\n return this.reducer.getSolution();\n }\n catch (e) {\n matrixService.terminate();\n throw e;\n }\n }\n}\nclass UMAPReducer extends MultiColumnReducer {\n /**\n * Creates an instance of UMAPReducer.\n * @param {Options} options Options to pass to the constructor.\n * @memberof UMAPReducer\n */\n constructor(options) {\n const randomSeed = options.randomSeed ?? Date();\n const randomFn = seedRandom(randomSeed);\n super(options);\n this.useWebGPU = false;\n assert('distanceFnames' in options);\n assert('distanceFns' in options);\n this.distanceFnArgs = options.distanceFnArgs;\n this.distanceFns = options.distanceFns;\n this.progressFunc = options.progressFunc;\n this.useWebGPU = options.useWebGPU ?? false;\n this.distanceFnames = options.distanceFnames;\n options.nComponents = 2; // TODO: make it configurable\n //Umap uses vector indexing, so we need to create an array of vectors as indeces.\n this.vectors = new Array(this.data[0].length).fill(0).map((_, i) => i);\n if (this.data[0].length <= (options.nNeighbors ?? 15))\n options.nNeighbors = this.data[0].length - 1;\n options.random = randomFn;\n this.reducer = new UMAP(options);\n // this.reducer.distanceFn = this._encodedDistance.bind(this);\n }\n /**\n * Embeds the data given into the two-dimensional space using UMAP method.\n * @param {boolean} [_parallelDistanceWorkers] Whether to use parallel distance matrix workers.\n * @return {any} Cartesian coordinate of this embedding.\n */\n async transform(_parallelDistanceWorkers) {\n console.time('knn graph');\n let knnGraph = undefined;\n if (this.useWebGPU) {\n try {\n knnGraph = await multiColWebGPUKNN(this.data, this.reducer.neighbors, this.distanceFnames, this.aggregationMethod, this.weights, this.distanceFnArgs);\n }\n catch (e) {\n console.error(e);\n }\n }\n if (!knnGraph) {\n if (this.useWebGPU)\n console.error('WEBGPU KNN failed, falling back to multithreaded CPU implementation');\n knnGraph = await new SparseMatrixService()\n .multiColumnKNN(this.data, this.distanceFnames, this.reducer.neighbors, this.distanceFnArgs, this.weights, this.aggregationMethod);\n }\n console.timeEnd('knn graph');\n if (this.useWebGPU) {\n this.webGPUReducer = new WebGPUUMAP(this.vectors.length, {\n nComponents: this.reducer.nComponents,\n gamma: this.reducer.repulsionStrength,\n alpha: this.reducer.learningRate,\n nNeighbours: this.reducer.neighbors,\n spread: this.reducer.spread,\n minDist: this.reducer.minDist,\n negativeSampleRate: this.reducer.negativeSampleRate,\n localConnectivity: this.reducer.localConnectivity,\n setOpMixRatio: this.reducer.setOpMixRatio,\n });\n this.webGPUReducer.setPrecomputedKNN(knnGraph.knnIndexes, knnGraph.knnDistances);\n }\n else {\n this.reducer.setPrecomputedKNN(knnGraph.knnIndexes, knnGraph.knnDistances);\n }\n // needed so that garbage collector can free memory from distance matrix\n await new Promise((resolve) => {\n setTimeout(() => {\n resolve();\n }, 300);\n });\n let embedding = null;\n console.time('fit');\n try {\n if (this.useWebGPU && this.webGPUReducer) {\n embedding = await this.webGPUReducer.fit();\n if (!embedding)\n throw new Error('Failed to compute embedding');\n embedding = // transpose TODO: do a better job here\n new Array(embedding[0].length).fill(null).map((_, i) => new Float32Array(embedding.map((v) => v[i])));\n }\n }\n catch (e) {\n console.error(e);\n }\n if (!embedding) {\n if (this.useWebGPU)\n console.error('WEBGPU UMAP failed, falling back to CPU implementation');\n embedding = await this.reducer.fitAsync(this.vectors, (epoc) => {\n if (this.progressFunc)\n this.progressFunc(epoc, this.reducer.getNEpochs(), this.reducer.getEmbedding());\n });\n }\n console.timeEnd('fit');\n return arrayCast2Coordinates(embedding);\n function arrayCast2Coordinates(data) {\n return new Array(data.length).fill(0).map((_, i) => (Vector.from(data[i])));\n }\n }\n}\nconst AvailableReducers = {\n 'UMAP': UMAPReducer,\n 't-SNE': TSNEReducer,\n};\nexport class MultiColDimReducer {\n /**\n * Creates an instance of DimensionalityReducer.\n * @param {any[]} data Vectors to embed.\n * @param {KnownMethods} method Embedding method to be applied\n * @param {KnownMetrics} metric Distance metric to be computed between each of the vectors.\n * @param {Options} [options] Options to pass to the implementing embedders.\n * @memberof DimensionalityReducer\n */\n constructor(data, method, metrics, weights, distanceAggregation, options) {\n const measures = [];\n for (let idx = 0; idx < metrics.length; ++idx) {\n const measure = new Measure(metrics[idx]).getMeasure(options.distanceFnArgs[idx]);\n measures.push(measure);\n let bitArrayLength = 2048;\n for (let i = 0; i < data[idx].length; ++i) {\n if (data[idx][i] && data[idx][i]._length) {\n bitArrayLength = data[idx][i]._length;\n break;\n }\n }\n if (isBitArrayMetric(metrics[idx])) {\n for (let i = 0; i < data[idx].length; ++i) {\n if (data[idx][i] && data[idx][i]._data)\n data[idx][i] = new BitArray(data[idx][i]._data, data[idx][i]._length);\n else\n data[idx][i] = new BitArray(bitArrayLength);\n }\n }\n }\n if (method == 'UMAP') {\n this.reducer = new UMAPReducer({\n data: data,\n distanceFnames: metrics,\n distanceFns: measures,\n distanceFnArgs: options.distanceFnArgs,\n weights: weights,\n aggregationMethod: distanceAggregation,\n ...options\n });\n }\n else if (method == 't-SNE') {\n this.reducer = new TSNEReducer({\n data: data,\n distanceFnames: metrics,\n distanceFns: measures,\n distanceFnArgs: options.distanceFnArgs,\n weights: weights,\n aggregationMethod: distanceAggregation,\n ...options\n });\n }\n }\n /**\n * Embeds the data given into the two-dimensional space using the chosen method.\n *\n * @param {boolean} transpose Whether to transform coordinates to have columns-first orientation.\n * @param {boolean} parallelDistanceWorkers Whether to use parallel distance computation.\n * @throws {Error} If the embedding method was not found.\n * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable.\n * @memberof DimensionalityReducer\n */\n async transform(transpose = false) {\n if (this.reducer === undefined)\n throw new Error('Reducer was not defined.');\n let embedding = await this.reducer.transform();\n if (transpose)\n embedding = transposeMatrix(embedding);\n return embedding;\n }\n /**\n * Returns metrics available by type.\n *\n * @param {AvailableDataTypes} typeName type name\n * @return {string[]} Metric names which expects the given data type\n * @memberof DimensionalityReducer\n */\n static availableMetricsByType(typeName) {\n return Object.keys(AvailableMetrics[typeName]);\n }\n /**\n * Returns dimensionality reduction methods available.\n *\n * @readonly\n * @memberof DimensionalityReducer\n */\n static get availableMethods() {\n return Object.keys(AvailableReducers);\n }\n /**\n * Returns metrics available.\n *\n * @readonly\n * @memberof DimensionalityReducer\n */\n static get availableMetrics() {\n let ans = [];\n Object.values(AvailableMetrics).forEach((obj) => {\n const array = Object.values(obj);\n ans = [...ans, ...array];\n });\n return ans;\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-column-dim-reducer.js","sourceRoot":"","sources":["multi-column-dim-reducer.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+C,MAAM,EAAU,MAC/D,iDAAiD,CAAC;AACzD,OAAO,EAAqB,gBAAgB,EAAgB,OAAO,EAAE,gBAAgB,EAAC,MAAM,kBAAkB,CAAC;AAC/G,OAAO,EAAC,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAEzD,OAAO,EAAC,IAAI,EAAC,MAAM,SAAS,CAAC;AAC7B,OAAO,EAAC,MAAM,EAAE,eAAe,EAAC,MAAM,iDAAiD,CAAC;AACxF,OAAO,EAAY,mBAAmB,EAAC,MAAM,0CAA0C,CAAC;AAExF,OAAO,QAAQ,MAAM,yCAAyC,CAAC;AAC/D,OAAO,UAAU,MAAM,YAAY,CAAC;AACpC,qCAAqC;AACrC,OAAO,EAAC,IAAI,EAAC,MAAM,gBAAgB,CAAC;AACpC,OAAO,EAAC,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAC3D,OAAO,EAAC,UAAU,EAAC,MAAM,0CAA0C,CAAC;AAiCpE,MAAe,kBAAkB;IAI7B,YAAY,OAAgB;QAC1B,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;QACzB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;QAC/B,IAAI,CAAC,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;IACrD,CAAC;CAKJ;AAED,MAAM,WAAY,SAAQ,kBAAkB;IAOxC;;;;OAIG;IACH,YAAY,OAAgB;QAC1B,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,MAAM,UAAU,GAAW,OAAO,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;QACxD,MAAM,QAAQ,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;QACxC,OAAO,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,6BAA6B;QAC9C,OAAO,CAAC,MAAM,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,UAAU,GAAG,OAAO,EAAE,UAAU,IAAI,IAAI,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;QACvF,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC;QACvC,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;IAC3C,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,SAAS;QACpB,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,KAAK;YAC7B,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAC;QAClE,MAAM,aAAa,GAAG,IAAI,qBAAqB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC7D,IAAI,CAAC;YACH,kFAAkF;YAClF,6CAA6C;YAC7C,+CAA+C;YAC/C,gHAAgH;YAChH,0BAA0B;YAC1B,IAAI;YACJ,kEAAkE;YAClE,gDAAgD;YAChD,yDAAyD;YACzD,MAAM,QAAQ,GAAG,MAAM,aAAa,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,KAAK,EAAE,IAAI,CAAC,cAAc,EACvG,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;YACxC,aAAa,CAAC,SAAS,EAAE,CAAC;YAC1B,0EAA0E;YAC1E,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;YAEzD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,EAAE,CAAC;gBACzC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,iDAAiD;gBACtE,IAAI,IAAI,CAAC,YAAY;oBACnB,IAAI,CAAC,YAAY,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;YAC9C,CAAC;YACD,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW,EAAE,CAAC;QACpC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,aAAa,CAAC,SAAS,EAAE,CAAC;YAC1B,MAAM,CAAC,CAAC;QACV,CAAC;IACH,CAAC;CACJ;AAED,MAAM,WAAY,SAAQ,kBAAkB;IASxC;;;;OAIG;IACH,YAAY,OAAgB;QAC1B,MAAM,UAAU,GAAW,OAAO,CAAC,UAAU,IAAI,IAAI,EAAE,CAAC;QACxD,MAAM,QAAQ,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;QACxC,KAAK,CAAC,OAAO,CAAC,CAAC;QAVP,cAAS,GAAY,KAAK,CAAC;QAWnC,MAAM,CAAC,gBAAgB,IAAI,OAAO,CAAC,CAAC;QACpC,MAAM,CAAC,aAAa,IAAI,OAAO,CAAC,CAAC;QACjC,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAc,CAAC;QAC7C,IAAI,CAAC,WAAW,GAAG,OAAO,CAAC,WAAY,CAAC;QACxC,IAAI,CAAC,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC;QACzC,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,IAAI,KAAK,CAAC;QAC5C,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC,cAAe,CAAC;QAC9C,OAAO,CAAC,WAAW,GAAG,CAAC,CAAC,CAAC,6BAA6B;QACtD,iFAAiF;QACjF,IAAI,CAAC,OAAO,GAAG,IAAI,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC;QAEvE,IAAI,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,UAAU,IAAI,EAAE,CAAC;YACnD,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;QAC/C,OAAO,CAAC,MAAM,GAAG,QAAQ,CAAC;QAC1B,IAAI,CAAC,OAAO,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,CAAC;QACjC,8DAA8D;IAChE,CAAC;IAED;;;;OAIG;IACI,KAAK,CAAC,SAAS,CAAC,wBAAkC;QACvD,OAAO,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QAC1B,IAAI,QAAQ,GAA0B,SAAS,CAAC;QAChD,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,CAAC;gBACH,QAAQ,GAAG,MAAM,iBAAiB,CAChC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,cAAqB,EAAE,IAAI,CAAC,iBAAwB,EAC5F,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,cAAc,CACV,CAAC;YAC5B,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;YACnB,CAAC;QACH,CAAC;QACD,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,IAAI,IAAI,CAAC,SAAS;gBAChB,OAAO,CAAC,KAAK,CAAC,qEAAqE,CAAC,CAAC;YACvF,QAAQ,GAAG,MAAM,IAAI,mBAAmB,EAAE;iBACvC,cAAc,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS,EACpE,IAAI,CAAC,cAAc,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,CAAC,CAAC;QACjE,CAAC;QACD,OAAO,CAAC,OAAO,CAAC,WAAW,CAAC,CAAC;QAC7B,IAAI,IAAI,CAAC,SAAS,EAAE,CAAC;YACnB,IAAI,CAAC,aAAa,GAAG,IAAI,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;gBACvD,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,WAAW;gBACrC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,iBAAiB;gBACrC,KAAK,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY;gBAChC,WAAW,EAAE,IAAI,CAAC,OAAO,CAAC,SAAS;gBACnC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,MAAM;gBAC3B,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO;gBAC7B,kBAAkB,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB;gBACnD,iBAAiB,EAAE,IAAI,CAAC,OAAO,CAAC,iBAAiB;gBACjD,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,aAAa;aAC1C,CAAC,CAAC;YACH,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;QACnF,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,YAAY,CAAC,CAAC;QAC7E,CAAC;QAED,wEAAwE;QACxE,MAAM,IAAI,OAAO,CAAO,CAAC,OAAO,EAAE,EAAE;YAClC,UAAU,CAAC,GAAG,EAAE;gBACd,OAAO,EAAE,CAAC;YACZ,CAAC,EAAE,GAAG,CAAC,CAAC;QACV,CAAC,CAAC,CAAC;QAEH,IAAI,SAAS,GAAkD,IAAI,CAAC;QACpE,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACpB,IAAI,CAAC;YACH,IAAI,IAAI,CAAC,SAAS,IAAI,IAAI,CAAC,aAAa,EAAE,CAAC;gBACzC,SAAS,GAAG,MAAM,IAAI,CAAC,aAAa,CAAC,GAAG,EAAE,CAAC;gBAC3C,IAAI,CAAC,SAAS;oBACZ,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;gBACjD,SAAS,GAAG,uCAAuC;oBACjD,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,YAAY,CAAC,SAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAC3G,CAAC;QACH,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QACnB,CAAC;QACD,IAAI,CAAC,SAAS,EAAE,CAAC;YACf,IAAI,IAAI,CAAC,SAAS;gBAChB,OAAO,CAAC,KAAK,CAAC,wDAAwD,CAAC,CAAC;YAC1E,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,EAAE;gBAC7D,IAAI,IAAI,CAAC,YAAY;oBACnB,IAAI,CAAC,YAAY,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,EAAE,IAAI,CAAC,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC;YACpF,CAAC,CAAC,CAAC;QACL,CAAC;QACD,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;QACvB,OAAO,qBAAqB,CAAC,SAAS,CAAC,CAAC;QACxC,SAAS,qBAAqB,CAAC,IAAiC;YAC9D,OAAO,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9E,CAAC;IACH,CAAC;CACJ;AAED,MAAM,iBAAiB,GAAG;IACxB,MAAM,EAAE,WAAW;IACnB,OAAO,EAAE,WAAW;CACrB,CAAC;AAIF,MAAM,OAAO,kBAAkB;IAE3B;;;;;;;KAOC;IACD,YAAY,IAAkB,EAAE,MAA2B,EAAE,OAAuB,EAClF,OAAiB,EAAE,mBAA8C,EAAE,OAAgB;QACnF,MAAM,QAAQ,GAAqB,EAAE,CAAC;QACtC,KAAK,IAAI,GAAG,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,GAAG,EAAE,CAAC;YAC9C,MAAM,OAAO,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,CAAC,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC;YAClF,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACvB,IAAI,cAAc,GAAG,IAAI,CAAC;YAC1B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;gBAC1C,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,EAAE,CAAC;oBACzC,cAAc,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;oBACtC,MAAM;gBACR,CAAC;YACH,CAAC;YACD,IAAI,gBAAgB,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,EAAE,CAAC;oBAC1C,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK;wBACpC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,QAAQ,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;;wBAEtE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,QAAQ,CAAC,cAAc,CAAC,CAAC;gBAChD,CAAC;YACH,CAAC;QACH,CAAC;QAED,IAAI,MAAM,IAAI,MAAM,EAAE,CAAC;YACrB,IAAI,CAAC,OAAO,GAAG,IAAI,WAAW,CAAC;gBAC7B,IAAI,EAAE,IAAI;gBACV,cAAc,EAAE,OAAO;gBACvB,WAAW,EAAE,QAAQ;gBACrB,cAAc,EAAE,OAAO,CAAC,cAAc;gBACtC,OAAO,EAAE,OAAO;gBAChB,iBAAiB,EAAE,mBAAmB;gBACtC,GAAG,OAAO;aACX,CAAC,CAAC;QACL,CAAC;aAAM,IAAI,MAAM,IAAI,OAAO,EAAE,CAAC;YAC7B,IAAI,CAAC,OAAO,GAAG,IAAI,WAAW,CAAC;gBAC7B,IAAI,EAAE,IAAI;gBACV,cAAc,EAAE,OAAO;gBACvB,WAAW,EAAE,QAAQ;gBACrB,cAAc,EAAE,OAAO,CAAC,cAAc;gBACtC,OAAO,EAAE,OAAO;gBAChB,iBAAiB,EAAE,mBAAmB;gBACtC,GAAG,OAAO;aACX,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;;;;;;;KAQC;IACM,KAAK,CAAC,SAAS,CAAC,YAAqB,KAAK;QAC/C,IAAI,IAAI,CAAC,OAAO,KAAK,SAAS;YAC5B,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAE9C,IAAI,SAAS,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;QAE/C,IAAI,SAAS;YACX,SAAS,GAAG,eAAe,CAAC,SAAS,CAAC,CAAC;QAEzC,OAAO,SAAS,CAAC;IACnB,CAAC;IAED;;;;;;KAMC;IACD,MAAM,CAAC,sBAAsB,CAAC,QAA4B;QACxD,OAAO,MAAM,CAAC,IAAI,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC;IACjD,CAAC;IAED;;;;;KAKC;IACD,MAAM,KAAK,gBAAgB;QACzB,OAAO,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC,CAAC;IACxC,CAAC;IAED;;;;;KAKC;IACD,MAAM,KAAK,gBAAgB;QACzB,IAAI,GAAG,GAAa,EAAE,CAAC;QACvB,MAAM,CAAC,MAAM,CAAC,gBAAgB,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YAC9C,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACjC,GAAG,GAAG,CAAC,GAAG,GAAG,EAAE,GAAG,KAAK,CAAC,CAAC;QAC3B,CAAC,CAAC,CAAC;QACH,OAAO,GAAG,CAAC;IACb,CAAC;CACJ","sourcesContent":["import {Coordinates, DistanceMetric, Matrix, Options, Vector, Vectors}\n  from '@datagrok-libraries/utils/src/type-declarations';\nimport {AvailableDataTypes, AvailableMetrics, KnownMetrics, Measure, isBitArrayMetric} from '../typed-metrics';\nimport {DistanceMatrixService} from '../distance-matrix';\nimport {DistanceAggregationMethod} from '../distance-matrix/types';\nimport {UMAP} from '../umap';\nimport {assert, transposeMatrix} from '@datagrok-libraries/utils/src/vector-operations';\nimport {KnnResult, SparseMatrixService} from '../distance-matrix/sparse-matrix-service';\nimport {DimReductionMethods} from './types';\nimport BitArray from '@datagrok-libraries/utils/src/bit-array';\nimport seedRandom from 'seedrandom';\n//import {TSNE} from '@keckelt/tsne';\nimport {TSNE} from '../t-sne/t-sne';\nimport {multiColWebGPUKNN} from '@datagrok-libraries/math';\nimport {WebGPUUMAP} from '@datagrok-libraries/math/src/webGPU/umap';\n\nexport interface IUMAPOptions {\n    learningRate?: number;\n    nComponents?: number;\n    nEpochs?: number;\n    nNeighbors?: number;\n    spread?: number;\n    minDist?: number;\n    progressFunc?: (epoc: number, epochsLength: number, embeddings: number[][]) => void;\n    randomSeed?: string;\n    useWebGPU?: boolean;\n}\n\nexport interface ITSNEOptions {\n    epsilon?: number;\n    perplexity?: number;\n    dim?: number;\n}\n\nexport interface IDimReductionParam<T extends number | string | boolean = number> {\n    uiName: string;\n    value: (T extends number ? number : T extends string ? string : boolean) | null;\n    tooltip: string;\n    type?: T extends number ? 'number' : T extends string ? 'string' : 'boolean';\n    placeholder?: string;\n    min?: number;\n    max?: number;\n    step?: number;\n    disable?: boolean;\n    disableTooltip?: string;\n}\n\nabstract class MultiColumnReducer {\n    protected data: Vectors[];\n    protected weights: number[];\n    protected aggregationMethod: DistanceAggregationMethod;\n    constructor(options: Options) {\n      this.data = options.data;\n      this.weights = options.weights;\n      this.aggregationMethod = options.aggregationMethod;\n    }\n\n    /** Embeds the data given into the two-dimensional space.\n     * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable. */\n    abstract transform(): Promise<Matrix>;\n}\n\nclass TSNEReducer extends MultiColumnReducer {\n    protected reducer: TSNE;\n    protected iterations: number;\n    protected distanceFnames: KnownMetrics[];\n    protected distanceFns: ((a: any, b: any) => number)[];\n    protected distanceFnArgs: {[_: string]: any}[];\n    protected progressFunc?: (epoc: number, epochsLength: number, embeddings?: number[][]) => void;\n    /**\n     * Creates an instance of TSNEReducer.\n     * @param {Options} options Options to pass to the constructor.\n     * @memberof TSNEReducer\n     */\n    constructor(options: Options) {\n      super(options);\n      const randomSeed: string = options.randomSeed ?? Date();\n      const randomFn = seedRandom(randomSeed);\n      options.dim = 2; // TODO: make it configurable\n      options.random = randomFn;\n      this.reducer = new TSNE(options);\n      this.iterations = options?.iterations ?? this.reducer.getIterSize(this.data[0].length);\n      this.distanceFnames = options.distanceFnames;\n      this.distanceFns = options.distanceFns;\n      this.distanceFnArgs = options.distanceFnArgs;\n      this.progressFunc = options.progressFunc;\n    }\n\n    /**\n     * Embeds the data given into the two-dimensional space using t-SNE method.\\\n     * @param {boolean} [parallelDistanceWorkers] Whether to use parallel distance workers.\n     * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable.\n     */\n    public async transform(): Promise<Matrix> {\n      if (this.data[0].length > 10000)\n        throw new Error('Maximum number of samples for T-SNE is 10000');\n      const matrixService = new DistanceMatrixService(true, false);\n      try {\n        // const aggregate = getAggregationFunction(this.aggregationMethod, this.weights);\n        // const distances: Array<Float32Array> = [];\n        // for (let i = 0; i < this.data.length; ++i) {\n        //   const dist = await matrixService.calc(this.data[i], this.distanceFnames[i], false, this.distanceFnArgs[i]);\n        //   distances.push(dist);\n        // }\n        // const distance = new Float32Array(distances[0].length).fill(0);\n        // for (let i = 0; i < distances[0].length; ++i)\n        //   distance[i] = aggregate(distances.map((d) => d[i]));\n        const distance = await matrixService.calcMulti(this.data, this.distanceFnames, false, this.distanceFnArgs,\n          this.weights, this.aggregationMethod);\n        matrixService.terminate();\n        // const matrixProxy = distanceMatrixProxy(distance, this.data[0].length);\n        this.reducer.initDataDist(distance, this.data[0].length);\n\n        for (let i = 0; i < this.iterations; ++i) {\n          this.reducer.step(); // every time you call this, solution gets better\n          if (this.progressFunc)\n            this.progressFunc(i, this.iterations, []);\n        }\n        return this.reducer.getSolution();\n      } catch (e) {\n        matrixService.terminate();\n        throw e;\n      }\n    }\n}\n\nclass UMAPReducer extends MultiColumnReducer {\n    protected reducer: UMAP;\n    protected distanceFnames: KnownMetrics[];\n    protected distanceFns: Function[];\n    protected vectors: number[];\n    protected progressFunc?: (epoc: number, epochsLength: number, embedding: number[][]) => void;\n    protected distanceFnArgs: {[_: string]: any}[];\n    protected useWebGPU: boolean = false;\n    protected webGPUReducer: WebGPUUMAP | undefined;\n    /**\n     * Creates an instance of UMAPReducer.\n     * @param {Options} options Options to pass to the constructor.\n     * @memberof UMAPReducer\n     */\n    constructor(options: Options) {\n      const randomSeed: string = options.randomSeed ?? Date();\n      const randomFn = seedRandom(randomSeed);\n      super(options);\n      assert('distanceFnames' in options);\n      assert('distanceFns' in options);\n      this.distanceFnArgs = options.distanceFnArgs;\n      this.distanceFns = options.distanceFns!;\n      this.progressFunc = options.progressFunc;\n      this.useWebGPU = options.useWebGPU ?? false;\n      this.distanceFnames = options.distanceFnames!;\n      options.nComponents = 2; // TODO: make it configurable\n      //Umap uses vector indexing, so we need to create an array of vectors as indeces.\n      this.vectors = new Array(this.data[0].length).fill(0).map((_, i) => i);\n\n      if (this.data[0].length <= (options.nNeighbors ?? 15))\n        options.nNeighbors = this.data[0].length - 1;\n      options.random = randomFn;\n      this.reducer = new UMAP(options);\n      // this.reducer.distanceFn = this._encodedDistance.bind(this);\n    }\n\n    /**\n     * Embeds the data given into the two-dimensional space using UMAP method.\n     * @param {boolean} [_parallelDistanceWorkers] Whether to use parallel distance matrix workers.\n     * @return {any} Cartesian coordinate of this embedding.\n     */\n    public async transform(_parallelDistanceWorkers?: boolean): Promise<Matrix> {\n      console.time('knn graph');\n      let knnGraph: KnnResult | undefined = undefined;\n      if (this.useWebGPU) {\n        try {\n          knnGraph = await multiColWebGPUKNN(\n            this.data, this.reducer.neighbors, this.distanceFnames as any, this.aggregationMethod as any,\n            this.weights, this.distanceFnArgs\n          ) as unknown as KnnResult;\n        } catch (e) {\n          console.error(e);\n        }\n      }\n      if (!knnGraph) {\n        if (this.useWebGPU)\n          console.error('WEBGPU KNN failed, falling back to multithreaded CPU implementation');\n        knnGraph = await new SparseMatrixService()\n          .multiColumnKNN(this.data, this.distanceFnames, this.reducer.neighbors,\n            this.distanceFnArgs, this.weights, this.aggregationMethod);\n      }\n      console.timeEnd('knn graph');\n      if (this.useWebGPU) {\n        this.webGPUReducer = new WebGPUUMAP(this.vectors.length, {\n          nComponents: this.reducer.nComponents,\n          gamma: this.reducer.repulsionStrength,\n          alpha: this.reducer.learningRate,\n          nNeighbours: this.reducer.neighbors,\n          spread: this.reducer.spread,\n          minDist: this.reducer.minDist,\n          negativeSampleRate: this.reducer.negativeSampleRate,\n          localConnectivity: this.reducer.localConnectivity,\n          setOpMixRatio: this.reducer.setOpMixRatio,\n        });\n        this.webGPUReducer.setPrecomputedKNN(knnGraph.knnIndexes, knnGraph.knnDistances);\n      } else {\n        this.reducer.setPrecomputedKNN(knnGraph.knnIndexes, knnGraph.knnDistances);\n      }\n\n      // needed so that garbage collector can free memory from distance matrix\n      await new Promise<void>((resolve) => {\n        setTimeout(() => {\n          resolve();\n        }, 300);\n      });\n\n      let embedding: number[][] | Float32Array[] | undefined |null = null;\n      console.time('fit');\n      try {\n        if (this.useWebGPU && this.webGPUReducer) {\n          embedding = await this.webGPUReducer.fit();\n          if (!embedding)\n            throw new Error('Failed to compute embedding');\n          embedding = // transpose TODO: do a better job here\n            new Array(embedding[0].length).fill(null).map((_, i) => new Float32Array(embedding!.map((v) => v[i])));\n        }\n      } catch (e) {\n        console.error(e);\n      }\n      if (!embedding) {\n        if (this.useWebGPU)\n          console.error('WEBGPU UMAP failed, falling back to CPU implementation');\n        embedding = await this.reducer.fitAsync(this.vectors, (epoc) => {\n          if (this.progressFunc)\n            this.progressFunc(epoc, this.reducer.getNEpochs(), this.reducer.getEmbedding());\n        });\n      }\n      console.timeEnd('fit');\n      return arrayCast2Coordinates(embedding);\n      function arrayCast2Coordinates(data: number[][] | Float32Array[]): Coordinates {\n        return new Array(data.length).fill(0).map((_, i) => (Vector.from(data[i])));\n      }\n    }\n}\n\nconst AvailableReducers = {\n  'UMAP': UMAPReducer,\n  't-SNE': TSNEReducer,\n};\n\nexport type KnownMethods = keyof typeof AvailableReducers;\n\nexport class MultiColDimReducer {\n    private reducer: MultiColumnReducer | undefined;\n    /**\n   * Creates an instance of DimensionalityReducer.\n   * @param {any[]} data Vectors to embed.\n   * @param {KnownMethods} method Embedding method to be applied\n   * @param {KnownMetrics} metric Distance metric to be computed between each of the vectors.\n   * @param {Options} [options] Options to pass to the implementing embedders.\n   * @memberof DimensionalityReducer\n   */\n    constructor(data: Array<any[]>, method: DimReductionMethods, metrics: KnownMetrics[],\n      weights: number[], distanceAggregation: DistanceAggregationMethod, options: Options) {\n      const measures: DistanceMetric[] = [];\n      for (let idx = 0; idx < metrics.length; ++idx) {\n        const measure = new Measure(metrics[idx]).getMeasure(options.distanceFnArgs[idx]);\n        measures.push(measure);\n        let bitArrayLength = 2048;\n        for (let i = 0; i < data[idx].length; ++i) {\n          if (data[idx][i] && data[idx][i]._length) {\n            bitArrayLength = data[idx][i]._length;\n            break;\n          }\n        }\n        if (isBitArrayMetric(metrics[idx])) {\n          for (let i = 0; i < data[idx].length; ++i) {\n            if (data[idx][i] && data[idx][i]._data)\n              data[idx][i] = new BitArray(data[idx][i]._data, data[idx][i]._length);\n            else\n              data[idx][i] = new BitArray(bitArrayLength);\n          }\n        }\n      }\n\n      if (method == 'UMAP') {\n        this.reducer = new UMAPReducer({\n          data: data,\n          distanceFnames: metrics,\n          distanceFns: measures,\n          distanceFnArgs: options.distanceFnArgs,\n          weights: weights,\n          aggregationMethod: distanceAggregation,\n          ...options\n        });\n      } else if (method == 't-SNE') {\n        this.reducer = new TSNEReducer({\n          data: data,\n          distanceFnames: metrics,\n          distanceFns: measures,\n          distanceFnArgs: options.distanceFnArgs,\n          weights: weights,\n          aggregationMethod: distanceAggregation,\n          ...options\n        });\n      }\n    }\n\n    /**\n   * Embeds the data given into the two-dimensional space using the chosen method.\n   *\n   * @param {boolean} transpose Whether to transform coordinates to have columns-first orientation.\n   * @param {boolean} parallelDistanceWorkers Whether to use parallel distance computation.\n   * @throws {Error} If the embedding method was not found.\n   * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable.\n   * @memberof DimensionalityReducer\n   */\n    public async transform(transpose: boolean = false): Promise<Matrix> {\n      if (this.reducer === undefined)\n        throw new Error('Reducer was not defined.');\n\n      let embedding = await this.reducer.transform();\n\n      if (transpose)\n        embedding = transposeMatrix(embedding);\n\n      return embedding;\n    }\n\n    /**\n   * Returns metrics available by type.\n   *\n   * @param {AvailableDataTypes} typeName type name\n   * @return {string[]} Metric names which expects the given data type\n   * @memberof DimensionalityReducer\n   */\n    static availableMetricsByType(typeName: AvailableDataTypes) {\n      return Object.keys(AvailableMetrics[typeName]);\n    }\n\n    /**\n   * Returns dimensionality reduction methods available.\n   *\n   * @readonly\n   * @memberof DimensionalityReducer\n   */\n    static get availableMethods() {\n      return Object.keys(AvailableReducers);\n    }\n\n    /**\n   * Returns metrics available.\n   *\n   * @readonly\n   * @memberof DimensionalityReducer\n   */\n    static get availableMetrics() {\n      let ans: string[] = [];\n      Object.values(AvailableMetrics).forEach((obj) => {\n        const array = Object.values(obj);\n        ans = [...ans, ...array];\n      });\n      return ans;\n    }\n}\n"]}","import { MultiColDimReducer } from './multi-column-dim-reducer';\n/**\n * Worker thread receiving data function.\n *\n * @param {any[]} columnData Samples to process.\n * @param {KnownMethods} method Embedding method.\n * @param {KnownMetrics} measure Distance metric.\n * @param {any} options Options to pass to algorithm.\n * @param {boolean} parallelDistanceWorkers Whether to use parallel distance workers.\n * @return {any} Embedding (and distance matrix where applicable).\n */\nasync function onMessage(columnsData, method, metrics, weights, aggregationMethod, options) {\n const reducer = new MultiColDimReducer(columnsData, method, metrics, weights, aggregationMethod, { ...options, progressFunc });\n return await reducer.transform(true);\n}\nasync function progressFunc(epochNum, epochsLength, embedding) {\n if (epochNum % 5 === 0)\n self.postMessage({ epochNum, epochsLength, embedding });\n}\nself.onmessage = async ({ data: { columnsData, method, distanceMetrics, options, weights, aggregationMethod } }) => {\n let data;\n try {\n const embedding = await onMessage(columnsData, method, distanceMetrics, weights, aggregationMethod, options);\n data = { embedding };\n }\n catch (e) {\n data = { error: e };\n }\n self.postMessage({\n error: data.error,\n embedding: data.embedding,\n });\n};\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXVsaXQtY29sdW1uLWRpbS1yZWR1Y2VyLXdvcmtlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIm11bGl0LWNvbHVtbi1kaW0tcmVkdWNlci13b3JrZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBSUEsT0FBTyxFQUFDLGtCQUFrQixFQUFDLE1BQU0sNEJBQTRCLENBQUM7QUFFOUQ7Ozs7Ozs7OztHQVNHO0FBQ0gsS0FBSyxVQUFVLFNBQVMsQ0FBQyxXQUF5QixFQUFFLE1BQTJCLEVBQUUsT0FBdUIsRUFDdEcsT0FBaUIsRUFBRSxpQkFBNEMsRUFDL0QsT0FBWTtJQUNaLE1BQU0sT0FBTyxHQUFHLElBQUksa0JBQWtCLENBQ3BDLFdBQVcsRUFDWCxNQUFNLEVBQ04sT0FBTyxFQUNQLE9BQU8sRUFDUCxpQkFBaUIsRUFDakIsRUFBQyxHQUFHLE9BQU8sRUFBRSxZQUFZLEVBQUMsQ0FDM0IsQ0FBQztJQUNGLE9BQU8sTUFBTSxPQUFPLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxDQUFDO0FBQ3ZDLENBQUM7QUFFRCxLQUFLLFVBQVUsWUFBWSxDQUFDLFFBQWdCLEVBQUUsWUFBb0IsRUFBRSxTQUFxQjtJQUN2RixJQUFJLFFBQVEsR0FBRyxDQUFDLEtBQUssQ0FBQztRQUNwQixJQUFJLENBQUMsV0FBVyxDQUFDLEVBQUMsUUFBUSxFQUFFLFlBQVksRUFBRSxTQUFTLEVBQUMsQ0FBQyxDQUFDO0FBQzFELENBQUM7QUFFRCxJQUFJLENBQUMsU0FBUyxHQUFHLEtBQUssRUFBRSxFQUFDLElBQUksRUFBRSxFQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsZUFBZSxFQUFFLE9BQU8sRUFBRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUMsRUFBQyxFQUFFLEVBQUU7SUFDN0csSUFBSSxJQUFvQyxDQUFDO0lBQ3pDLElBQUksQ0FBQztRQUNILE1BQU0sU0FBUyxHQUFHLE1BQU0sU0FBUyxDQUFDLFdBQVcsRUFBRSxNQUFNLEVBQUUsZUFBZSxFQUFFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxPQUFPLENBQUMsQ0FBQztRQUM3RyxJQUFJLEdBQUcsRUFBQyxTQUFTLEVBQUMsQ0FBQztJQUNyQixDQUFDO0lBQUMsT0FBTyxDQUFNLEVBQUUsQ0FBQztRQUNoQixJQUFJLEdBQUcsRUFBQyxLQUFLLEVBQUUsQ0FBQyxFQUFDLENBQUM7SUFDcEIsQ0FBQztJQUNELElBQUksQ0FBQyxXQUFXLENBQUM7UUFDZixLQUFLLEVBQUUsSUFBSSxDQUFDLEtBQUs7UUFDakIsU0FBUyxFQUFFLElBQUksQ0FBQyxTQUFTO0tBQzFCLENBQUMsQ0FBQztBQUNMLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7TWF0cml4fSBmcm9tICdAZGF0YWdyb2stbGlicmFyaWVzL3V0aWxzL3NyYy90eXBlLWRlY2xhcmF0aW9ucyc7XG5pbXBvcnQge0tub3duTWV0cmljc30gZnJvbSAnLi4vdHlwZWQtbWV0cmljcy90eXBlZC1tZXRyaWNzJztcbmltcG9ydCB7RGltUmVkdWN0aW9uTWV0aG9kc30gZnJvbSAnLi90eXBlcyc7XG5pbXBvcnQge0Rpc3RhbmNlQWdncmVnYXRpb25NZXRob2R9IGZyb20gJy4uL2Rpc3RhbmNlLW1hdHJpeC90eXBlcyc7XG5pbXBvcnQge011bHRpQ29sRGltUmVkdWNlcn0gZnJvbSAnLi9tdWx0aS1jb2x1bW4tZGltLXJlZHVjZXInO1xuXG4vKipcbiAqIFdvcmtlciB0aHJlYWQgcmVjZWl2aW5nIGRhdGEgZnVuY3Rpb24uXG4gKlxuICogQHBhcmFtIHthbnlbXX0gY29sdW1uRGF0YSBTYW1wbGVzIHRvIHByb2Nlc3MuXG4gKiBAcGFyYW0ge0tub3duTWV0aG9kc30gbWV0aG9kIEVtYmVkZGluZyBtZXRob2QuXG4gKiBAcGFyYW0ge0tub3duTWV0cmljc30gbWVhc3VyZSBEaXN0YW5jZSBtZXRyaWMuXG4gKiBAcGFyYW0ge2FueX0gb3B0aW9ucyBPcHRpb25zIHRvIHBhc3MgdG8gYWxnb3JpdGhtLlxuICogQHBhcmFtIHtib29sZWFufSBwYXJhbGxlbERpc3RhbmNlV29ya2VycyBXaGV0aGVyIHRvIHVzZSBwYXJhbGxlbCBkaXN0YW5jZSB3b3JrZXJzLlxuICogQHJldHVybiB7YW55fSBFbWJlZGRpbmcgKGFuZCBkaXN0YW5jZSBtYXRyaXggd2hlcmUgYXBwbGljYWJsZSkuXG4gKi9cbmFzeW5jIGZ1bmN0aW9uIG9uTWVzc2FnZShjb2x1bW5zRGF0YTogQXJyYXk8YW55W10+LCBtZXRob2Q6IERpbVJlZHVjdGlvbk1ldGhvZHMsIG1ldHJpY3M6IEtub3duTWV0cmljc1tdLFxuICB3ZWlnaHRzOiBudW1iZXJbXSwgYWdncmVnYXRpb25NZXRob2Q6IERpc3RhbmNlQWdncmVnYXRpb25NZXRob2QsXG4gIG9wdGlvbnM6IGFueSk6IFByb21pc2U8TWF0cml4PiB7XG4gIGNvbnN0IHJlZHVjZXIgPSBuZXcgTXVsdGlDb2xEaW1SZWR1Y2VyKFxuICAgIGNvbHVtbnNEYXRhLFxuICAgIG1ldGhvZCxcbiAgICBtZXRyaWNzLFxuICAgIHdlaWdodHMsXG4gICAgYWdncmVnYXRpb25NZXRob2QsXG4gICAgey4uLm9wdGlvbnMsIHByb2dyZXNzRnVuY31cbiAgKTtcbiAgcmV0dXJuIGF3YWl0IHJlZHVjZXIudHJhbnNmb3JtKHRydWUpO1xufVxuXG5hc3luYyBmdW5jdGlvbiBwcm9ncmVzc0Z1bmMoZXBvY2hOdW06IG51bWJlciwgZXBvY2hzTGVuZ3RoOiBudW1iZXIsIGVtYmVkZGluZzogbnVtYmVyW11bXSkge1xuICBpZiAoZXBvY2hOdW0gJSA1ID09PSAwKVxuICAgIHNlbGYucG9zdE1lc3NhZ2Uoe2Vwb2NoTnVtLCBlcG9jaHNMZW5ndGgsIGVtYmVkZGluZ30pO1xufVxuXG5zZWxmLm9ubWVzc2FnZSA9IGFzeW5jICh7ZGF0YToge2NvbHVtbnNEYXRhLCBtZXRob2QsIGRpc3RhbmNlTWV0cmljcywgb3B0aW9ucywgd2VpZ2h0cywgYWdncmVnYXRpb25NZXRob2R9fSkgPT4ge1xuICBsZXQgZGF0YToge2Vycm9yPzogYW55LCBlbWJlZGRpbmc/OiBhbnl9O1xuICB0cnkge1xuICAgIGNvbnN0IGVtYmVkZGluZyA9IGF3YWl0IG9uTWVzc2FnZShjb2x1bW5zRGF0YSwgbWV0aG9kLCBkaXN0YW5jZU1ldHJpY3MsIHdlaWdodHMsIGFnZ3JlZ2F0aW9uTWV0aG9kLCBvcHRpb25zKTtcbiAgICBkYXRhID0ge2VtYmVkZGluZ307XG4gIH0gY2F0Y2ggKGU6IGFueSkge1xuICAgIGRhdGEgPSB7ZXJyb3I6IGV9O1xuICB9XG4gIHNlbGYucG9zdE1lc3NhZ2Uoe1xuICAgIGVycm9yOiBkYXRhLmVycm9yLFxuICAgIGVtYmVkZGluZzogZGF0YS5lbWJlZGRpbmcsXG4gIH0pO1xufTtcbiJdfQ==","// A library of seedable RNGs implemented in Javascript.\n//\n// Usage:\n//\n// var seedrandom = require('seedrandom');\n// var random = seedrandom(1); // or any seed.\n// var x = random(); // 0 <= x < 1. Every bit is random.\n// var x = random.quick(); // 0 <= x < 1. 32 bits of randomness.\n\n// alea, a 53-bit multiply-with-carry generator by Johannes Baagøe.\n// Period: ~2^116\n// Reported to pass all BigCrush tests.\nvar alea = require('./lib/alea');\n\n// xor128, a pure xor-shift generator by George Marsaglia.\n// Period: 2^128-1.\n// Reported to fail: MatrixRank and LinearComp.\nvar xor128 = require('./lib/xor128');\n\n// xorwow, George Marsaglia's 160-bit xor-shift combined plus weyl.\n// Period: 2^192-2^32\n// Reported to fail: CollisionOver, SimpPoker, and LinearComp.\nvar xorwow = require('./lib/xorwow');\n\n// xorshift7, by François Panneton and Pierre L'ecuyer, takes\n// a different approach: it adds robustness by allowing more shifts\n// than Marsaglia's original three. It is a 7-shift generator\n// with 256 bits, that passes BigCrush with no systmatic failures.\n// Period 2^256-1.\n// No systematic BigCrush failures reported.\nvar xorshift7 = require('./lib/xorshift7');\n\n// xor4096, by Richard Brent, is a 4096-bit xor-shift with a\n// very long period that also adds a Weyl generator. It also passes\n// BigCrush with no systematic failures. Its long period may\n// be useful if you have many generators and need to avoid\n// collisions.\n// Period: 2^4128-2^32.\n// No systematic BigCrush failures reported.\nvar xor4096 = require('./lib/xor4096');\n\n// Tyche-i, by Samuel Neves and Filipe Araujo, is a bit-shifting random\n// number generator derived from ChaCha, a modern stream cipher.\n// https://eden.dei.uc.pt/~sneves/pubs/2011-snfa2.pdf\n// Period: ~2^127\n// No systematic BigCrush failures reported.\nvar tychei = require('./lib/tychei');\n\n// The original ARC4-based prng included in this library.\n// Period: ~2^1600\nvar sr = require('./seedrandom');\n\nsr.alea = alea;\nsr.xor128 = xor128;\nsr.xorwow = xorwow;\nsr.xorshift7 = xorshift7;\nsr.xor4096 = xor4096;\nsr.tychei = tychei;\n\nmodule.exports = sr;\n","// A port of an algorithm by Johannes Baagøe <baagoe@baagoe.com>, 2010\n// http://baagoe.com/en/RandomMusings/javascript/\n// https://github.com/nquinlan/better-random-numbers-for-javascript-mirror\n// Original work is under MIT license -\n\n// Copyright (C) 2010 by Johannes Baagøe <baagoe@baagoe.org>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n\n\n(function(global, module, define) {\n\nfunction Alea(seed) {\n var me = this, mash = Mash();\n\n me.next = function() {\n var t = 2091639 * me.s0 + me.c * 2.3283064365386963e-10; // 2^-32\n me.s0 = me.s1;\n me.s1 = me.s2;\n return me.s2 = t - (me.c = t | 0);\n };\n\n // Apply the seeding algorithm from Baagoe.\n me.c = 1;\n me.s0 = mash(' ');\n me.s1 = mash(' ');\n me.s2 = mash(' ');\n me.s0 -= mash(seed);\n if (me.s0 < 0) { me.s0 += 1; }\n me.s1 -= mash(seed);\n if (me.s1 < 0) { me.s1 += 1; }\n me.s2 -= mash(seed);\n if (me.s2 < 0) { me.s2 += 1; }\n mash = null;\n}\n\nfunction copy(f, t) {\n t.c = f.c;\n t.s0 = f.s0;\n t.s1 = f.s1;\n t.s2 = f.s2;\n return t;\n}\n\nfunction impl(seed, opts) {\n var xg = new Alea(seed),\n state = opts && opts.state,\n prng = xg.next;\n prng.int32 = function() { return (xg.next() * 0x100000000) | 0; }\n prng.double = function() {\n return prng() + (prng() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53\n };\n prng.quick = prng;\n if (state) {\n if (typeof(state) == 'object') copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nfunction Mash() {\n var n = 0xefc8249d;\n\n var mash = function(data) {\n data = String(data);\n for (var i = 0; i < data.length; i++) {\n n += data.charCodeAt(i);\n var h = 0.02519603282416938 * n;\n n = h >>> 0;\n h -= n;\n h *= n;\n n = h >>> 0;\n h -= n;\n n += h * 0x100000000; // 2^32\n }\n return (n >>> 0) * 2.3283064365386963e-10; // 2^-32\n };\n\n return mash;\n}\n\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.alea = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n\n","// A Javascript implementaion of the \"Tyche-i\" prng algorithm by\n// Samuel Neves and Filipe Araujo.\n// See https://eden.dei.uc.pt/~sneves/pubs/2011-snfa2.pdf\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this, strseed = '';\n\n // Set up generator function.\n me.next = function() {\n var b = me.b, c = me.c, d = me.d, a = me.a;\n b = (b << 25) ^ (b >>> 7) ^ c;\n c = (c - d) | 0;\n d = (d << 24) ^ (d >>> 8) ^ a;\n a = (a - b) | 0;\n me.b = b = (b << 20) ^ (b >>> 12) ^ c;\n me.c = c = (c - d) | 0;\n me.d = (d << 16) ^ (c >>> 16) ^ a;\n return me.a = (a - b) | 0;\n };\n\n /* The following is non-inverted tyche, which has better internal\n * bit diffusion, but which is about 25% slower than tyche-i in JS.\n me.next = function() {\n var a = me.a, b = me.b, c = me.c, d = me.d;\n a = (me.a + me.b | 0) >>> 0;\n d = me.d ^ a; d = d << 16 ^ d >>> 16;\n c = me.c + d | 0;\n b = me.b ^ c; b = b << 12 ^ d >>> 20;\n me.a = a = a + b | 0;\n d = d ^ a; me.d = d = d << 8 ^ d >>> 24;\n me.c = c = c + d | 0;\n b = b ^ c;\n return me.b = (b << 7 ^ b >>> 25);\n }\n */\n\n me.a = 0;\n me.b = 0;\n me.c = 2654435769 | 0;\n me.d = 1367130551;\n\n if (seed === Math.floor(seed)) {\n // Integer seed.\n me.a = (seed / 0x100000000) | 0;\n me.b = seed | 0;\n } else {\n // String seed.\n strseed += seed;\n }\n\n // Mix in string seed, then discard an initial batch of 64 values.\n for (var k = 0; k < strseed.length + 20; k++) {\n me.b ^= strseed.charCodeAt(k) | 0;\n me.next();\n }\n}\n\nfunction copy(f, t) {\n t.a = f.a;\n t.b = f.b;\n t.c = f.c;\n t.d = f.d;\n return t;\n};\n\nfunction impl(seed, opts) {\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (typeof(state) == 'object') copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.tychei = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n\n","// A Javascript implementaion of the \"xor128\" prng algorithm by\n// George Marsaglia. See http://www.jstatsoft.org/v08/i14/paper\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this, strseed = '';\n\n me.x = 0;\n me.y = 0;\n me.z = 0;\n me.w = 0;\n\n // Set up generator function.\n me.next = function() {\n var t = me.x ^ (me.x << 11);\n me.x = me.y;\n me.y = me.z;\n me.z = me.w;\n return me.w ^= (me.w >>> 19) ^ t ^ (t >>> 8);\n };\n\n if (seed === (seed | 0)) {\n // Integer seed.\n me.x = seed;\n } else {\n // String seed.\n strseed += seed;\n }\n\n // Mix in string seed, then discard an initial batch of 64 values.\n for (var k = 0; k < strseed.length + 64; k++) {\n me.x ^= strseed.charCodeAt(k) | 0;\n me.next();\n }\n}\n\nfunction copy(f, t) {\n t.x = f.x;\n t.y = f.y;\n t.z = f.z;\n t.w = f.w;\n return t;\n}\n\nfunction impl(seed, opts) {\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (typeof(state) == 'object') copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.xor128 = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n\n","// A Javascript implementaion of Richard Brent's Xorgens xor4096 algorithm.\n//\n// This fast non-cryptographic random number generator is designed for\n// use in Monte-Carlo algorithms. It combines a long-period xorshift\n// generator with a Weyl generator, and it passes all common batteries\n// of stasticial tests for randomness while consuming only a few nanoseconds\n// for each prng generated. For background on the generator, see Brent's\n// paper: \"Some long-period random number generators using shifts and xors.\"\n// http://arxiv.org/pdf/1004.3115v1.pdf\n//\n// Usage:\n//\n// var xor4096 = require('xor4096');\n// random = xor4096(1); // Seed with int32 or string.\n// assert.equal(random(), 0.1520436450538547); // (0, 1) range, 53 bits.\n// assert.equal(random.int32(), 1806534897); // signed int32, 32 bits.\n//\n// For nonzero numeric keys, this impelementation provides a sequence\n// identical to that by Brent's xorgens 3 implementaion in C. This\n// implementation also provides for initalizing the generator with\n// string seeds, or for saving and restoring the state of the generator.\n//\n// On Chrome, this prng benchmarks about 2.1 times slower than\n// Javascript's built-in Math.random().\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this;\n\n // Set up generator function.\n me.next = function() {\n var w = me.w,\n X = me.X, i = me.i, t, v;\n // Update Weyl generator.\n me.w = w = (w + 0x61c88647) | 0;\n // Update xor generator.\n v = X[(i + 34) & 127];\n t = X[i = ((i + 1) & 127)];\n v ^= v << 13;\n t ^= t << 17;\n v ^= v >>> 15;\n t ^= t >>> 12;\n // Update Xor generator array state.\n v = X[i] = v ^ t;\n me.i = i;\n // Result is the combination.\n return (v + (w ^ (w >>> 16))) | 0;\n };\n\n function init(me, seed) {\n var t, v, i, j, w, X = [], limit = 128;\n if (seed === (seed | 0)) {\n // Numeric seeds initialize v, which is used to generates X.\n v = seed;\n seed = null;\n } else {\n // String seeds are mixed into v and X one character at a time.\n seed = seed + '\\0';\n v = 0;\n limit = Math.max(limit, seed.length);\n }\n // Initialize circular array and weyl value.\n for (i = 0, j = -32; j < limit; ++j) {\n // Put the unicode characters into the array, and shuffle them.\n if (seed) v ^= seed.charCodeAt((j + 32) % seed.length);\n // After 32 shuffles, take v as the starting w value.\n if (j === 0) w = v;\n v ^= v << 10;\n v ^= v >>> 15;\n v ^= v << 4;\n v ^= v >>> 13;\n if (j >= 0) {\n w = (w + 0x61c88647) | 0; // Weyl.\n t = (X[j & 127] ^= (v + w)); // Combine xor and weyl to init array.\n i = (0 == t) ? i + 1 : 0; // Count zeroes.\n }\n }\n // We have detected all zeroes; make the key nonzero.\n if (i >= 128) {\n X[(seed && seed.length || 0) & 127] = -1;\n }\n // Run the generator 512 times to further mix the state before using it.\n // Factoring this as a function slows the main generator, so it is just\n // unrolled here. The weyl generator is not advanced while warming up.\n i = 127;\n for (j = 4 * 128; j > 0; --j) {\n v = X[(i + 34) & 127];\n t = X[i = ((i + 1) & 127)];\n v ^= v << 13;\n t ^= t << 17;\n v ^= v >>> 15;\n t ^= t >>> 12;\n X[i] = v ^ t;\n }\n // Storing state as object members is faster than using closure variables.\n me.w = w;\n me.X = X;\n me.i = i;\n }\n\n init(me, seed);\n}\n\nfunction copy(f, t) {\n t.i = f.i;\n t.w = f.w;\n t.X = f.X.slice();\n return t;\n};\n\nfunction impl(seed, opts) {\n if (seed == null) seed = +(new Date);\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (state.X) copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.xor4096 = impl;\n}\n\n})(\n this, // window object or global\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n","// A Javascript implementaion of the \"xorshift7\" algorithm by\n// François Panneton and Pierre L'ecuyer:\n// \"On the Xorgshift Random Number Generators\"\n// http://saluc.engr.uconn.edu/refs/crypto/rng/panneton05onthexorshift.pdf\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this;\n\n // Set up generator function.\n me.next = function() {\n // Update xor generator.\n var X = me.x, i = me.i, t, v, w;\n t = X[i]; t ^= (t >>> 7); v = t ^ (t << 24);\n t = X[(i + 1) & 7]; v ^= t ^ (t >>> 10);\n t = X[(i + 3) & 7]; v ^= t ^ (t >>> 3);\n t = X[(i + 4) & 7]; v ^= t ^ (t << 7);\n t = X[(i + 7) & 7]; t = t ^ (t << 13); v ^= t ^ (t << 9);\n X[i] = v;\n me.i = (i + 1) & 7;\n return v;\n };\n\n function init(me, seed) {\n var j, w, X = [];\n\n if (seed === (seed | 0)) {\n // Seed state array using a 32-bit integer.\n w = X[0] = seed;\n } else {\n // Seed state using a string.\n seed = '' + seed;\n for (j = 0; j < seed.length; ++j) {\n X[j & 7] = (X[j & 7] << 15) ^\n (seed.charCodeAt(j) + X[(j + 1) & 7] << 13);\n }\n }\n // Enforce an array length of 8, not all zeroes.\n while (X.length < 8) X.push(0);\n for (j = 0; j < 8 && X[j] === 0; ++j);\n if (j == 8) w = X[7] = -1; else w = X[j];\n\n me.x = X;\n me.i = 0;\n\n // Discard an initial 256 values.\n for (j = 256; j > 0; --j) {\n me.next();\n }\n }\n\n init(me, seed);\n}\n\nfunction copy(f, t) {\n t.x = f.x.slice();\n t.i = f.i;\n return t;\n}\n\nfunction impl(seed, opts) {\n if (seed == null) seed = +(new Date);\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (state.x) copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.xorshift7 = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n","// A Javascript implementaion of the \"xorwow\" prng algorithm by\n// George Marsaglia. See http://www.jstatsoft.org/v08/i14/paper\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this, strseed = '';\n\n // Set up generator function.\n me.next = function() {\n var t = (me.x ^ (me.x >>> 2));\n me.x = me.y; me.y = me.z; me.z = me.w; me.w = me.v;\n return (me.d = (me.d + 362437 | 0)) +\n (me.v = (me.v ^ (me.v << 4)) ^ (t ^ (t << 1))) | 0;\n };\n\n me.x = 0;\n me.y = 0;\n me.z = 0;\n me.w = 0;\n me.v = 0;\n\n if (seed === (seed | 0)) {\n // Integer seed.\n me.x = seed;\n } else {\n // String seed.\n strseed += seed;\n }\n\n // Mix in string seed, then discard an initial batch of 64 values.\n for (var k = 0; k < strseed.length + 64; k++) {\n me.x ^= strseed.charCodeAt(k) | 0;\n if (k == strseed.length) {\n me.d = me.x << 10 ^ me.x >>> 4;\n }\n me.next();\n }\n}\n\nfunction copy(f, t) {\n t.x = f.x;\n t.y = f.y;\n t.z = f.z;\n t.w = f.w;\n t.v = f.v;\n t.d = f.d;\n return t;\n}\n\nfunction impl(seed, opts) {\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (typeof(state) == 'object') copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.xorwow = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n\n","/*\nCopyright 2019 David Bau.\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n*/\n\n(function (global, pool, math) {\n//\n// The following constants are related to IEEE 754 limits.\n//\n\nvar width = 256, // each RC4 output is 0 <= x < 256\n chunks = 6, // at least six RC4 outputs for each double\n digits = 52, // there are 52 significant digits in a double\n rngname = 'random', // rngname: name for Math.random and Math.seedrandom\n startdenom = math.pow(width, chunks),\n significance = math.pow(2, digits),\n overflow = significance * 2,\n mask = width - 1,\n nodecrypto; // node.js crypto module, initialized at the bottom.\n\n//\n// seedrandom()\n// This is the seedrandom function described above.\n//\nfunction seedrandom(seed, options, callback) {\n var key = [];\n options = (options == true) ? { entropy: true } : (options || {});\n\n // Flatten the seed string or build one from local entropy if needed.\n var shortseed = mixkey(flatten(\n options.entropy ? [seed, tostring(pool)] :\n (seed == null) ? autoseed() : seed, 3), key);\n\n // Use the seed to initialize an ARC4 generator.\n var arc4 = new ARC4(key);\n\n // This function returns a random double in [0, 1) that contains\n // randomness in every bit of the mantissa of the IEEE 754 value.\n var prng = function() {\n var n = arc4.g(chunks), // Start with a numerator n < 2 ^ 48\n d = startdenom, // and denominator d = 2 ^ 48.\n x = 0; // and no 'extra last byte'.\n while (n < significance) { // Fill up all significant digits by\n n = (n + x) * width; // shifting numerator and\n d *= width; // denominator and generating a\n x = arc4.g(1); // new least-significant-byte.\n }\n while (n >= overflow) { // To avoid rounding up, before adding\n n /= 2; // last byte, shift everything\n d /= 2; // right using integer math until\n x >>>= 1; // we have exactly the desired bits.\n }\n return (n + x) / d; // Form the number within [0, 1).\n };\n\n prng.int32 = function() { return arc4.g(4) | 0; }\n prng.quick = function() { return arc4.g(4) / 0x100000000; }\n prng.double = prng;\n\n // Mix the randomness into accumulated entropy.\n mixkey(tostring(arc4.S), pool);\n\n // Calling convention: what to return as a function of prng, seed, is_math.\n return (options.pass || callback ||\n function(prng, seed, is_math_call, state) {\n if (state) {\n // Load the arc4 state from the given state if it has an S array.\n if (state.S) { copy(state, arc4); }\n // Only provide the .state method if requested via options.state.\n prng.state = function() { return copy(arc4, {}); }\n }\n\n // If called as a method of Math (Math.seedrandom()), mutate\n // Math.random because that is how seedrandom.js has worked since v1.0.\n if (is_math_call) { math[rngname] = prng; return seed; }\n\n // Otherwise, it is a newer calling convention, so return the\n // prng directly.\n else return prng;\n })(\n prng,\n shortseed,\n 'global' in options ? options.global : (this == math),\n options.state);\n}\n\n//\n// ARC4\n//\n// An ARC4 implementation. The constructor takes a key in the form of\n// an array of at most (width) integers that should be 0 <= x < (width).\n//\n// The g(count) method returns a pseudorandom integer that concatenates\n// the next (count) outputs from ARC4. Its return value is a number x\n// that is in the range 0 <= x < (width ^ count).\n//\nfunction ARC4(key) {\n var t, keylen = key.length,\n me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];\n\n // The empty key [] is treated as [0].\n if (!keylen) { key = [keylen++]; }\n\n // Set up S using the standard key scheduling algorithm.\n while (i < width) {\n s[i] = i++;\n }\n for (i = 0; i < width; i++) {\n s[i] = s[j = mask & (j + key[i % keylen] + (t = s[i]))];\n s[j] = t;\n }\n\n // The \"g\" method returns the next (count) outputs as one number.\n (me.g = function(count) {\n // Using instance members instead of closure state nearly doubles speed.\n var t, r = 0,\n i = me.i, j = me.j, s = me.S;\n while (count--) {\n t = s[i = mask & (i + 1)];\n r = r * width + s[mask & ((s[i] = s[j = mask & (j + t)]) + (s[j] = t))];\n }\n me.i = i; me.j = j;\n return r;\n // For robust unpredictability, the function call below automatically\n // discards an initial batch of values. This is called RC4-drop[256].\n // See http://google.com/search?q=rsa+fluhrer+response&btnI\n })(width);\n}\n\n//\n// copy()\n// Copies internal state of ARC4 to or from a plain object.\n//\nfunction copy(f, t) {\n t.i = f.i;\n t.j = f.j;\n t.S = f.S.slice();\n return t;\n};\n\n//\n// flatten()\n// Converts an object tree to nested arrays of strings.\n//\nfunction flatten(obj, depth) {\n var result = [], typ = (typeof obj), prop;\n if (depth && typ == 'object') {\n for (prop in obj) {\n try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}\n }\n }\n return (result.length ? result : typ == 'string' ? obj : obj + '\\0');\n}\n\n//\n// mixkey()\n// Mixes a string seed into a key that is an array of integers, and\n// returns a shortened string seed that is equivalent to the result key.\n//\nfunction mixkey(seed, key) {\n var stringseed = seed + '', smear, j = 0;\n while (j < stringseed.length) {\n key[mask & j] =\n mask & ((smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++));\n }\n return tostring(key);\n}\n\n//\n// autoseed()\n// Returns an object for autoseeding, using window.crypto and Node crypto\n// module if available.\n//\nfunction autoseed() {\n try {\n var out;\n if (nodecrypto && (out = nodecrypto.randomBytes)) {\n // The use of 'out' to remember randomBytes makes tight minified code.\n out = out(width);\n } else {\n out = new Uint8Array(width);\n (global.crypto || global.msCrypto).getRandomValues(out);\n }\n return tostring(out);\n } catch (e) {\n var browser = global.navigator,\n plugins = browser && browser.plugins;\n return [+new Date, global, plugins, global.screen, tostring(pool)];\n }\n}\n\n//\n// tostring()\n// Converts an array of charcodes to a string\n//\nfunction tostring(a) {\n return String.fromCharCode.apply(0, a);\n}\n\n//\n// When seedrandom.js is loaded, we immediately mix a few bits\n// from the built-in RNG into the entropy pool. Because we do\n// not want to interfere with deterministic PRNG state later,\n// seedrandom will not call math.random on its own again after\n// initialization.\n//\nmixkey(math.random(), pool);\n\n//\n// Nodejs and AMD support: export the implementation as a module using\n// either convention.\n//\nif ((typeof module) == 'object' && module.exports) {\n module.exports = seedrandom;\n // When in node.js, try using crypto package for autoseeding.\n try {\n nodecrypto = require('crypto');\n } catch (ex) {}\n} else if ((typeof define) == 'function' && define.amd) {\n define(function() { return seedrandom; });\n} else {\n // When included as a plain script, set up Math.seedrandom global.\n math['seed' + rngname] = seedrandom;\n}\n\n\n// End anonymous scope, and pass initial values.\n})(\n // global: `self` in browsers (including strict mode and web workers),\n // otherwise `this` in Node and other environments\n (typeof self !== 'undefined') ? self : this,\n [], // pool: entropy pool starts empty\n Math // math: package containing random, pow, and seedrandom\n);\n"],"names":["_scriptDir","exportCppDbscanLib","document","currentScript","src","undefined","readyPromiseResolve","readyPromiseReject","Module","Promise","resolve","reject","readBinary","moduleOverrides","Object","assign","ENVIRONMENT_IS_WEB","window","ENVIRONMENT_IS_WORKER","importScripts","scriptDirectory","process","versions","node","self","location","href","indexOf","substr","replace","lastIndexOf","url","xhr","XMLHttpRequest","open","responseType","send","Uint8Array","console","log","bind","wasmBinary","wasmMemory","err","warn","WebAssembly","abort","HEAP8","HEAPU8","HEAPU32","ABORT","updateMemoryViews","b","buffer","Int8Array","Int16Array","Int32Array","Uint16Array","Uint32Array","Float32Array","Float64Array","__ATPRERUN__","__ATINIT__","__ATPOSTRUN__","runDependencies","runDependencyWatcher","dependenciesFulfilled","what","e","RuntimeError","wasmBinaryFile","path","isDataURI","filename","startsWith","getBinary","file","instantiateArrayBuffer","binaryFile","imports","receiver","fetch","then","credentials","response","catch","getBinaryPromise","binary","instantiate","instance","reason","callRuntimeCallbacks","callbacks","length","shift","ExceptionInfo","excPtr","this","ptr","set_type","type","get_type","set_destructor","destructor","get_destructor","set_caught","caught","get_caught","set_rethrown","rethrown","get_rethrown","init","set_adjusted_ptr","adjustedPtr","get_adjusted_ptr","get_exception_ptr","___cxa_is_pointer_type","adjusted","emscripten_realloc_buffer","size","grow","byteLength","getCFunc","ident","UTF8Decoder","TextDecoder","ccall","returnType","argTypes","args","opts","toC","str","ret","len","i","c","charCodeAt","lengthBytesUTF8","stackAlloc","outPtr","maxBytesToWrite","heap","outIdx","endIdx","u","stringToUTF8Array","stringToUTF8","stringToUTF8OnStack","arr","array","set","func","cArgs","stack","converter","stackSave","apply","stackRestore","heapOrArray","idx","maxBytesToRead","endPtr","decode","subarray","u0","u1","u2","String","fromCharCode","ch","UTF8ArrayToString","Boolean","convertReturnValue","onDone","calledRun","wasmImports","dest","num","copyWithin","requestedSize","x","oldSize","maxHeapSize","cutDown","overGrownHeapSize","Math","min","max","callback","info","receiveInstance","module","cb","exports","unshift","clearInterval","removeRunDependency","result","instantiateStreaming","createWasm","arguments","run","doRun","postRun","preRun","setTimeout","numericArgs","every","runCaller","pop","ready","define","isNil","insertSmaller","distancesAr","indexes","index","newPosition","findIndex","v","splice","assert","condition","message","Error","vectorDistanceMetricsMethods","Euclidean","p","q","pow","sqrt","stringDistanceMetricsMethods","Levenshtein","JaroWinkler","Manhattan","s1","s2","dist","Onehot","bitArrayDistanceMetricsMethods","Tanimoto","Dice","Asymmetric","BraunBlanquet","Cosine","Kulczynski","McConnaughey","RogotGoldberg","Russel","Sokal","Hamming","intArrayDistanceMetricsMethods","TanimotoIntArray","numberDistanceMetricsMethods","Difference","numberArrayDistanceMetrics","CommonItems","AvailableMetrics","Vector","BitArray","MacroMolecule","HAMMING","LEVENSHTEIN","NEEDLEMANN_WUNSCH","MONOMER_CHEMICAL_DISTANCE","Number","IntArray","NumberArray","MetricToDataType","keys","reduce","key","val","Measure","constructor","method","dataType","metricNeedsArgs","toString","name","isNumberArrayMetric","getMeasure","dict","hasOwnProperty","getMetricByDataType","availableMeasures","DistanceMatrixService","useConcurrentWorkers","terminateOnComplete","threadCount","navigator","hardwareConcurrency","_workerCount","_workers","Array","fill","map","Worker","URL","_terminateOnComplete","calc","values","fnName","normalize","calcMulti","MANHATTAN","fnNames","weights","aggregationMethod","async","promises","totalLength","chunkSize","distanceMatrix","endRow","endCol","lmin","lmax","MIN_VALUE","start","floor","end","startRow","startCol","postMessage","chunckSize","resolveWorker","rejectWorker","onmessage","data","error","distanceMatrixData","terminate","all","forEach","value","worker","tauRandInt","n","random","tauRand","empty","output","push","range","_","filled","zeros","mean","input","sum","rejectionSample","nSamples","poolSize","rejectSample","j","broken","k","reshape2d","a","rows","col","makeHeap","nPoints","makeArrays","fillValue","Infinity","heapPush","row","weight","flag","indices","uncheckedHeapPush","isNew","iSwap","ic1","ic2","heapShape2","buildCandidates","currentGraph","nVertices","nNeighbors","maxCandidates","candidateNeighbors","isn","d","deheapSort","indHeap","distHeap","indHeapIndex","distHeapIndex","temp1","temp2","siftDown","heap1","heap2","ceiling","elt","leftChild","rightChild","swap","smallestFlagged","ind","minDist","resultIndex","SparseMatrix","cols","dims","entries","Map","nRows","nCols","checkDims","makeKey","has","get","defaultValue","getAll","ordered","rowColValues","sort","getDims","getRows","from","_key","getCols","getValues","fn","vals","toArray","matrix","oldRows","oldCols","oldVals","matlen","pairwiseMultiply","elementWise","y","add","subtract","multiplyScalar","scalar","eliminateZeros","m","zeroIndices","Set","removeByZeroIndex","nextValues","filter","nextRows","nextCols","normType","normFn","normFns","colsByRow","nextMatrix","norm","xs","op","visited","operate","nextValue","valuesA","rowsA","colsA","valuesB","rowsB","colsB","getCSR","indptr","currentRow","FlatTree","hyperplanes","offsets","children","makeForest","nTrees","leafSize","trees","makeEuclideanTree","makeTree","forest","tree","nNodes","numNodes","nLeaves","numLeaves","hyperplane","recursiveFlatten","flattenTree","splitResults","leftIndex","rightIndex","left","right","hyperplaneOffset","hyperplaneVector","nLeft","nRight","side","margin","indicesLeft","indicesRight","offset","euclideanRandomProjectionSplit","isLeaf","nodeNum","leafNum","oldNodeNum","res","selectSide","point","searchFlatTree","prototype","isAnyArray","object","call","endsWith","errorCalculation","parameters","parameterizedFunction","abs","step","params","damping","gradientDifference","identity","eye","evaluatedData","gradientFunc","paramFunction","ans","param","auxParams","slice","funcParam","gradientFunction","matrixFunc","matrixFunction","inverseMatrix","mmul","transpose","sub","mul","to1DArray","SMOOTH_K_TOLERANCE","MIN_K_DIST_SCALE","UMAP","neighbors","learningRate","localConnectivity","nComponents","nEpochs","negativeSampleRate","repulsionStrength","setOpMixRatio","spread","transformQueueSize","targetMetric","targetWeight","targetNNeighbors","distanceFn","numeric","isInitialized","rpForest","embedding","optimizationState","OptimizationState","setParam","fit","X","initializeFit","optimizeLayout","fitAsync","optimizeLayoutAsync","setSupervisedProjection","Y","setPrecomputedKNN","knnIndices","knnDistances","getNEpochs","knnResults","nearestNeighbors","graph","fuzzySimplicialSet","makeSearchFns","searchGraph","makeSearchGraph","processGraphForSupervisedProjection","head","tail","epochsPerSample","initializeSimplicialSetEmbedding","initializeOptimization","prepareForOptimizationLoop","initFromTree","initFromRandom","queryPoints","_heap","_tree","search","initialization","tried","vertex","candidates","candidate","knn","distances","neighbor","distance","transform","toTransform","rawData","results","adjustedLocalConnectivity","sigmas","rhos","smoothKNNDistance","computeMembershipStrengths","csrMatrix","_z","initTransform","graphMax","makeEpochsPerSample","assignOptimizationStateParameters","headEmbedding","tailEmbedding","currentEpoch","farDist","categoricalSimplicialSetIntersection","optimizeLayoutStep","getEmbedding","metricNNDescent","leafArray","nIters","delta","rho","rpTreeInit","cj","ck","round","log2","sparseMatrix","prodMatrix","simplicialSet","target","unknownDist","intersection","exp","fastIntersection","resetLocalConnectivity","nIter","bandwidth","lo","hi","mid","ithDistances","nonZeroDists","interpolation","psum","meanIthDistances","meanDistances","graphValues","entry","w","state","dim","moveOther","epochsPerNegativeSample","epochOfNextNegativeSample","epochOfNextSample","initialAlpha","alpha","gamma","xv","yv","parameterValues","options","maxIterations","errorTolerance","minValues","maxValues","initialValues","parLen","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","iteration","converged","isNaN","parameterError","iterations","findABParams","current","other","distSquared","rDist","gradCoeff","gradD","clip","nNegSamples","epochCallback","epochCompleted","shouldStop","isFinished","clipValue","TSNE","getopt","opt","field","defaultval","gaussRandom","returnV","vValue","r","randn","mu","std","ArrayBuffer","randn2d","s","uses","l2","x1","x2","D","x1i","x2i","xtod","N","getIterSize","rowSize","d2p","perplexity","tol","indexer","hTarget","P","prow","betamin","betamax","beta","done","maxtries","pj","nHere","pOut","N2","sign","iter","epsilon","initDataRaw","dists","initSolution","initDataDist","time","timeEnd","gains","ystep","getSolution","cg","costGrad","cost","grad","ymean","gid","sid","gainid","newgain","newsid","debugGrad","yold","cg0","cg1","analytic","numerical","pmul","quArr","qsum","qu","prev","Q","premult","thisArg","_arguments","generator","fulfilled","next","rejected","gpuAdapter","gpuDevice","gpu","requestAdapter","powerPreference","isLost","lost","requiredBufferSize","adapterLimits","limits","buffferSizeLimit","maxBufferSize","storageBufferSizeLimit","maxStorageBufferBindingSize","requestDevice","requiredLimits","WEBGSLAGGREGATION","EUCLIDEAN","arraySize","WEBGPUDISTANCE","_maxArraySize","entryIndex","maxArraySize","_entryIndex","TANIMOTO","LEVENSTEIN","NEEDLEMAN_WUNSCH","SOKAL","COSINE","ASYMMETRIC","OneHot","distanceFunctionComplexity","maxEntrySize","ceil","_maxEntrySize","TypeSupportedDistances","MatrixMatrixOpType","MatrixOpType","MatrixScalarOpType","multiColWebGPUKNN","entryList","knnSize","distanceMetrics","aggregationFunction","some","list","availableDistanceMetrics","metric","includes","join","numOfColumns","device","deviceLost","listSize","processInfo","distanceMetric","gapOpenPenalty","gapExtensionPenalty","_a","_b","entryType","encodedList","split","_data","encodedListType","arraySizes","maxEntryLen","complexity","EncodedArrayConstructor","flatSourceArray","seq","suppInfoStructWgsl","suppInfoSize","suppInfoType","suppInfoBuffer","maxMonomerIndex","scoringMatrix","alphabetIndexes","similarityMatrixSize","transferedSimilarityMatrix","key2","dataTypeWGSL","dataStructWgsl","sourceArraySize","suppInfoWgsl","wgsl","needsDummy","trim","combinedComplexity","dataWgsl","computationsPerPass","pairComparisonsPerPass","workgroupsDim","globalThreadDimSize","resultIndexes","resultDistances","createShaderModule","label","code","getCombinedDistanceScript","pipeline","createComputePipeline","layout","compute","entryPoint","computeInfo32Size","suppInfo32Size","computeInfoBufferSize","BYTES_PER_ELEMENT","paddedComputeInfoBufferSize","remainder","computeInfoBuffer","createBuffer","usage","GPUBufferUsage","STORAGE","COPY_SRC","COPY_DST","mappedAtCreation","mappedComputeInfoArrayBuffer","getMappedRange","startAt","endAt","pairComparisonStartAt","pairComparisonEndAt","computeInfoOffSet","ArrayConstructor","unmap","suppInfoBufferSize","paddedSuppInfoBufferSize","suppInfoRemainder","mappedSuppInfoArrayBuffer","suppInfoOffSet","outKnnArraySize","bufferDistances","bufferIndexes","bytesPerOutArrayRow","bindGroup","createBindGroup","getBindGroupLayout","binding","resource","resultBufferDistances","MAP_READ","resultBufferIndexes","pairComparisonPasses","pairIter","queue","writeBuffer","encoder","createCommandEncoder","pass","beginComputePass","setPipeline","setBindGroup","dispatchWorkgroups","workGroupDivision","copyBufferToBuffer","commandBuffer","finish","submit","onSubmittedWorkDone","mapAsync","GPUMapMode","READ","destroy","knnIndexes","maxEntryLens","aggregation","pairwiseOpSparse","indexes1","distances1","offsets1","indexes2","distances2","offsets2","numOfEntries","unionMatrixOffsets","requiredWorkgroups","threadsPerWorkgroupDim","numOfWorkgroupsPerDim","threadsPerYDimension","sparseSize1","sparseSize2","unionMatrixSize","processWgsl","paddedStorage1ByteSize","remainder1","paddedStorage2ByteSize","remainder2","paddedResStorageByteSize","remainder3","source1Buffer","mappedSource1Buffer","source2Buffer","mappedSource2Buffer","resBuffer","unionMatrixOffsetsBuffer","mappedUnionMatrixOffsetsBuffer","resultBuffer","resultArrayBuffer","resultKnnIndexes","resultKnnDistances","weightSquare","centralDifference","nbParams","nbPoints","rowIndex","funcParam2","residualError","scale","jacobianWeightResidualError","perturbations","checkTimeout","dampingStepUp","dampingStepDown","improvementThreshold","timeout","filler","endTime","Date","now","checkOptions","optimalError","optimalParameters","previousError","toOffsetForm","ar","performMatrixOps","flatKnnIndexes","flatKnnDistances","unionInfo","entryLen","knnMatrixOpInfoWGSL","indexesBuffer32Size","indexBuffer","mappedIndexesBuffer","mappedIndexesArray","sizesBuffer","unionSizesBuffer","mappedUnionSizesBuffer","resultTransposeSizesBuffer","resultUnionSizesBuffer","resultTransposeSizesArrayBuffer","resultUnionSizesArrayBuffer","resultTransposeSizesArray","resultUnionSizesArray","old","getKnnSparseOpInfo","transposed","knnSparseInfo","fullKnnEntrySize","transposeOffsets","offsetsCopy","transposeKNNIndexes","transposeKNNDistances","otherIndex","otherIndexOffset","transposeKNN","sourceOffsets","transposeMultRes","addRes","subtRes","unionSizes","meanDistancesSum","currentMean","smoothKNNDistanceWGSL","distanceBuffer32Size","resultSigmas","resultRhos","distancesBuffer","mappedDistanceBuffer","mappedDistanceArray","bufferSigmas","bufferRhos","resultBufferRhos","resultBufferSigmas","UmapParams","nNeighbours","WebGPUUMAP","membershipStrengths","calcSmoothKNNDistances","calcMembershipStrengths","umapParams","resEmbeddings","embeddingSize","divisionFactor","headSize","processWGSL","embedSize","workgroupDim","threadsPerRow","optimizeLayoutWGSL","paddedMatrixStorageSize","paddedepochStorageSize","paddedembedStorageSize","paddedComputeInfoSize","remainder4","matrixStorageBuffer","matrixStorageArrayBuffer","epochStorageBuffer","epochStorageArrayBuffer","epochStorageArrayView","headEmbeddings","embeddingStorageBuffer","mappedEmbeddingStorageBuffer","mappedEmbeddingStorageArray","randomNumbers","computeInfoArrayBuffer","outEmbedViewBuffer","resArrayBuffer","headEmbeddingsView","optimizationLoop","sigmasLength","rhosLength","computeMembershipStrengthsWGSL","paddedCombinedMembershipStructByteSize","membershipStrengthsInfoBuffer","mappedInfoBuffer","mappedInfoArray","knnDistancesBuffer","resultKnnDistancesArrayBuffer","bytesPerKnnRow","resKnnDistances","dataView","out","fuzzySimplicialSetRes","eRes","maxVal","cur","minGraphVal","unionSizesCopy","offsetAccum","nonZeroGraphOffsets","nonZeroGraphSize","MultiColumnReducer","TSNEReducer","super","randomSeed","randomFn","reducer","distanceFnames","distanceFns","distanceFnArgs","progressFunc","matrixService","UMAPReducer","useWebGPU","vectors","_parallelDistanceWorkers","knnGraph","multiColumnKNN","webGPUReducer","epoc","AvailableReducers","MultiColDimReducer","metrics","distanceAggregation","measures","measure","bitArrayLength","_length","transposeMatrix","availableMetricsByType","typeName","availableMethods","availableMetrics","obj","epochNum","epochsLength","columnsData","onMessage","alea","xor128","xorwow","xorshift7","xor4096","tychei","sr","global","Alea","seed","me","mash","h","t","s0","copy","f","impl","xg","prng","int32","double","quick","XorGen","strseed","z","limit","pool","math","nodecrypto","width","startdenom","significance","overflow","mask","seedrandom","shortseed","mixkey","flatten","entropy","tostring","randomBytes","crypto","msCrypto","getRandomValues","browser","plugins","screen","autoseed","arc4","ARC4","g","S","is_math_call","keylen","count","depth","prop","typ","smear","stringseed","ex"],"sourceRoot":""}
1
+ {"version":3,"file":"738.js","mappings":"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","sources":["webpack://eda/./node_modules/@datagrok-libraries/math/src/dbscan/wasm/wasmDbscan.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/distance-matrix/utils.js","webpack://eda/./node_modules/@datagrok-libraries/utils/src/type-declarations.js","webpack://eda/./node_modules/@datagrok-libraries/utils/src/vector-operations.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/typed-metrics/typed-metrics.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/distance-matrix/distance-matrix-service.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/utils.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/heap.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/matrix.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/tree.js","webpack://eda/./node_modules/@datagrok-libraries/ml/node_modules/is-any-array/src/index.js","webpack://eda/./node_modules/@datagrok-libraries/ml/node_modules/ml-levenberg-marquardt/src/errorCalculation.js","webpack://eda/./node_modules/@datagrok-libraries/ml/node_modules/ml-levenberg-marquardt/src/step.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/umap.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/umap/nn_descent.js","webpack://eda/./node_modules/@datagrok-libraries/ml/node_modules/ml-levenberg-marquardt/src/index.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/t-sne/t-sne.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/distance-matrix/proxy.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/getGPUDevice.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/multi-col-distances/webGPU-aggregation.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/multi-col-distances/webGPU-multicol-distances.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/multi-col-knn/multiCol-KNN.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/types.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/preprocessing/webGPU-process-info.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/knn-sparse-info.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/pairwise-sparse-ops.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/errorCalculation.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/step.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/gradientFunction.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/utils.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/index.js","webpack://eda/./node_modules/ml-levenberg-marquardt/lib-esm/checkOptions.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/fuzzy-simplical-set.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/wgsl/knn-sparse-info.wgsl.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/smooth-knn-distance.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/wgsl/smooth-knn-distance.wgsl.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/WEBGPU-UMAP.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/optimization-loop.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/wgsl/optimization-loop.wgsl.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/membership-strengths.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/wgsl/membership-strengths.wgsl.js","webpack://eda/./node_modules/@datagrok-libraries/math/src/webGPU/umap/simplical-set-embedding.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/multi-column-dim-reducer.js","webpack://eda/./node_modules/@datagrok-libraries/ml/src/multi-column-dimensionality-reduction/mulit-column-dim-reducer-worker.js","webpack://eda/./node_modules/seedrandom/index.js","webpack://eda/./node_modules/seedrandom/lib/alea.js","webpack://eda/./node_modules/seedrandom/lib/tychei.js","webpack://eda/./node_modules/seedrandom/lib/xor128.js","webpack://eda/./node_modules/seedrandom/lib/xor4096.js","webpack://eda/./node_modules/seedrandom/lib/xorshift7.js","webpack://eda/./node_modules/seedrandom/lib/xorwow.js","webpack://eda/./node_modules/seedrandom/seedrandom.js"],"sourcesContent":["\r\nexport var exportCppDbscanLib = (() => {\r\n var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined;\r\n \r\n return (\r\nfunction(exportCppDbscanLib = {}) {\r\n\r\n// include: shell.js\r\n// The Module object: Our interface to the outside world. We import\r\n// and export values on it. There are various ways Module can be used:\r\n// 1. Not defined. We create it here\r\n// 2. A function parameter, function(Module) { ..generated code.. }\r\n// 3. pre-run appended it, var Module = {}; ..generated code..\r\n// 4. External script tag defines var Module.\r\n// We need to check if Module already exists (e.g. case 3 above).\r\n// Substitution will be replaced with actual code on later stage of the build,\r\n// this way Closure Compiler will not mangle it (e.g. case 4. above).\r\n// Note that if you want to run closure, and also to use Module\r\n// after the generated code, you will need to define var Module = {};\r\n// before the code. Then that object will be used in the code, and you\r\n// can continue to use Module afterwards as well.\r\nvar Module = typeof exportCppDbscanLib != 'undefined' ? exportCppDbscanLib : {};\r\n\r\n// Set up the promise that indicates the Module is initialized\r\nvar readyPromiseResolve, readyPromiseReject;\r\nModule['ready'] = new Promise(function(resolve, reject) {\r\n readyPromiseResolve = resolve;\r\n readyPromiseReject = reject;\r\n});\r\n\r\n// --pre-jses are emitted after the Module integration code, so that they can\r\n// refer to Module (if they choose; they can also define Module)\r\n\r\n\r\n// Sometimes an existing Module object exists with properties\r\n// meant to overwrite the default module functionality. Here\r\n// we collect those properties and reapply _after_ we configure\r\n// the current environment's defaults to avoid having to be so\r\n// defensive during initialization.\r\nvar moduleOverrides = Object.assign({}, Module);\r\n\r\nvar arguments_ = [];\r\nvar thisProgram = './this.program';\r\nvar quit_ = (status, toThrow) => {\r\n throw toThrow;\r\n};\r\n\r\n// Determine the runtime environment we are in. You can customize this by\r\n// setting the ENVIRONMENT setting at compile time (see settings.js).\r\n\r\n// Attempt to auto-detect the environment\r\nvar ENVIRONMENT_IS_WEB = typeof window == 'object';\r\nvar ENVIRONMENT_IS_WORKER = typeof importScripts == 'function';\r\n// N.b. Electron.js environment is simultaneously a NODE-environment, but\r\n// also a web environment.\r\nvar ENVIRONMENT_IS_NODE = typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string';\r\nvar ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;\r\n\r\n// `/` should be present at the end if `scriptDirectory` is not empty\r\nvar scriptDirectory = '';\r\nfunction locateFile(path) {\r\n if (Module['locateFile']) {\r\n return Module['locateFile'](path, scriptDirectory);\r\n }\r\n return scriptDirectory + path;\r\n}\r\n\r\n// Hooks that are implemented differently in different runtime environments.\r\nvar read_,\r\n readAsync,\r\n readBinary,\r\n setWindowTitle;\r\n\r\n// Note that this includes Node.js workers when relevant (pthreads is enabled).\r\n// Node.js workers are detected as a combination of ENVIRONMENT_IS_WORKER and\r\n// ENVIRONMENT_IS_NODE.\r\nif (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {\r\n if (ENVIRONMENT_IS_WORKER) { // Check worker, not web, since window could be polyfilled\r\n scriptDirectory = self.location.href;\r\n } else if (typeof document != 'undefined' && document.currentScript) { // web\r\n scriptDirectory = document.currentScript.src;\r\n }\r\n // When MODULARIZE, this JS may be executed later, after document.currentScript\r\n // is gone, so we saved it, and we use it here instead of any other info.\r\n if (_scriptDir) {\r\n scriptDirectory = _scriptDir;\r\n }\r\n // blob urls look like blob:http://site.com/etc/etc and we cannot infer anything from them.\r\n // otherwise, slice off the final part of the url to find the script directory.\r\n // if scriptDirectory does not contain a slash, lastIndexOf will return -1,\r\n // and scriptDirectory will correctly be replaced with an empty string.\r\n // If scriptDirectory contains a query (starting with ?) or a fragment (starting with #),\r\n // they are removed because they could contain a slash.\r\n if (scriptDirectory.indexOf('blob:') !== 0) {\r\n scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, \"\").lastIndexOf('/')+1);\r\n } else {\r\n scriptDirectory = '';\r\n }\r\n\r\n // Differentiate the Web Worker from the Node Worker case, as reading must\r\n // be done differently.\r\n {\r\n// include: web_or_worker_shell_read.js\r\nread_ = (url) => {\r\n var xhr = new XMLHttpRequest();\r\n xhr.open('GET', url, false);\r\n xhr.send(null);\r\n return xhr.responseText;\r\n }\r\n\r\n if (ENVIRONMENT_IS_WORKER) {\r\n readBinary = (url) => {\r\n var xhr = new XMLHttpRequest();\r\n xhr.open('GET', url, false);\r\n xhr.responseType = 'arraybuffer';\r\n xhr.send(null);\r\n return new Uint8Array(/** @type{!ArrayBuffer} */(xhr.response));\r\n };\r\n }\r\n\r\n readAsync = (url, onload, onerror) => {\r\n var xhr = new XMLHttpRequest();\r\n xhr.open('GET', url, true);\r\n xhr.responseType = 'arraybuffer';\r\n xhr.onload = () => {\r\n if (xhr.status == 200 || (xhr.status == 0 && xhr.response)) { // file URLs can return 0\r\n onload(xhr.response);\r\n return;\r\n }\r\n onerror();\r\n };\r\n xhr.onerror = onerror;\r\n xhr.send(null);\r\n }\r\n\r\n// end include: web_or_worker_shell_read.js\r\n }\r\n\r\n setWindowTitle = (title) => document.title = title;\r\n} else\r\n{\r\n}\r\n\r\nvar out = Module['print'] || console.log.bind(console);\r\nvar err = Module['printErr'] || console.warn.bind(console);\r\n\r\n// Merge back in the overrides\r\nObject.assign(Module, moduleOverrides);\r\n// Free the object hierarchy contained in the overrides, this lets the GC\r\n// reclaim data used e.g. in memoryInitializerRequest, which is a large typed array.\r\nmoduleOverrides = null;\r\n\r\n// Emit code to handle expected values on the Module object. This applies Module.x\r\n// to the proper local x. This has two benefits: first, we only emit it if it is\r\n// expected to arrive, and second, by using a local everywhere else that can be\r\n// minified.\r\n\r\nif (Module['arguments']) arguments_ = Module['arguments'];\r\n\r\nif (Module['thisProgram']) thisProgram = Module['thisProgram'];\r\n\r\nif (Module['quit']) quit_ = Module['quit'];\r\n\r\n// perform assertions in shell.js after we set up out() and err(), as otherwise if an assertion fails it cannot print the message\r\n\r\n\r\n// end include: shell.js\r\n// include: preamble.js\r\n// === Preamble library stuff ===\r\n\r\n// Documentation for the public APIs defined in this file must be updated in:\r\n// site/source/docs/api_reference/preamble.js.rst\r\n// A prebuilt local version of the documentation is available at:\r\n// site/build/text/docs/api_reference/preamble.js.txt\r\n// You can also build docs locally as HTML or other formats in site/\r\n// An online HTML version (which may be of a different version of Emscripten)\r\n// is up at http://kripken.github.io/emscripten-site/docs/api_reference/preamble.js.html\r\n\r\nvar wasmBinary;\r\nif (Module['wasmBinary']) wasmBinary = Module['wasmBinary'];\r\nvar noExitRuntime = Module['noExitRuntime'] || true;\r\n\r\nif (typeof WebAssembly != 'object') {\r\n abort('no native wasm support detected');\r\n}\r\n\r\n// Wasm globals\r\n\r\nvar wasmMemory;\r\n\r\n//========================================\r\n// Runtime essentials\r\n//========================================\r\n\r\n// whether we are quitting the application. no code should run after this.\r\n// set in exit() and abort()\r\nvar ABORT = false;\r\n\r\n// set by exit() and abort(). Passed to 'onExit' handler.\r\n// NOTE: This is also used as the process return code code in shell environments\r\n// but only when noExitRuntime is false.\r\nvar EXITSTATUS;\r\n\r\n/** @type {function(*, string=)} */\r\nfunction assert(condition, text) {\r\n if (!condition) {\r\n // This build was created without ASSERTIONS defined. `assert()` should not\r\n // ever be called in this configuration but in case there are callers in\r\n // the wild leave this simple abort() implemenation here for now.\r\n abort(text);\r\n }\r\n}\r\n\r\n// Memory management\r\n\r\nvar HEAP,\r\n/** @type {!Int8Array} */\r\n HEAP8,\r\n/** @type {!Uint8Array} */\r\n HEAPU8,\r\n/** @type {!Int16Array} */\r\n HEAP16,\r\n/** @type {!Uint16Array} */\r\n HEAPU16,\r\n/** @type {!Int32Array} */\r\n HEAP32,\r\n/** @type {!Uint32Array} */\r\n HEAPU32,\r\n/** @type {!Float32Array} */\r\n HEAPF32,\r\n/** @type {!Float64Array} */\r\n HEAPF64;\r\n\r\nfunction updateMemoryViews() {\r\n var b = wasmMemory.buffer;\r\n Module['HEAP8'] = HEAP8 = new Int8Array(b);\r\n Module['HEAP16'] = HEAP16 = new Int16Array(b);\r\n Module['HEAP32'] = HEAP32 = new Int32Array(b);\r\n Module['HEAPU8'] = HEAPU8 = new Uint8Array(b);\r\n Module['HEAPU16'] = HEAPU16 = new Uint16Array(b);\r\n Module['HEAPU32'] = HEAPU32 = new Uint32Array(b);\r\n Module['HEAPF32'] = HEAPF32 = new Float32Array(b);\r\n Module['HEAPF64'] = HEAPF64 = new Float64Array(b);\r\n}\r\n\r\n// include: runtime_init_table.js\r\n// In regular non-RELOCATABLE mode the table is exported\r\n// from the wasm module and this will be assigned once\r\n// the exports are available.\r\nvar wasmTable;\r\n\r\n// end include: runtime_init_table.js\r\n// include: runtime_stack_check.js\r\n// end include: runtime_stack_check.js\r\n// include: runtime_assertions.js\r\n// end include: runtime_assertions.js\r\nvar __ATPRERUN__ = []; // functions called before the runtime is initialized\r\nvar __ATINIT__ = []; // functions called during startup\r\nvar __ATEXIT__ = []; // functions called during shutdown\r\nvar __ATPOSTRUN__ = []; // functions called after the main() is called\r\n\r\nvar runtimeInitialized = false;\r\n\r\nvar runtimeKeepaliveCounter = 0;\r\n\r\nfunction keepRuntimeAlive() {\r\n return noExitRuntime || runtimeKeepaliveCounter > 0;\r\n}\r\n\r\nfunction preRun() {\r\n if (Module['preRun']) {\r\n if (typeof Module['preRun'] == 'function') Module['preRun'] = [Module['preRun']];\r\n while (Module['preRun'].length) {\r\n addOnPreRun(Module['preRun'].shift());\r\n }\r\n }\r\n callRuntimeCallbacks(__ATPRERUN__);\r\n}\r\n\r\nfunction initRuntime() {\r\n runtimeInitialized = true;\r\n\r\n \r\n callRuntimeCallbacks(__ATINIT__);\r\n}\r\n\r\nfunction postRun() {\r\n\r\n if (Module['postRun']) {\r\n if (typeof Module['postRun'] == 'function') Module['postRun'] = [Module['postRun']];\r\n while (Module['postRun'].length) {\r\n addOnPostRun(Module['postRun'].shift());\r\n }\r\n }\r\n\r\n callRuntimeCallbacks(__ATPOSTRUN__);\r\n}\r\n\r\nfunction addOnPreRun(cb) {\r\n __ATPRERUN__.unshift(cb);\r\n}\r\n\r\nfunction addOnInit(cb) {\r\n __ATINIT__.unshift(cb);\r\n}\r\n\r\nfunction addOnExit(cb) {\r\n}\r\n\r\nfunction addOnPostRun(cb) {\r\n __ATPOSTRUN__.unshift(cb);\r\n}\r\n\r\n// include: runtime_math.js\r\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/imul\r\n\r\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/fround\r\n\r\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32\r\n\r\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/trunc\r\n\r\n// end include: runtime_math.js\r\n// A counter of dependencies for calling run(). If we need to\r\n// do asynchronous work before running, increment this and\r\n// decrement it. Incrementing must happen in a place like\r\n// Module.preRun (used by emcc to add file preloading).\r\n// Note that you can add dependencies in preRun, even though\r\n// it happens right before run - run will be postponed until\r\n// the dependencies are met.\r\nvar runDependencies = 0;\r\nvar runDependencyWatcher = null;\r\nvar dependenciesFulfilled = null; // overridden to take different actions when all run dependencies are fulfilled\r\n\r\nfunction getUniqueRunDependency(id) {\r\n return id;\r\n}\r\n\r\nfunction addRunDependency(id) {\r\n runDependencies++;\r\n\r\n if (Module['monitorRunDependencies']) {\r\n Module['monitorRunDependencies'](runDependencies);\r\n }\r\n\r\n}\r\n\r\nfunction removeRunDependency(id) {\r\n runDependencies--;\r\n\r\n if (Module['monitorRunDependencies']) {\r\n Module['monitorRunDependencies'](runDependencies);\r\n }\r\n\r\n if (runDependencies == 0) {\r\n if (runDependencyWatcher !== null) {\r\n clearInterval(runDependencyWatcher);\r\n runDependencyWatcher = null;\r\n }\r\n if (dependenciesFulfilled) {\r\n var callback = dependenciesFulfilled;\r\n dependenciesFulfilled = null;\r\n callback(); // can add another dependenciesFulfilled\r\n }\r\n }\r\n}\r\n\r\n/** @param {string|number=} what */\r\nfunction abort(what) {\r\n if (Module['onAbort']) {\r\n Module['onAbort'](what);\r\n }\r\n\r\n what = 'Aborted(' + what + ')';\r\n // TODO(sbc): Should we remove printing and leave it up to whoever\r\n // catches the exception?\r\n err(what);\r\n\r\n ABORT = true;\r\n EXITSTATUS = 1;\r\n\r\n what += '. Build with -sASSERTIONS for more info.';\r\n\r\n // Use a wasm runtime error, because a JS error might be seen as a foreign\r\n // exception, which means we'd run destructors on it. We need the error to\r\n // simply make the program stop.\r\n // FIXME This approach does not work in Wasm EH because it currently does not assume\r\n // all RuntimeErrors are from traps; it decides whether a RuntimeError is from\r\n // a trap or not based on a hidden field within the object. So at the moment\r\n // we don't have a way of throwing a wasm trap from JS. TODO Make a JS API that\r\n // allows this in the wasm spec.\r\n\r\n // Suppress closure compiler warning here. Closure compiler's builtin extern\r\n // defintion for WebAssembly.RuntimeError claims it takes no arguments even\r\n // though it can.\r\n // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure gets fixed.\r\n /** @suppress {checkTypes} */\r\n var e = new WebAssembly.RuntimeError(what);\r\n\r\n readyPromiseReject(e);\r\n // Throw the error whether or not MODULARIZE is set because abort is used\r\n // in code paths apart from instantiation where an exception is expected\r\n // to be thrown when abort is called.\r\n throw e;\r\n}\r\n\r\n// include: memoryprofiler.js\r\n// end include: memoryprofiler.js\r\n// include: URIUtils.js\r\n// Prefix of data URIs emitted by SINGLE_FILE and related options.\r\nvar dataURIPrefix = 'data:application/octet-stream;base64,';\r\n\r\n// Indicates whether filename is a base64 data URI.\r\nfunction isDataURI(filename) {\r\n // Prefix of data URIs emitted by SINGLE_FILE and related options.\r\n return filename.startsWith(dataURIPrefix);\r\n}\r\n\r\n// Indicates whether filename is delivered via file protocol (as opposed to http/https)\r\nfunction isFileURI(filename) {\r\n return filename.startsWith('file://');\r\n}\r\n\r\n// end include: URIUtils.js\r\n// include: runtime_exceptions.js\r\n// end include: runtime_exceptions.js\r\nvar wasmBinaryFile;\r\n wasmBinaryFile = 'wasmDbscan.wasm';\r\n if (!isDataURI(wasmBinaryFile)) {\r\n wasmBinaryFile = locateFile(wasmBinaryFile);\r\n }\r\n\r\nfunction getBinary(file) {\r\n try {\r\n if (file == wasmBinaryFile && wasmBinary) {\r\n return new Uint8Array(wasmBinary);\r\n }\r\n if (readBinary) {\r\n return readBinary(file);\r\n }\r\n throw \"both async and sync fetching of the wasm failed\";\r\n }\r\n catch (err) {\r\n abort(err);\r\n }\r\n}\r\n\r\nfunction getBinaryPromise(binaryFile) {\r\n // If we don't have the binary yet, try to load it asynchronously.\r\n // Fetch has some additional restrictions over XHR, like it can't be used on a file:// url.\r\n // See https://github.com/github/fetch/pull/92#issuecomment-140665932\r\n // Cordova or Electron apps are typically loaded from a file:// url.\r\n // So use fetch if it is available and the url is not a file, otherwise fall back to XHR.\r\n if (!wasmBinary && (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER)) {\r\n if (typeof fetch == 'function'\r\n ) {\r\n return fetch(binaryFile, { credentials: 'same-origin' }).then(function(response) {\r\n if (!response['ok']) {\r\n throw \"failed to load wasm binary file at '\" + binaryFile + \"'\";\r\n }\r\n return response['arrayBuffer']();\r\n }).catch(function () {\r\n return getBinary(binaryFile);\r\n });\r\n }\r\n }\r\n\r\n // Otherwise, getBinary should be able to get it synchronously\r\n return Promise.resolve().then(function() { return getBinary(binaryFile); });\r\n}\r\n\r\nfunction instantiateArrayBuffer(binaryFile, imports, receiver) {\r\n return getBinaryPromise(binaryFile).then(function(binary) {\r\n return WebAssembly.instantiate(binary, imports);\r\n }).then(function (instance) {\r\n return instance;\r\n }).then(receiver, function(reason) {\r\n err('failed to asynchronously prepare wasm: ' + reason);\r\n\r\n abort(reason);\r\n });\r\n}\r\n\r\nfunction instantiateAsync(binary, binaryFile, imports, callback) {\r\n if (!binary &&\r\n typeof WebAssembly.instantiateStreaming == 'function' &&\r\n !isDataURI(binaryFile) &&\r\n typeof fetch == 'function') {\r\n return fetch(binaryFile, { credentials: 'same-origin' }).then(function(response) {\r\n // Suppress closure warning here since the upstream definition for\r\n // instantiateStreaming only allows Promise<Repsponse> rather than\r\n // an actual Response.\r\n // TODO(https://github.com/google/closure-compiler/pull/3913): Remove if/when upstream closure is fixed.\r\n /** @suppress {checkTypes} */\r\n var result = WebAssembly.instantiateStreaming(response, imports);\r\n\r\n return result.then(\r\n callback,\r\n function(reason) {\r\n // We expect the most common failure cause to be a bad MIME type for the binary,\r\n // in which case falling back to ArrayBuffer instantiation should work.\r\n err('wasm streaming compile failed: ' + reason);\r\n err('falling back to ArrayBuffer instantiation');\r\n return instantiateArrayBuffer(binaryFile, imports, callback);\r\n });\r\n });\r\n } else {\r\n return instantiateArrayBuffer(binaryFile, imports, callback);\r\n }\r\n}\r\n\r\n// Create the wasm instance.\r\n// Receives the wasm imports, returns the exports.\r\nfunction createWasm() {\r\n // prepare imports\r\n var info = {\r\n 'env': wasmImports,\r\n 'wasi_snapshot_preview1': wasmImports,\r\n };\r\n // Load the wasm module and create an instance of using native support in the JS engine.\r\n // handle a generated wasm instance, receiving its exports and\r\n // performing other necessary setup\r\n /** @param {WebAssembly.Module=} module*/\r\n function receiveInstance(instance, module) {\r\n var exports = instance.exports;\r\n\r\n Module['asm'] = exports;\r\n\r\n wasmMemory = Module['asm']['memory'];\r\n updateMemoryViews();\r\n\r\n wasmTable = Module['asm']['__indirect_function_table'];\r\n\r\n addOnInit(Module['asm']['__wasm_call_ctors']);\r\n\r\n removeRunDependency('wasm-instantiate');\r\n\r\n return exports;\r\n }\r\n // wait for the pthread pool (if any)\r\n addRunDependency('wasm-instantiate');\r\n\r\n // Prefer streaming instantiation if available.\r\n function receiveInstantiationResult(result) {\r\n // 'result' is a ResultObject object which has both the module and instance.\r\n // receiveInstance() will swap in the exports (to Module.asm) so they can be called\r\n // TODO: Due to Closure regression https://github.com/google/closure-compiler/issues/3193, the above line no longer optimizes out down to the following line.\r\n // When the regression is fixed, can restore the above PTHREADS-enabled path.\r\n receiveInstance(result['instance']);\r\n }\r\n\r\n // User shell pages can write their own Module.instantiateWasm = function(imports, successCallback) callback\r\n // to manually instantiate the Wasm module themselves. This allows pages to\r\n // run the instantiation parallel to any other async startup actions they are\r\n // performing.\r\n // Also pthreads and wasm workers initialize the wasm instance through this\r\n // path.\r\n if (Module['instantiateWasm']) {\r\n\r\n try {\r\n return Module['instantiateWasm'](info, receiveInstance);\r\n } catch(e) {\r\n err('Module.instantiateWasm callback failed with error: ' + e);\r\n // If instantiation fails, reject the module ready promise.\r\n readyPromiseReject(e);\r\n }\r\n }\r\n\r\n // If instantiation fails, reject the module ready promise.\r\n instantiateAsync(wasmBinary, wasmBinaryFile, info, receiveInstantiationResult).catch(readyPromiseReject);\r\n return {}; // no exports yet; we'll fill them in later\r\n}\r\n\r\n// Globals used by JS i64 conversions (see makeSetValue)\r\nvar tempDouble;\r\nvar tempI64;\r\n\r\n// include: runtime_debug.js\r\n// end include: runtime_debug.js\r\n// === Body ===\r\n\r\n\r\n// end include: preamble.js\r\n\r\n /** @constructor */\r\n function ExitStatus(status) {\r\n this.name = 'ExitStatus';\r\n this.message = 'Program terminated with exit(' + status + ')';\r\n this.status = status;\r\n }\r\n\r\n function callRuntimeCallbacks(callbacks) {\r\n while (callbacks.length > 0) {\r\n // Pass the module as the first argument.\r\n callbacks.shift()(Module);\r\n }\r\n }\r\n\r\n \r\n /**\r\n * @param {number} ptr\r\n * @param {string} type\r\n */\r\n function getValue(ptr, type = 'i8') {\r\n if (type.endsWith('*')) type = '*';\r\n switch (type) {\r\n case 'i1': return HEAP8[((ptr)>>0)];\r\n case 'i8': return HEAP8[((ptr)>>0)];\r\n case 'i16': return HEAP16[((ptr)>>1)];\r\n case 'i32': return HEAP32[((ptr)>>2)];\r\n case 'i64': return HEAP32[((ptr)>>2)];\r\n case 'float': return HEAPF32[((ptr)>>2)];\r\n case 'double': return HEAPF64[((ptr)>>3)];\r\n case '*': return HEAPU32[((ptr)>>2)];\r\n default: abort('invalid type for getValue: ' + type);\r\n }\r\n }\r\n\r\n \r\n /**\r\n * @param {number} ptr\r\n * @param {number} value\r\n * @param {string} type\r\n */\r\n function setValue(ptr, value, type = 'i8') {\r\n if (type.endsWith('*')) type = '*';\r\n switch (type) {\r\n case 'i1': HEAP8[((ptr)>>0)] = value; break;\r\n case 'i8': HEAP8[((ptr)>>0)] = value; break;\r\n case 'i16': HEAP16[((ptr)>>1)] = value; break;\r\n case 'i32': HEAP32[((ptr)>>2)] = value; break;\r\n case 'i64': (tempI64 = [value>>>0,(tempDouble=value,(+(Math.abs(tempDouble))) >= 1.0 ? (tempDouble > 0.0 ? ((Math.min((+(Math.floor((tempDouble)/4294967296.0))), 4294967295.0))|0)>>>0 : (~~((+(Math.ceil((tempDouble - +(((~~(tempDouble)))>>>0))/4294967296.0)))))>>>0) : 0)],HEAP32[((ptr)>>2)] = tempI64[0],HEAP32[(((ptr)+(4))>>2)] = tempI64[1]); break;\r\n case 'float': HEAPF32[((ptr)>>2)] = value; break;\r\n case 'double': HEAPF64[((ptr)>>3)] = value; break;\r\n case '*': HEAPU32[((ptr)>>2)] = value; break;\r\n default: abort('invalid type for setValue: ' + type);\r\n }\r\n }\r\n\r\n /** @constructor */\r\n function ExceptionInfo(excPtr) {\r\n this.excPtr = excPtr;\r\n this.ptr = excPtr - 24;\r\n \r\n this.set_type = function(type) {\r\n HEAPU32[(((this.ptr)+(4))>>2)] = type;\r\n };\r\n \r\n this.get_type = function() {\r\n return HEAPU32[(((this.ptr)+(4))>>2)];\r\n };\r\n \r\n this.set_destructor = function(destructor) {\r\n HEAPU32[(((this.ptr)+(8))>>2)] = destructor;\r\n };\r\n \r\n this.get_destructor = function() {\r\n return HEAPU32[(((this.ptr)+(8))>>2)];\r\n };\r\n \r\n this.set_caught = function (caught) {\r\n caught = caught ? 1 : 0;\r\n HEAP8[(((this.ptr)+(12))>>0)] = caught;\r\n };\r\n \r\n this.get_caught = function () {\r\n return HEAP8[(((this.ptr)+(12))>>0)] != 0;\r\n };\r\n \r\n this.set_rethrown = function (rethrown) {\r\n rethrown = rethrown ? 1 : 0;\r\n HEAP8[(((this.ptr)+(13))>>0)] = rethrown;\r\n };\r\n \r\n this.get_rethrown = function () {\r\n return HEAP8[(((this.ptr)+(13))>>0)] != 0;\r\n };\r\n \r\n // Initialize native structure fields. Should be called once after allocated.\r\n this.init = function(type, destructor) {\r\n this.set_adjusted_ptr(0);\r\n this.set_type(type);\r\n this.set_destructor(destructor);\r\n }\r\n \r\n this.set_adjusted_ptr = function(adjustedPtr) {\r\n HEAPU32[(((this.ptr)+(16))>>2)] = adjustedPtr;\r\n };\r\n \r\n this.get_adjusted_ptr = function() {\r\n return HEAPU32[(((this.ptr)+(16))>>2)];\r\n };\r\n \r\n // Get pointer which is expected to be received by catch clause in C++ code. It may be adjusted\r\n // when the pointer is casted to some of the exception object base classes (e.g. when virtual\r\n // inheritance is used). When a pointer is thrown this method should return the thrown pointer\r\n // itself.\r\n this.get_exception_ptr = function() {\r\n // Work around a fastcomp bug, this code is still included for some reason in a build without\r\n // exceptions support.\r\n var isPointer = ___cxa_is_pointer_type(this.get_type());\r\n if (isPointer) {\r\n return HEAPU32[((this.excPtr)>>2)];\r\n }\r\n var adjusted = this.get_adjusted_ptr();\r\n if (adjusted !== 0) return adjusted;\r\n return this.excPtr;\r\n };\r\n }\r\n \r\n var exceptionLast = 0;\r\n \r\n var uncaughtExceptionCount = 0;\r\n function ___cxa_throw(ptr, type, destructor) {\r\n var info = new ExceptionInfo(ptr);\r\n // Initialize ExceptionInfo content after it was allocated in __cxa_allocate_exception.\r\n info.init(type, destructor);\r\n exceptionLast = ptr;\r\n uncaughtExceptionCount++;\r\n throw exceptionLast;\r\n }\r\n\r\n function _abort() {\r\n abort('');\r\n }\r\n\r\n function _emscripten_memcpy_big(dest, src, num) {\r\n HEAPU8.copyWithin(dest, src, src + num);\r\n }\r\n\r\n function getHeapMax() {\r\n // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate\r\n // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side\r\n // for any code that deals with heap sizes, which would require special\r\n // casing all heap size related code to treat 0 specially.\r\n return 2147483648;\r\n }\r\n \r\n function emscripten_realloc_buffer(size) {\r\n var b = wasmMemory.buffer;\r\n try {\r\n // round size grow request up to wasm page size (fixed 64KB per spec)\r\n wasmMemory.grow((size - b.byteLength + 65535) >>> 16); // .grow() takes a delta compared to the previous size\r\n updateMemoryViews();\r\n return 1 /*success*/;\r\n } catch(e) {\r\n }\r\n // implicit 0 return to save code size (caller will cast \"undefined\" into 0\r\n // anyhow)\r\n }\r\n function _emscripten_resize_heap(requestedSize) {\r\n var oldSize = HEAPU8.length;\r\n requestedSize = requestedSize >>> 0;\r\n // With multithreaded builds, races can happen (another thread might increase the size\r\n // in between), so return a failure, and let the caller retry.\r\n \r\n // Memory resize rules:\r\n // 1. Always increase heap size to at least the requested size, rounded up\r\n // to next page multiple.\r\n // 2a. If MEMORY_GROWTH_LINEAR_STEP == -1, excessively resize the heap\r\n // geometrically: increase the heap size according to\r\n // MEMORY_GROWTH_GEOMETRIC_STEP factor (default +20%), At most\r\n // overreserve by MEMORY_GROWTH_GEOMETRIC_CAP bytes (default 96MB).\r\n // 2b. If MEMORY_GROWTH_LINEAR_STEP != -1, excessively resize the heap\r\n // linearly: increase the heap size by at least\r\n // MEMORY_GROWTH_LINEAR_STEP bytes.\r\n // 3. Max size for the heap is capped at 2048MB-WASM_PAGE_SIZE, or by\r\n // MAXIMUM_MEMORY, or by ASAN limit, depending on which is smallest\r\n // 4. If we were unable to allocate as much memory, it may be due to\r\n // over-eager decision to excessively reserve due to (3) above.\r\n // Hence if an allocation fails, cut down on the amount of excess\r\n // growth, in an attempt to succeed to perform a smaller allocation.\r\n \r\n // A limit is set for how much we can grow. We should not exceed that\r\n // (the wasm binary specifies it, so if we tried, we'd fail anyhow).\r\n var maxHeapSize = getHeapMax();\r\n if (requestedSize > maxHeapSize) {\r\n return false;\r\n }\r\n \r\n let alignUp = (x, multiple) => x + (multiple - x % multiple) % multiple;\r\n \r\n // Loop through potential heap size increases. If we attempt a too eager\r\n // reservation that fails, cut down on the attempted size and reserve a\r\n // smaller bump instead. (max 3 times, chosen somewhat arbitrarily)\r\n for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {\r\n var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown); // ensure geometric growth\r\n // but limit overreserving (default to capping at +96MB overgrowth at most)\r\n overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296 );\r\n \r\n var newSize = Math.min(maxHeapSize, alignUp(Math.max(requestedSize, overGrownHeapSize), 65536));\r\n \r\n var replacement = emscripten_realloc_buffer(newSize);\r\n if (replacement) {\r\n \r\n return true;\r\n }\r\n }\r\n return false;\r\n }\r\n\r\n function getCFunc(ident) {\r\n var func = Module['_' + ident]; // closure exported function\r\n return func;\r\n }\r\n \r\n \r\n function writeArrayToMemory(array, buffer) {\r\n HEAP8.set(array, buffer);\r\n }\r\n \r\n function lengthBytesUTF8(str) {\r\n var len = 0;\r\n for (var i = 0; i < str.length; ++i) {\r\n // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code\r\n // unit, not a Unicode code point of the character! So decode\r\n // UTF16->UTF32->UTF8.\r\n // See http://unicode.org/faq/utf_bom.html#utf16-3\r\n var c = str.charCodeAt(i); // possibly a lead surrogate\r\n if (c <= 0x7F) {\r\n len++;\r\n } else if (c <= 0x7FF) {\r\n len += 2;\r\n } else if (c >= 0xD800 && c <= 0xDFFF) {\r\n len += 4; ++i;\r\n } else {\r\n len += 3;\r\n }\r\n }\r\n return len;\r\n }\r\n \r\n function stringToUTF8Array(str, heap, outIdx, maxBytesToWrite) {\r\n // Parameter maxBytesToWrite is not optional. Negative values, 0, null,\r\n // undefined and false each don't write out any bytes.\r\n if (!(maxBytesToWrite > 0))\r\n return 0;\r\n \r\n var startIdx = outIdx;\r\n var endIdx = outIdx + maxBytesToWrite - 1; // -1 for string null terminator.\r\n for (var i = 0; i < str.length; ++i) {\r\n // Gotcha: charCodeAt returns a 16-bit word that is a UTF-16 encoded code\r\n // unit, not a Unicode code point of the character! So decode\r\n // UTF16->UTF32->UTF8.\r\n // See http://unicode.org/faq/utf_bom.html#utf16-3\r\n // For UTF8 byte structure, see http://en.wikipedia.org/wiki/UTF-8#Description\r\n // and https://www.ietf.org/rfc/rfc2279.txt\r\n // and https://tools.ietf.org/html/rfc3629\r\n var u = str.charCodeAt(i); // possibly a lead surrogate\r\n if (u >= 0xD800 && u <= 0xDFFF) {\r\n var u1 = str.charCodeAt(++i);\r\n u = 0x10000 + ((u & 0x3FF) << 10) | (u1 & 0x3FF);\r\n }\r\n if (u <= 0x7F) {\r\n if (outIdx >= endIdx) break;\r\n heap[outIdx++] = u;\r\n } else if (u <= 0x7FF) {\r\n if (outIdx + 1 >= endIdx) break;\r\n heap[outIdx++] = 0xC0 | (u >> 6);\r\n heap[outIdx++] = 0x80 | (u & 63);\r\n } else if (u <= 0xFFFF) {\r\n if (outIdx + 2 >= endIdx) break;\r\n heap[outIdx++] = 0xE0 | (u >> 12);\r\n heap[outIdx++] = 0x80 | ((u >> 6) & 63);\r\n heap[outIdx++] = 0x80 | (u & 63);\r\n } else {\r\n if (outIdx + 3 >= endIdx) break;\r\n heap[outIdx++] = 0xF0 | (u >> 18);\r\n heap[outIdx++] = 0x80 | ((u >> 12) & 63);\r\n heap[outIdx++] = 0x80 | ((u >> 6) & 63);\r\n heap[outIdx++] = 0x80 | (u & 63);\r\n }\r\n }\r\n // Null-terminate the pointer to the buffer.\r\n heap[outIdx] = 0;\r\n return outIdx - startIdx;\r\n }\r\n function stringToUTF8(str, outPtr, maxBytesToWrite) {\r\n return stringToUTF8Array(str, HEAPU8,outPtr, maxBytesToWrite);\r\n }\r\n function stringToUTF8OnStack(str) {\r\n var size = lengthBytesUTF8(str) + 1;\r\n var ret = stackAlloc(size);\r\n stringToUTF8(str, ret, size);\r\n return ret;\r\n }\r\n \r\n var UTF8Decoder = typeof TextDecoder != 'undefined' ? new TextDecoder('utf8') : undefined;\r\n \r\n /**\r\n * Given a pointer 'idx' to a null-terminated UTF8-encoded string in the given\r\n * array that contains uint8 values, returns a copy of that string as a\r\n * Javascript String object.\r\n * heapOrArray is either a regular array, or a JavaScript typed array view.\r\n * @param {number} idx\r\n * @param {number=} maxBytesToRead\r\n * @return {string}\r\n */\r\n function UTF8ArrayToString(heapOrArray, idx, maxBytesToRead) {\r\n var endIdx = idx + maxBytesToRead;\r\n var endPtr = idx;\r\n // TextDecoder needs to know the byte length in advance, it doesn't stop on\r\n // null terminator by itself. Also, use the length info to avoid running tiny\r\n // strings through TextDecoder, since .subarray() allocates garbage.\r\n // (As a tiny code save trick, compare endPtr against endIdx using a negation,\r\n // so that undefined means Infinity)\r\n while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;\r\n \r\n if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {\r\n return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));\r\n }\r\n var str = '';\r\n // If building with TextDecoder, we have already computed the string length\r\n // above, so test loop end condition against that\r\n while (idx < endPtr) {\r\n // For UTF8 byte structure, see:\r\n // http://en.wikipedia.org/wiki/UTF-8#Description\r\n // https://www.ietf.org/rfc/rfc2279.txt\r\n // https://tools.ietf.org/html/rfc3629\r\n var u0 = heapOrArray[idx++];\r\n if (!(u0 & 0x80)) { str += String.fromCharCode(u0); continue; }\r\n var u1 = heapOrArray[idx++] & 63;\r\n if ((u0 & 0xE0) == 0xC0) { str += String.fromCharCode(((u0 & 31) << 6) | u1); continue; }\r\n var u2 = heapOrArray[idx++] & 63;\r\n if ((u0 & 0xF0) == 0xE0) {\r\n u0 = ((u0 & 15) << 12) | (u1 << 6) | u2;\r\n } else {\r\n u0 = ((u0 & 7) << 18) | (u1 << 12) | (u2 << 6) | (heapOrArray[idx++] & 63);\r\n }\r\n \r\n if (u0 < 0x10000) {\r\n str += String.fromCharCode(u0);\r\n } else {\r\n var ch = u0 - 0x10000;\r\n str += String.fromCharCode(0xD800 | (ch >> 10), 0xDC00 | (ch & 0x3FF));\r\n }\r\n }\r\n return str;\r\n }\r\n \r\n \r\n /**\r\n * Given a pointer 'ptr' to a null-terminated UTF8-encoded string in the\r\n * emscripten HEAP, returns a copy of that string as a Javascript String object.\r\n *\r\n * @param {number} ptr\r\n * @param {number=} maxBytesToRead - An optional length that specifies the\r\n * maximum number of bytes to read. You can omit this parameter to scan the\r\n * string until the first \u0000 byte. If maxBytesToRead is passed, and the string\r\n * at [ptr, ptr+maxBytesToReadr[ contains a null byte in the middle, then the\r\n * string will cut short at that byte index (i.e. maxBytesToRead will not\r\n * produce a string of exact length [ptr, ptr+maxBytesToRead[) N.B. mixing\r\n * frequent uses of UTF8ToString() with and without maxBytesToRead may throw\r\n * JS JIT optimizations off, so it is worth to consider consistently using one\r\n * @return {string}\r\n */\r\n function UTF8ToString(ptr, maxBytesToRead) {\r\n return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : '';\r\n }\r\n \r\n /**\r\n * @param {string|null=} returnType\r\n * @param {Array=} argTypes\r\n * @param {Arguments|Array=} args\r\n * @param {Object=} opts\r\n */\r\n function ccall(ident, returnType, argTypes, args, opts) {\r\n // For fast lookup of conversion functions\r\n var toC = {\r\n 'string': (str) => {\r\n var ret = 0;\r\n if (str !== null && str !== undefined && str !== 0) { // null string\r\n // at most 4 bytes per UTF-8 code point, +1 for the trailing '\\0'\r\n ret = stringToUTF8OnStack(str);\r\n }\r\n return ret;\r\n },\r\n 'array': (arr) => {\r\n var ret = stackAlloc(arr.length);\r\n writeArrayToMemory(arr, ret);\r\n return ret;\r\n }\r\n };\r\n \r\n function convertReturnValue(ret) {\r\n if (returnType === 'string') {\r\n \r\n return UTF8ToString(ret);\r\n }\r\n if (returnType === 'boolean') return Boolean(ret);\r\n return ret;\r\n }\r\n \r\n var func = getCFunc(ident);\r\n var cArgs = [];\r\n var stack = 0;\r\n if (args) {\r\n for (var i = 0; i < args.length; i++) {\r\n var converter = toC[argTypes[i]];\r\n if (converter) {\r\n if (stack === 0) stack = stackSave();\r\n cArgs[i] = converter(args[i]);\r\n } else {\r\n cArgs[i] = args[i];\r\n }\r\n }\r\n }\r\n var ret = func.apply(null, cArgs);\r\n function onDone(ret) {\r\n if (stack !== 0) stackRestore(stack);\r\n return convertReturnValue(ret);\r\n }\r\n \r\n ret = onDone(ret);\r\n return ret;\r\n }\r\n \r\n /**\r\n * @param {string=} returnType\r\n * @param {Array=} argTypes\r\n * @param {Object=} opts\r\n */\r\n function cwrap(ident, returnType, argTypes, opts) {\r\n // When the function takes numbers and returns a number, we can just return\r\n // the original function\r\n var numericArgs = !argTypes || argTypes.every((type) => type === 'number' || type === 'boolean');\r\n var numericRet = returnType !== 'string';\r\n if (numericRet && numericArgs && !opts) {\r\n return getCFunc(ident);\r\n }\r\n return function() {\r\n return ccall(ident, returnType, argTypes, arguments, opts);\r\n }\r\n }\r\n\r\nvar wasmImports = {\r\n \"__cxa_throw\": ___cxa_throw,\r\n \"abort\": _abort,\r\n \"emscripten_memcpy_big\": _emscripten_memcpy_big,\r\n \"emscripten_resize_heap\": _emscripten_resize_heap\r\n};\r\nvar asm = createWasm();\r\n/** @type {function(...*):?} */\r\nvar ___wasm_call_ctors = function() {\r\n return (___wasm_call_ctors = Module[\"asm\"][\"__wasm_call_ctors\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar _dbscan = Module[\"_dbscan\"] = function() {\r\n return (_dbscan = Module[\"_dbscan\"] = Module[\"asm\"][\"dbscan\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar ___errno_location = function() {\r\n return (___errno_location = Module[\"asm\"][\"__errno_location\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar _malloc = Module[\"_malloc\"] = function() {\r\n return (_malloc = Module[\"_malloc\"] = Module[\"asm\"][\"malloc\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar _free = Module[\"_free\"] = function() {\r\n return (_free = Module[\"_free\"] = Module[\"asm\"][\"free\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar stackSave = function() {\r\n return (stackSave = Module[\"asm\"][\"stackSave\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar stackRestore = function() {\r\n return (stackRestore = Module[\"asm\"][\"stackRestore\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar stackAlloc = function() {\r\n return (stackAlloc = Module[\"asm\"][\"stackAlloc\"]).apply(null, arguments);\r\n};\r\n\r\n/** @type {function(...*):?} */\r\nvar ___cxa_is_pointer_type = function() {\r\n return (___cxa_is_pointer_type = Module[\"asm\"][\"__cxa_is_pointer_type\"]).apply(null, arguments);\r\n};\r\n\r\n\r\n\r\n// include: postamble.js\r\n// === Auto-generated postamble setup entry stuff ===\r\n\r\nModule[\"ccall\"] = ccall;\r\nModule[\"cwrap\"] = cwrap;\r\n\r\n\r\nvar calledRun;\r\n\r\ndependenciesFulfilled = function runCaller() {\r\n // If run has never been called, and we should call run (INVOKE_RUN is true, and Module.noInitialRun is not false)\r\n if (!calledRun) run();\r\n if (!calledRun) dependenciesFulfilled = runCaller; // try this again later, after new deps are fulfilled\r\n};\r\n\r\nfunction run() {\r\n\r\n if (runDependencies > 0) {\r\n return;\r\n }\r\n\r\n preRun();\r\n\r\n // a preRun added a dependency, run will be called later\r\n if (runDependencies > 0) {\r\n return;\r\n }\r\n\r\n function doRun() {\r\n // run may have just been called through dependencies being fulfilled just in this very frame,\r\n // or while the async setStatus time below was happening\r\n if (calledRun) return;\r\n calledRun = true;\r\n Module['calledRun'] = true;\r\n\r\n if (ABORT) return;\r\n\r\n initRuntime();\r\n\r\n readyPromiseResolve(Module);\r\n if (Module['onRuntimeInitialized']) Module['onRuntimeInitialized']();\r\n\r\n postRun();\r\n }\r\n\r\n if (Module['setStatus']) {\r\n Module['setStatus']('Running...');\r\n setTimeout(function() {\r\n setTimeout(function() {\r\n Module['setStatus']('');\r\n }, 1);\r\n doRun();\r\n }, 1);\r\n } else\r\n {\r\n doRun();\r\n }\r\n}\r\n\r\nif (Module['preInit']) {\r\n if (typeof Module['preInit'] == 'function') Module['preInit'] = [Module['preInit']];\r\n while (Module['preInit'].length > 0) {\r\n Module['preInit'].pop()();\r\n }\r\n}\r\n\r\nrun();\r\n\r\n\r\n// end include: postamble.js\r\n\r\n\r\n return exportCppDbscanLib.ready\r\n}\r\n\r\n);\r\n})();\r\nif (typeof exports === 'object' && typeof module === 'object')\r\n module.exports = exportCppDbscanLib;\r\nelse if (typeof define === 'function' && define['amd'])\r\n define([], function() { return exportCppDbscanLib; });\r\nelse if (typeof exports === 'object')\r\n exports[\"exportCppDbscanLib\"] = exportCppDbscanLib;\r\n","import { DistanceAggregationMethods } from './types';\nexport const isNil = (x) => x === null || x === undefined;\nexport function insertSmaller(distancesAr, indexes, num, index) {\n if (num > distancesAr[distancesAr.length - 1])\n return;\n const newPosition = distancesAr.findIndex((v) => num < v);\n distancesAr.pop();\n distancesAr.splice(newPosition, 0, num);\n indexes.pop();\n indexes.splice(newPosition, 0, index);\n}\nexport function insertLarger(distancesAr, indexes, num, index) {\n if (num < distancesAr[distancesAr.length - 1])\n return;\n const newPosition = distancesAr.findIndex((v) => num > v);\n distancesAr.pop();\n distancesAr.splice(newPosition, 0, num);\n indexes.pop();\n indexes.splice(newPosition, 0, index);\n}\nexport function getAggregationFunction(aggregationMethod, weights) {\n switch (aggregationMethod) {\n case DistanceAggregationMethods.MANHATTAN:\n return (vs) => vs.reduce((acc, val, idx) => acc + val * weights[idx], 0);\n default:\n return (vs) => {\n // euclidean\n const sum = vs.reduce((acc, val, idx) => acc + (val * weights[idx]) ** 2, 0);\n return Math.sqrt(sum);\n };\n }\n}\n//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJ1dGlscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQTRCLDBCQUEwQixFQUFDLE1BQU0sU0FBUyxDQUFDO0FBRTlFLE1BQU0sQ0FBQyxNQUFNLEtBQUssR0FBRyxDQUFDLENBQU0sRUFBRSxFQUFFLENBQUMsQ0FBQyxLQUFLLElBQUksSUFBSSxDQUFDLEtBQUssU0FBUyxDQUFDO0FBRS9ELE1BQU0sVUFBVSxhQUFhLENBQUMsV0FBcUIsRUFBRSxPQUFpQixFQUFFLEdBQVcsRUFBRSxLQUFhO0lBQ2hHLElBQUksR0FBRyxHQUFHLFdBQVcsQ0FBQyxXQUFXLENBQUMsTUFBTSxHQUFDLENBQUMsQ0FBQztRQUN6QyxPQUFPO0lBRVQsTUFBTSxXQUFXLEdBQUcsV0FBVyxDQUFDLFNBQVMsQ0FBQyxDQUFDLENBQUMsRUFBRSxFQUFFLENBQUMsR0FBRyxHQUFHLENBQUMsQ0FBQyxDQUFDO0lBQzFELFdBQVcsQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUNsQixXQUFXLENBQUMsTUFBTSxDQUFDLFdBQVcsRUFBRSxDQUFDLEVBQUUsR0FBRyxDQUFDLENBQUM7SUFDeEMsT0FBTyxDQUFDLEdBQUcsRUFBRSxDQUFDO0lBQ2QsT0FBTyxDQUFDLE1BQU0sQ0FBQyxXQUFXLEVBQUUsQ0FBQyxFQUFFLEtBQUssQ0FBQyxDQUFDO0FBQ3hDLENBQUM7QUFFRCxNQUFNLFVBQVUsWUFBWSxDQUFDLFdBQXFCLEVBQUUsT0FBaUIsRUFBRSxHQUFXLEVBQUUsS0FBYTtJQUMvRixJQUFJLEdBQUcsR0FBRyxXQUFXLENBQUMsV0FBVyxDQUFDLE1BQU0sR0FBQyxDQUFDLENBQUM7UUFDekMsT0FBTztJQUVULE1BQU0sV0FBVyxHQUFHLFdBQVcsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLEdBQUcsR0FBRyxDQUFDLENBQUMsQ0FBQztJQUMxRCxXQUFXLENBQUMsR0FBRyxFQUFFLENBQUM7SUFDbEIsV0FBVyxDQUFDLE1BQU0sQ0FBQyxXQUFXLEVBQUUsQ0FBQyxFQUFFLEdBQUcsQ0FBQyxDQUFDO0lBQ3hDLE9BQU8sQ0FBQyxHQUFHLEVBQUUsQ0FBQztJQUNkLE9BQU8sQ0FBQyxNQUFNLENBQUMsV0FBVyxFQUFFLENBQUMsRUFBRSxLQUFLLENBQUMsQ0FBQztBQUN4QyxDQUFDO0FBRUQsTUFBTSxVQUFVLHNCQUFzQixDQUNwQyxpQkFBNEMsRUFBRSxPQUFpQjtJQUUvRCxRQUFRLGlCQUFpQixFQUFFLENBQUM7UUFDMUIsS0FBSywwQkFBMEIsQ0FBQyxTQUFTO1lBQ3ZDLE9BQU8sQ0FBQyxFQUFZLEVBQUUsRUFBRSxDQUFDLEVBQUUsQ0FBQyxNQUFNLENBQUMsQ0FBQyxHQUFHLEVBQUUsR0FBRyxFQUFFLEdBQUcsRUFBRSxFQUFFLENBQUMsR0FBRyxHQUFHLEdBQUcsR0FBRyxPQUFPLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQyxDQUFDLENBQUM7UUFDckY7WUFDRSxPQUFPLENBQUMsRUFBWSxFQUFFLEVBQUU7Z0JBQ3RCLFlBQVk7Z0JBQ1osTUFBTSxHQUFHLEdBQUcsRUFBRSxDQUFDLE1BQU0sQ0FBQyxDQUFDLEdBQUcsRUFBRSxHQUFHLEVBQUUsR0FBRyxFQUFFLEVBQUUsQ0FBQyxHQUFHLEdBQUcsQ0FBQyxHQUFHLEdBQUcsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO2dCQUM3RSxPQUFPLElBQUksQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7WUFDeEIsQ0FBQyxDQUFDO0lBQ04sQ0FBQztBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0Rpc3RhbmNlQWdncmVnYXRpb25NZXRob2QsIERpc3RhbmNlQWdncmVnYXRpb25NZXRob2RzfSBmcm9tICcuL3R5cGVzJztcblxuZXhwb3J0IGNvbnN0IGlzTmlsID0gKHg6IGFueSkgPT4geCA9PT0gbnVsbCB8fCB4ID09PSB1bmRlZmluZWQ7XG5cbmV4cG9ydCBmdW5jdGlvbiBpbnNlcnRTbWFsbGVyKGRpc3RhbmNlc0FyOiBudW1iZXJbXSwgaW5kZXhlczogbnVtYmVyW10sIG51bTogbnVtYmVyLCBpbmRleDogbnVtYmVyKSB7XG4gIGlmIChudW0gPiBkaXN0YW5jZXNBcltkaXN0YW5jZXNBci5sZW5ndGgtMV0pXG4gICAgcmV0dXJuO1xuXG4gIGNvbnN0IG5ld1Bvc2l0aW9uID0gZGlzdGFuY2VzQXIuZmluZEluZGV4KCh2KSA9PiBudW0gPCB2KTtcbiAgZGlzdGFuY2VzQXIucG9wKCk7XG4gIGRpc3RhbmNlc0FyLnNwbGljZShuZXdQb3NpdGlvbiwgMCwgbnVtKTtcbiAgaW5kZXhlcy5wb3AoKTtcbiAgaW5kZXhlcy5zcGxpY2UobmV3UG9zaXRpb24sIDAsIGluZGV4KTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGluc2VydExhcmdlcihkaXN0YW5jZXNBcjogbnVtYmVyW10sIGluZGV4ZXM6IG51bWJlcltdLCBudW06IG51bWJlciwgaW5kZXg6IG51bWJlcikge1xuICBpZiAobnVtIDwgZGlzdGFuY2VzQXJbZGlzdGFuY2VzQXIubGVuZ3RoLTFdKVxuICAgIHJldHVybjtcblxuICBjb25zdCBuZXdQb3NpdGlvbiA9IGRpc3RhbmNlc0FyLmZpbmRJbmRleCgodikgPT4gbnVtID4gdik7XG4gIGRpc3RhbmNlc0FyLnBvcCgpO1xuICBkaXN0YW5jZXNBci5zcGxpY2UobmV3UG9zaXRpb24sIDAsIG51bSk7XG4gIGluZGV4ZXMucG9wKCk7XG4gIGluZGV4ZXMuc3BsaWNlKG5ld1Bvc2l0aW9uLCAwLCBpbmRleCk7XG59XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRBZ2dyZWdhdGlvbkZ1bmN0aW9uKFxuICBhZ2dyZWdhdGlvbk1ldGhvZDogRGlzdGFuY2VBZ2dyZWdhdGlvbk1ldGhvZCwgd2VpZ2h0czogbnVtYmVyW11cbik6ICh2YWx1ZXM6IG51bWJlcltdKSA9PiBudW1iZXIge1xuICBzd2l0Y2ggKGFnZ3JlZ2F0aW9uTWV0aG9kKSB7XG4gICAgY2FzZSBEaXN0YW5jZUFnZ3JlZ2F0aW9uTWV0aG9kcy5NQU5IQVRUQU46XG4gICAgICByZXR1cm4gKHZzOiBudW1iZXJbXSkgPT4gdnMucmVkdWNlKChhY2MsIHZhbCwgaWR4KSA9PiBhY2MgKyB2YWwgKiB3ZWlnaHRzW2lkeF0sIDApO1xuICAgIGRlZmF1bHQ6XG4gICAgICByZXR1cm4gKHZzOiBudW1iZXJbXSkgPT4ge1xuICAgICAgICAvLyBldWNsaWRlYW5cbiAgICAgICAgY29uc3Qgc3VtID0gdnMucmVkdWNlKChhY2MsIHZhbCwgaWR4KSA9PiBhY2MgKyAodmFsICogd2VpZ2h0c1tpZHhdKSAqKiAyLCAwKTtcbiAgICAgICAgcmV0dXJuIE1hdGguc3FydChzdW0pO1xuICAgICAgfTtcbiAgfVxufVxuIl19","/**\n * Denotes a vector of floating poit values.\n *\n * @export\n * @class Vector\n * @extends {Float32Array}\n */\nexport class Vector extends Float32Array {\n}\n/**\n * Denotes a two-dimensional matrix.\n *\n * @export\n * @class Matrix\n * @extends {Array<Vector>}\n */\nexport class Matrix extends Array {\n}\n/**\n * Denotes cartesian coordinates.\n *\n * @export\n * @class Coordinates\n * @extends {Matrix}\n */\nexport class Coordinates extends Matrix {\n}\n/**\n * Denotes an array of arbitrary-typed vectors.\n *\n * @export\n * @class Vectors\n * @extends {Array<any>}\n */\nexport class Vectors extends Array {\n}\n//# sourceMappingURL=data:application/json;base64,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","import { Vector } from './type-declarations';\nimport { randomFloat, randomInt } from './random';\n/**\n * Asserts a condition by throwing an Error.\n *\n * @export\n * @param {boolean} [condition=false] Condition to assert.\n * @param {string} [message='Assertion error.'] Message to output.\n * @throws {Error}\n */\nexport function assert(condition = false, message = 'Assertion error.') {\n if (!condition)\n throw new Error(message);\n}\n/**\n * Creates new two-dimensional array and fills it with the value given.\n *\n * @param {number} dimension1 The first dimension of the coordinates (number of rows).\n * @param {number} dimension2 The second dimension of the coordinates (number of columns).\n * @param {number} [fill=0] A value to fill the coordinates with.\n * @return {Coordinates} A two-dimensional filled with the value given.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function initCoordinates(dimension1, dimension2, fill = 0) {\n return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));\n}\n/**\n * Transpose matrix.\n *\n * @export\n * @param {Matrix} matrix The matrix to be transposed.\n * @return {Matrix} Transposed matrix.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function transposeMatrix(matrix) {\n return new Array(matrix[0].length).fill(0)\n .map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));\n}\n/**\n * Adds two vectors with the second one to be multiplied by the given ratio.\n *\n * @export\n * @param {Vector} p The first vector to add.\n * @param {Vector} q The second vector to add.\n * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.\n * @return {Vector} New vector contained the result of operation p+multiplier*q.\n */\nexport function vectorAdd(p, q, multiplier = 1) {\n const nItems = p.length;\n assert(nItems == q.length, 'Vector lengths do not match.');\n const total = new Vector(nItems);\n for (let i = 0; i < p.length; ++i)\n total[i] = p[i] + multiplier * q[i];\n return total;\n}\n/**\n * Sums the vector's items.\n *\n * @param {Vector} v The vector to be summed.\n * @return {number} The vector's items sum.\n */\nfunction itemsSum(v) {\n let total = 0;\n for (let i = 0; i < v.length; ++i)\n total += v[i];\n return total;\n}\n/**\n * Suqares the vector's items.\n *\n * @param {Vector} v The vector to square.\n * @return {Vector} A new vector containing the original's items squared.\n */\nfunction vectorSquare(v) {\n const nItems = v.length;\n const total = new Vector(nItems);\n for (let i = 0; i < v.length; ++i)\n total[i] = v[i] * v[i];\n return total;\n}\nexport function vectorLength(v) {\n let sqrSum = 0;\n for (let i = 0; i < v.length; i++)\n sqrSum += v[i] * v[i];\n return Math.sqrt(sqrSum);\n}\nexport function vectorDotProduct(v1, v2) {\n if (v1.length != v2.length)\n throw new Error('The dimensionality of the vectors must match');\n let prod = 0;\n for (let i = 0; i < v1.length; i++)\n prod += v1[i] * v2[i];\n return prod;\n}\n/**\n * Creates a matrix filled with random floating point values.\n *\n * @export\n * @param {number} dimension1 The first dimension of the matrix.\n * @param {number} dimension2 The second dimension of the matrix.\n * @param {number} [scale=1.] Max value given by random generator.\n * @return {Matrix} A new matrix filled with random floating point values.\n */\nexport function fillRandomMatrix(dimension1, dimension2, scale = 1.) {\n const matrix = initCoordinates(dimension1, dimension2);\n for (let i = 0; i < dimension1; ++i) {\n for (let j = 0; j < dimension2; ++j)\n matrix[i][j] = randomFloat(scale);\n }\n return matrix;\n}\n/**\n * Calculates Euclidean distance between two vectors.\n *\n * @export\n * @param {Vector} p The first vector.\n * @param {Vector} q The second vector.\n * @return {number} Euclidean distance between the given vectors.\n */\nexport function calculateEuclideanDistance(p, q) {\n let result = 0;\n const len = p.length;\n if (len !== q.length)\n throw new Error('The dimensionality of the vectors must match');\n for (let i = 0; i < len; ++i)\n result += Math.pow((p[i] - q[i]), 2);\n return Math.sqrt(result);\n}\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcDistanceMatrix(data, distance) {\n const nItems = data.length;\n const matrix = initCoordinates(nItems, nItems, 0);\n for (let i = 0; i < nItems; ++i) {\n for (let j = i + 1; j < nItems; ++j) {\n const d = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);\n matrix[i][j] = matrix[j][i] = d;\n }\n }\n return matrix;\n}\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcNormalizedDistanceMatrix(data, distance) {\n const nItems = data.length;\n const matrix = initCoordinates(nItems, nItems, 0);\n let max = Number.MIN_VALUE;\n let min = Number.MAX_VALUE;\n for (let i = 0; i < nItems; ++i) {\n for (let j = i; j < nItems; ++j) {\n const d = (data[i] == null) || (data[j] == null || i === j) ? 0 : distance(data[i], data[j]);\n matrix[i][j] = matrix[j][i] = d;\n if (d > max)\n max = d;\n if (d < min)\n min = d;\n }\n }\n for (let i = 0; i < nItems; ++i) {\n for (let j = i + 1; j < nItems; ++j)\n matrix[i][j] = matrix[j][i] = (matrix[i][j] - min) / (max - min);\n }\n return matrix;\n}\n/** Generates array from a range [begin; end] or [begin; end) if endExclusive. **/\nexport function genRange(begin, end, endExclusive = false) {\n const nItems = end - begin + (endExclusive ? 0 : 1);\n const series = new Int32Array(nItems);\n for (let i = 0; i < nItems; ++i)\n series[i] = begin + i;\n return series;\n}\n/**\n * Returns order of values as if they are sorted.\n *\n * @export\n * @param {any[]} values Input array.\n * @param {boolean} [reverse=false] Whether to return reversed order.\n * @return {number[]} The order computed.\n */\nexport function argSort(values, reverse = false) {\n const sortfn = reverse ? (a, b) => (b[0] - a[0]) : (a, b) => (a[0] - b[0]);\n const decor = (v, i) => [v, i]; // set index to value\n const undecor = (a) => a[1]; // leave only index\n const _argsort = (arr) => arr.map(decor).sort(sortfn).map(undecor);\n return _argsort(values);\n}\n/**\n * Returns the indexes of the most diverse objects according to the dist function\n * @param {number} length total number of objects\n * @param {number} n number of diverse elements to find\n * @param {(i1: number, i2: number) => number} dist a function which calculates distance between\n * two objects using their indexes\n * @returns {number[]} The indexes of the most diverse objects\n */\nexport function getDiverseSubset(length, n, dist) {\n function maxBy(values, orderBy) {\n let maxValue = null;\n let maxOrderBy = null;\n for (const element of values) {\n const elementOrderBy = orderBy(element);\n if (maxOrderBy == null || elementOrderBy > maxOrderBy) {\n maxValue = element;\n maxOrderBy = elementOrderBy;\n }\n }\n return maxValue;\n }\n const subset = [randomInt(length - 1)];\n const complement = new Set();\n for (let i = 0; i < length; ++i) {\n if (!subset.includes(i))\n complement.add(i);\n }\n while (subset.length < n) {\n const idx = maxBy(complement.values(), (i) => Math.min.apply(Math, subset.map(function (val, index) {\n return dist(i, val);\n })));\n if (idx) {\n subset.push(idx);\n complement.delete(idx);\n }\n }\n return subset;\n}\n/**\n * Returns normalized vector.\n *\n * @export\n * @param {Vector} data numerical array\n */\nexport function normalize(data) {\n const len = data.length;\n let sum = 0;\n let sumOfSquares = 0;\n for (let i = 0; i < len; ++i) {\n sum += data[i];\n sumOfSquares += Math.pow(data[i], 2);\n }\n const mean = sum / len;\n const stdDevInverse = 1.0 / Math.sqrt(sumOfSquares / len - Math.pow(mean, 2));\n for (let i = 0; i < len; ++i)\n data[i] = (data[i] - mean) * stdDevInverse;\n return data;\n}\n/**\n * Finds set difference between two lists.\n * @param {any[]} a The first list.\n * @param {any[]} b The second list.\n * @return {any[]}\n */\nexport function setDifference(a, b) {\n const bSet = new Set(b);\n return Array.from(new Set(a.filter((x) => !bSet.has(x))).values());\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vector-operations.js","sourceRoot":"","sources":["vector-operations.ts"],"names":[],"mappings":"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","sourcesContent":["import {Matrix, Vector, Coordinates, Vectors, DistanceMetric} from './type-declarations';\nimport {randomFloat, randomInt} from './random';\n\n/**\n * Asserts a condition by throwing an Error.\n *\n * @export\n * @param {boolean} [condition=false] Condition to assert.\n * @param {string} [message='Assertion error.'] Message to output.\n * @throws {Error}\n */\nexport function assert(condition: boolean = false, message: string = 'Assertion error.') {\n  if (!condition)\n    throw new Error(message);\n}\n\n/**\n * Creates new two-dimensional array and fills it with the value given.\n *\n * @param {number} dimension1 The first dimension of the coordinates (number of rows).\n * @param {number} dimension2 The second dimension of the coordinates (number of columns).\n * @param {number} [fill=0] A value to fill the coordinates with.\n * @return {Coordinates} A two-dimensional filled with the value given.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function initCoordinates(dimension1: number, dimension2: number, fill: number = 0): Coordinates {\n  return new Array(dimension1).fill(fill).map(() => (new Vector(dimension2).fill(fill)));\n}\n\n/**\n * Transpose matrix.\n *\n * @export\n * @param {Matrix} matrix The matrix to be transposed.\n * @return {Matrix} Transposed matrix.\n * @todo Might be slow since used Array.map. Probably needs performance revision.\n */\nexport function transposeMatrix(matrix: Matrix): Matrix {\n  return new Array(matrix[0].length).fill(0)\n    .map((_, i) => (new Vector(matrix.length).fill(0).map((_, j) => (matrix[j][i]))));\n}\n\n/**\n * Adds two vectors with the second one to be multiplied by the given ratio.\n *\n * @export\n * @param {Vector} p The first vector to add.\n * @param {Vector} q The second vector to add.\n * @param {number} [multiplier=1] A multiplier to be used before the second vector is added.\n * @return {Vector} New vector contained the result of operation p+multiplier*q.\n */\nexport function vectorAdd(p: Vector, q: Vector, multiplier: number = 1): Vector {\n  const nItems = p.length;\n\n  assert(nItems == q.length, 'Vector lengths do not match.');\n\n  const total = new Vector(nItems);\n\n  for (let i = 0; i < p.length; ++i)\n    total[i] = p[i] + multiplier * q[i];\n\n  return total;\n}\n\n/**\n * Sums the vector's items.\n *\n * @param {Vector} v The vector to be summed.\n * @return {number} The vector's items sum.\n */\nfunction itemsSum(v: Vector): number {\n  let total = 0;\n\n  for (let i = 0; i < v.length; ++i)\n    total += v[i];\n\n  return total;\n}\n\n/**\n * Suqares the vector's items.\n *\n * @param {Vector} v The vector to square.\n * @return {Vector} A new vector containing the original's items squared.\n */\nfunction vectorSquare(v: Vector): Vector {\n  const nItems = v.length;\n  const total = new Vector(nItems);\n\n  for (let i = 0; i < v.length; ++i)\n    total[i] = v[i] * v[i];\n\n  return total;\n}\n\nexport function vectorLength(v: Vector): number {\n  let sqrSum: number = 0;\n  for (let i: number = 0; i < v.length; i++)\n    sqrSum += v[i] * v[i];\n  return Math.sqrt(sqrSum);\n}\n\nexport function vectorDotProduct(v1: Vector, v2: Vector): number {\n  if (v1.length != v2.length)\n    throw new Error('The dimensionality of the vectors must match');\n  let prod: number = 0;\n  for (let i: number = 0; i < v1.length; i++)\n    prod += v1[i] * v2[i];\n  return prod;\n}\n\n/**\n * Creates a matrix filled with random floating point values.\n *\n * @export\n * @param {number} dimension1 The first dimension of the matrix.\n * @param {number} dimension2 The second dimension of the matrix.\n * @param {number} [scale=1.] Max value given by random generator.\n * @return {Matrix} A new matrix filled with random floating point  values.\n */\nexport function fillRandomMatrix(dimension1: number, dimension2: number, scale: number = 1.): Matrix {\n  const matrix = initCoordinates(dimension1, dimension2);\n\n  for (let i = 0; i < dimension1; ++i) {\n    for (let j = 0; j < dimension2; ++j)\n      matrix[i][j] = randomFloat(scale);\n  }\n  return matrix;\n}\n\n/**\n * Calculates Euclidean distance between two vectors.\n *\n * @export\n * @param {Vector} p The first vector.\n * @param {Vector} q The second vector.\n * @return {number} Euclidean distance between the given vectors.\n */\nexport function calculateEuclideanDistance(p: Vector, q: Vector): number {\n  let result = 0;\n  const len = p.length;\n\n  if (len !== q.length)\n    throw new Error('The dimensionality of the vectors must match');\n  \n  for (let i = 0; i < len; ++i)\n    result += (p[i] - q[i]) ** 2;\n  \n  return Math.sqrt(result);\n}\n\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix {\n  const nItems = data.length;\n  const matrix = initCoordinates(nItems, nItems, 0);\n\n  for (let i = 0; i < nItems; ++i) {\n    for (let j = i + 1; j < nItems; ++j) {\n      const d: number = (data[i] == null) || (data[j] == null) ? 0 : distance(data[i], data[j]);\n      matrix[i][j] = matrix[j][i] = d;\n    }\n  }\n  return matrix;\n}\n\n/**\n * Creates a distance matrix using a custom distance function.\n *\n * @export\n * @param {Vectors} data Input vectors to calculate distances.\n * @param {DistanceMetric} distance Custom distance function.\n * @return {Matrix} Calculated custom distance matrix.\n */\nexport function calcNormalizedDistanceMatrix(data: Vectors, distance: DistanceMetric): Matrix {\n  const nItems = data.length;\n  const matrix = initCoordinates(nItems, nItems, 0);\n  let max = Number.MIN_VALUE;\n  let min = Number.MAX_VALUE;\n  for (let i = 0; i < nItems; ++i) {\n    for (let j = i; j < nItems; ++j) {\n      const d: number = (data[i] == null) || (data[j] == null || i === j) ? 0 : distance(data[i], data[j]);\n      matrix[i][j] = matrix[j][i] = d;\n      if (d > max) max = d;\n      if (d < min) min = d;\n    }\n  }\n  for (let i = 0; i < nItems; ++i) {\n    for (let j = i + 1; j < nItems; ++j)\n      matrix[i][j] = matrix[j][i] = (matrix[i][j] - min) / (max - min);\n  }\n  return matrix;\n}\n\n/** Generates array from a range [begin; end] or [begin; end) if endExclusive. **/\nexport function genRange(begin: number, end: number, endExclusive = false): Int32Array {\n  const nItems = end - begin + (endExclusive ? 0 : 1);\n  const series = new Int32Array(nItems);\n\n  for (let i = 0; i < nItems; ++i)\n    series[i] = begin + i;\n\n  return series;\n}\n\n/**\n * Returns order of values as if they are sorted.\n *\n * @export\n * @param {any[]} values Input array.\n * @param {boolean} [reverse=false] Whether to return reversed order.\n * @return {number[]} The order computed.\n */\nexport function argSort(values: any[], reverse = false): number[] {\n  const sortfn = reverse ? (a: any[], b: any[]) => (b[0] - a[0]) : (a: any[], b: any[]) => (a[0] - b[0]);\n  const decor = (v: any, i: number) => [v, i]; // set index to value\n  const undecor = (a: any[]) => a[1]; // leave only index\n  const _argsort = (arr: any[]) => arr.map(decor).sort(sortfn).map(undecor);\n  return _argsort(values);\n}\n\n/**\n * Returns the indexes of the most diverse objects according to the dist function\n * @param {number} length total number of objects\n * @param {number} n number of diverse elements to find\n * @param {(i1: number, i2: number) => number} dist a function which calculates distance between\n *                                                  two objects using their indexes\n * @returns {number[]} The indexes of the most diverse objects\n */\nexport function getDiverseSubset(length: number, n: number, dist: (i1: number, i2: number) => number): number[] {\n  function maxBy(values: IterableIterator<number>, orderBy: (i: number) => number) {\n    let maxValue = null;\n    let maxOrderBy = null;\n\n    for (const element of values) {\n      const elementOrderBy = orderBy(element);\n      if (maxOrderBy == null || elementOrderBy > maxOrderBy) {\n        maxValue = element;\n        maxOrderBy = elementOrderBy;\n      }\n    }\n    return maxValue;\n  }\n\n  const subset = [randomInt(length - 1)];\n  const complement = new Set();\n\n  for (let i = 0; i < length; ++i) {\n    if (!subset.includes(i))\n      complement.add(i);\n  }\n\n  while (subset.length < n) {\n    const idx = maxBy(\n      complement.values() as IterableIterator<number>,\n      (i) => Math.min.apply(Math, subset.map(function(val, index) {\n        return dist(i, val);\n      })));\n    if (idx) {\n      subset.push(idx);\n      complement.delete(idx);\n    }\n  }\n  return subset;\n}\n\n/**\n * Returns normalized vector.\n * \n * @export\n * @param {Vector} data numerical array\n */\nexport function normalize(data: Vector): Vector {\n  const len = data.length;\n  let sum = 0;\n  let sumOfSquares = 0;\n\n  for (let i = 0; i < len; ++i) {\n    sum += data[i];\n    sumOfSquares += data[i] ** 2;\n  }\n\n  const mean = sum / len;\n  const stdDevInverse = 1.0 / Math.sqrt(sumOfSquares / len - mean ** 2);\n\n  for (let i = 0; i < len; ++i)\n    data[i] = (data[i] - mean) * stdDevInverse;\n\n  return data;\n}\n\n/**\n * Finds set difference between two lists.\n * @param {any[]} a The first list.\n * @param {any[]} b The second list.\n * @return {any[]}\n */\nexport function setDifference(a: any[], b: any[]): any[] {\n  const bSet = new Set(b);\n  return Array.from(new Set(a.filter((x) => !bSet.has(x))).values());\n}\n"]}","import * as fl from 'fastest-levenshtein';\nimport { jaroWinkler } from 'jaro-winkler-typescript';\nimport { asymmetricDistance, braunBlanquetDistance, cosineDistance, diceDistance, euclideanDistance, hammingDistance, kulczynskiDistance, mcConnaugheyDistance, rogotGoldbergDistance, russelDistance, sokalDistance, tanimotoDistance, numericDistance, tanimotoDistanceIntArray, inverseCommonItemsCount, } from '../distance-metrics-methods';\nimport { calculateEuclideanDistance } from '@datagrok-libraries/utils/src/vector-operations';\nimport { mmDistanceFunctions, MmDistanceFunctionsNames } from '../macromolecule-distance-functions';\nimport { DistanceMetricsSubjects, BitArrayMetricsNames, StringMetricsNames, VectorMetricsNames, NumberMetricsNames, IntArrayMetricsNames, NumberArrayMetricsNames } from './consts';\nexport const vectorDistanceMetricsMethods = {\n [VectorMetricsNames.Euclidean]: calculateEuclideanDistance,\n};\nexport const stringDistanceMetricsMethods = {\n [StringMetricsNames.Levenshtein]: fl.distance,\n [StringMetricsNames.JaroWinkler]: jaroWinkler,\n [StringMetricsNames.Manhattan]: manhattanDistance,\n [StringMetricsNames.Onehot]: categoricalDistance,\n};\nexport const bitArrayDistanceMetricsMethods = {\n [BitArrayMetricsNames.Tanimoto]: tanimotoDistance,\n [BitArrayMetricsNames.Dice]: diceDistance,\n [BitArrayMetricsNames.Asymmetric]: asymmetricDistance,\n [BitArrayMetricsNames.BraunBlanquet]: braunBlanquetDistance,\n [BitArrayMetricsNames.Cosine]: cosineDistance,\n [BitArrayMetricsNames.Kulczynski]: kulczynskiDistance,\n [BitArrayMetricsNames.McConnaughey]: mcConnaugheyDistance,\n [BitArrayMetricsNames.RogotGoldberg]: rogotGoldbergDistance,\n [BitArrayMetricsNames.Russel]: russelDistance,\n [BitArrayMetricsNames.Sokal]: sokalDistance,\n [BitArrayMetricsNames.Hamming]: hammingDistance,\n [BitArrayMetricsNames.Euclidean]: euclideanDistance,\n};\nexport const intArrayDistanceMetricsMethods = {\n [IntArrayMetricsNames.TanimotoIntArray]: tanimotoDistanceIntArray,\n};\nexport const numberDistanceMetricsMethods = {\n [NumberMetricsNames.Difference]: numericDistance,\n};\nexport const numberArrayDistanceMetrics = {\n [NumberArrayMetricsNames.CommonItems]: inverseCommonItemsCount,\n};\nexport const AvailableMetrics = {\n [DistanceMetricsSubjects.Vector]: {\n [VectorMetricsNames.Euclidean]: vectorDistanceMetricsMethods[VectorMetricsNames.Euclidean],\n },\n [DistanceMetricsSubjects.String]: {\n [StringMetricsNames.Levenshtein]: stringDistanceMetricsMethods[StringMetricsNames.Levenshtein],\n [StringMetricsNames.JaroWinkler]: stringDistanceMetricsMethods[StringMetricsNames.JaroWinkler],\n [StringMetricsNames.Manhattan]: stringDistanceMetricsMethods[StringMetricsNames.Manhattan],\n [StringMetricsNames.Onehot]: stringDistanceMetricsMethods[StringMetricsNames.Onehot],\n },\n [DistanceMetricsSubjects.BitArray]: {\n [BitArrayMetricsNames.Tanimoto]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Tanimoto],\n [BitArrayMetricsNames.Dice]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Dice],\n [BitArrayMetricsNames.Asymmetric]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Asymmetric],\n [BitArrayMetricsNames.BraunBlanquet]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.BraunBlanquet],\n [BitArrayMetricsNames.Cosine]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Cosine],\n [BitArrayMetricsNames.Kulczynski]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Kulczynski],\n [BitArrayMetricsNames.McConnaughey]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.McConnaughey],\n [BitArrayMetricsNames.RogotGoldberg]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.RogotGoldberg],\n [BitArrayMetricsNames.Russel]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Russel],\n [BitArrayMetricsNames.Sokal]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Sokal],\n },\n [DistanceMetricsSubjects.MacroMolecule]: {\n [MmDistanceFunctionsNames.HAMMING]: mmDistanceFunctions[MmDistanceFunctionsNames.HAMMING],\n [MmDistanceFunctionsNames.LEVENSHTEIN]: mmDistanceFunctions[MmDistanceFunctionsNames.LEVENSHTEIN],\n [MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH]: mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH],\n [MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE]: mmDistanceFunctions[MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE],\n },\n [DistanceMetricsSubjects.Number]: {\n [NumberMetricsNames.Difference]: numberDistanceMetricsMethods[NumberMetricsNames.Difference],\n },\n [DistanceMetricsSubjects.IntArray]: {\n [IntArrayMetricsNames.TanimotoIntArray]: intArrayDistanceMetricsMethods[IntArrayMetricsNames.TanimotoIntArray],\n },\n [DistanceMetricsSubjects.NumberArray]: {\n [NumberArrayMetricsNames.CommonItems]: numberArrayDistanceMetrics[NumberArrayMetricsNames.CommonItems],\n },\n};\nexport const MetricToDataType = Object.keys(AvailableMetrics)\n .reduce((ret, key) => {\n for (const val of Object.keys(AvailableMetrics[key]))\n ret[val] = key;\n return ret;\n}, {});\nexport function isStringMetric(name) {\n return MetricToDataType[name] == 'String';\n}\nexport function isBitArrayMetric(name) {\n return MetricToDataType[name] == 'BitArray';\n}\nexport function isVectorMetric(name) {\n return MetricToDataType[name] == 'Vector';\n}\nexport function isMacroMoleculeMetric(name) {\n return MetricToDataType[name] == DistanceMetricsSubjects.MacroMolecule.toString();\n}\nexport function isNumericMetric(name) {\n return MetricToDataType[name] == DistanceMetricsSubjects.Number.toString();\n}\nexport function isNumberArrayMetric(name) {\n return MetricToDataType[name] == DistanceMetricsSubjects.NumberArray.toString();\n}\n/** Manhattan distance between two sequences (match - 0, mismatch - 1) normalized for length. */\nexport function manhattanDistance(s1, s2) {\n if (s1.length !== s2.length) {\n return 1;\n }\n else {\n let dist = 0;\n for (let i = 1; i < s1.length; i++)\n dist += s1[i] == s2[i] ? 0 : 1;\n return dist / s1.length;\n }\n}\nexport function categoricalDistance(s1, s2) {\n return s1 === s2 ? 0 : 1;\n}\n/** Unified class implementing different string measures. */\nexport class Measure {\n /**\n * Creates an instance of Measure with .\n * @param {string} method Method to calculate distance between strings.\n * @memberof Measurer\n */\n constructor(method) {\n this.method = method;\n this.dataType = MetricToDataType[method];\n }\n /**\n * Returns true if the metric needs arguments to be calculated.\n * @param {KnownMetrics} method Metric to check if it needs arguments.\n * @return {boolean} True if the metric needs arguments.\n * @memberof Measure\n */\n metricNeedsArgs(method) {\n return isMacroMoleculeMetric(method) || isNumericMetric(method) || isNumberArrayMetric(method);\n }\n /**\n * Returns custom string distance function specified.\n * @param {opts} opts Options for the measure. used for macromolecule distances\n * @return {DistanceMetric} Callback of the measure chosen.\n * @memberof Measurer\n */\n getMeasure(opts) {\n const dict = AvailableMetrics;\n if (!dict.hasOwnProperty(this.dataType) || !dict[this.dataType].hasOwnProperty(this.method))\n throw new Error(`Unknown measure ${this.method} for data type ${this.dataType}`);\n return this.metricNeedsArgs(this.method) ?\n dict[this.dataType][this.method](opts) :\n dict[this.dataType][this.method];\n }\n /**\n * Returns custom string distance by the given data type.\n * @param {AvailableDataTypes} dataType Metric's data type\n * @return {string[]} Metric names which expects the given data type\n * @memberof Measurer\n */\n static getMetricByDataType(dataType) {\n return Object.keys(AvailableMetrics[dataType]);\n }\n /** Returns metric names available.\n * @memberof Measurer\n */\n static get availableMeasures() {\n return Object.keys(AvailableMetrics);\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"typed-metrics.js","sourceRoot":"","sources":["typed-metrics.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fl from 'fastest-levenshtein';\nimport {jaroWinkler} from 'jaro-winkler-typescript';\nimport {DistanceMetric} from '@datagrok-libraries/utils/src/type-declarations';\nimport {\n  asymmetricDistance,\n  braunBlanquetDistance,\n  cosineDistance,\n  diceDistance,\n  euclideanDistance,\n  hammingDistance,\n  kulczynskiDistance,\n  mcConnaugheyDistance,\n  rogotGoldbergDistance,\n  russelDistance,\n  sokalDistance,\n  tanimotoDistance,\n  numericDistance,\n  tanimotoDistanceIntArray,\n  inverseCommonItemsCount,\n} from '../distance-metrics-methods';\n\nimport {calculateEuclideanDistance} from '@datagrok-libraries/utils/src/vector-operations';\nimport BitArray from '@datagrok-libraries/utils/src/bit-array';\nimport {Vector, StringDictionary} from '@datagrok-libraries/utils/src/type-declarations';\nimport {mmDistanceFunctions, MmDistanceFunctionsNames} from '../macromolecule-distance-functions';\nimport {DistanceMetricsSubjects, BitArrayMetricsNames,\n  StringMetricsNames, VectorMetricsNames, NumberMetricsNames, IntArrayMetricsNames,\n  NumberArrayMetricsNames} from './consts';\n\n\nexport const vectorDistanceMetricsMethods: { [name: string]: (x: Vector, y: Vector) => number } = {\n  [VectorMetricsNames.Euclidean]: calculateEuclideanDistance,\n};\n\nexport const stringDistanceMetricsMethods: { [name: string]: (x: string, y: string) => number } = {\n  [StringMetricsNames.Levenshtein]: fl.distance,\n  [StringMetricsNames.JaroWinkler]: jaroWinkler,\n  [StringMetricsNames.Manhattan]: manhattanDistance,\n  [StringMetricsNames.Onehot]: categoricalDistance,\n};\n\nexport const bitArrayDistanceMetricsMethods: { [name: string]: (x: BitArray, y: BitArray) => number } = {\n  [BitArrayMetricsNames.Tanimoto]: tanimotoDistance,\n  [BitArrayMetricsNames.Dice]: diceDistance,\n  [BitArrayMetricsNames.Asymmetric]: asymmetricDistance,\n  [BitArrayMetricsNames.BraunBlanquet]: braunBlanquetDistance,\n  [BitArrayMetricsNames.Cosine]: cosineDistance,\n  [BitArrayMetricsNames.Kulczynski]: kulczynskiDistance,\n  [BitArrayMetricsNames.McConnaughey]: mcConnaugheyDistance,\n  [BitArrayMetricsNames.RogotGoldberg]: rogotGoldbergDistance,\n  [BitArrayMetricsNames.Russel]: russelDistance,\n  [BitArrayMetricsNames.Sokal]: sokalDistance,\n  [BitArrayMetricsNames.Hamming]: hammingDistance,\n  [BitArrayMetricsNames.Euclidean]: euclideanDistance,\n};\n\nexport const intArrayDistanceMetricsMethods: { [name: string]: (x: Uint32Array, y: Uint32Array) => number } = {\n  [IntArrayMetricsNames.TanimotoIntArray]: tanimotoDistanceIntArray,\n};\n\nexport const numberDistanceMetricsMethods: { [name: string]: (args: any) => (x: number, y: number) => number } = {\n  [NumberMetricsNames.Difference]: numericDistance,\n};\n\nexport const numberArrayDistanceMetrics:\n{ [name: string]: (args: any) => (x: ArrayLike<number>, y: ArrayLike<number>) => number } = {\n  [NumberArrayMetricsNames.CommonItems]: inverseCommonItemsCount,\n};\n\nexport const AvailableMetrics = {\n  [DistanceMetricsSubjects.Vector]: {\n    [VectorMetricsNames.Euclidean]: vectorDistanceMetricsMethods[VectorMetricsNames.Euclidean],\n  },\n  [DistanceMetricsSubjects.String]: {\n    [StringMetricsNames.Levenshtein]: stringDistanceMetricsMethods[StringMetricsNames.Levenshtein],\n    [StringMetricsNames.JaroWinkler]: stringDistanceMetricsMethods[StringMetricsNames.JaroWinkler],\n    [StringMetricsNames.Manhattan]: stringDistanceMetricsMethods[StringMetricsNames.Manhattan],\n    [StringMetricsNames.Onehot]: stringDistanceMetricsMethods[StringMetricsNames.Onehot],\n  },\n  [DistanceMetricsSubjects.BitArray]: {\n    [BitArrayMetricsNames.Tanimoto]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Tanimoto],\n    [BitArrayMetricsNames.Dice]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Dice],\n    [BitArrayMetricsNames.Asymmetric]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Asymmetric],\n    [BitArrayMetricsNames.BraunBlanquet]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.BraunBlanquet],\n    [BitArrayMetricsNames.Cosine]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Cosine],\n    [BitArrayMetricsNames.Kulczynski]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Kulczynski],\n    [BitArrayMetricsNames.McConnaughey]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.McConnaughey],\n    [BitArrayMetricsNames.RogotGoldberg]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.RogotGoldberg],\n    [BitArrayMetricsNames.Russel]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Russel],\n    [BitArrayMetricsNames.Sokal]: bitArrayDistanceMetricsMethods[BitArrayMetricsNames.Sokal],\n  },\n  [DistanceMetricsSubjects.MacroMolecule]: { // optional args needed for macromolecule functions which initialize them\n    [MmDistanceFunctionsNames.HAMMING]: mmDistanceFunctions[MmDistanceFunctionsNames.HAMMING],\n    [MmDistanceFunctionsNames.LEVENSHTEIN]: mmDistanceFunctions[MmDistanceFunctionsNames.LEVENSHTEIN],\n    [MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH]: mmDistanceFunctions[MmDistanceFunctionsNames.NEEDLEMANN_WUNSCH],\n    [MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE]:\n      mmDistanceFunctions[MmDistanceFunctionsNames.MONOMER_CHEMICAL_DISTANCE],\n  },\n  [DistanceMetricsSubjects.Number]: {\n    [NumberMetricsNames.Difference]: numberDistanceMetricsMethods[NumberMetricsNames.Difference],\n  },\n  [DistanceMetricsSubjects.IntArray]: {\n    [IntArrayMetricsNames.TanimotoIntArray]: intArrayDistanceMetricsMethods[IntArrayMetricsNames.TanimotoIntArray],\n  },\n  [DistanceMetricsSubjects.NumberArray]: {\n    [NumberArrayMetricsNames.CommonItems]: numberArrayDistanceMetrics[NumberArrayMetricsNames.CommonItems],\n  },\n};\n\nexport const MetricToDataType: StringDictionary = Object.keys(AvailableMetrics)\n  .reduce((ret: StringDictionary, key) => {\n    for (const val of Object.keys(AvailableMetrics[key as AvailableDataTypes]))\n      ret[val as AvailableDataTypes] = key;\n\n    return ret;\n  }, {});\n\nexport type AvailableDataTypes = keyof typeof AvailableMetrics;\nexport type VectorMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.Vector];\nexport type StringMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.String];\nexport type BitArrayMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.BitArray];\nexport type NumberMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.Number];\nexport type IntArrayMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.IntArray];\nexport type NumberArrayMetrics = keyof typeof AvailableMetrics[DistanceMetricsSubjects.NumberArray];\nexport type KnownMetrics = StringMetrics | BitArrayMetrics | VectorMetrics |\n  MmDistanceFunctionsNames | NumberMetricsNames | IntArrayMetricsNames | NumberArrayMetricsNames;\n\nexport type ValidTypes =\n  { data: string[], metric: StringMetrics | MmDistanceFunctionsNames } |\n  { data: Vector[], metric: VectorMetrics } |\n  { data: BitArray[], metric: BitArrayMetrics } |\n  { data: number[], metric: NumberMetricsNames };\n\nexport function isStringMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == 'String';\n}\n\nexport function isBitArrayMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == 'BitArray';\n}\n\nexport function isVectorMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == 'Vector';\n}\n\nexport function isMacroMoleculeMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == DistanceMetricsSubjects.MacroMolecule.toString();\n}\n\nexport function isNumericMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == DistanceMetricsSubjects.Number.toString();\n}\n\nexport function isNumberArrayMetric(name: KnownMetrics) {\n  return MetricToDataType[name] == DistanceMetricsSubjects.NumberArray.toString();\n}\n\n/** Manhattan distance between two sequences (match - 0, mismatch - 1) normalized for length. */\nexport function manhattanDistance(s1: string, s2: string): number {\n  if (s1.length !== s2.length) {\n    return 1;\n  } else {\n    let dist: number = 0;\n    for (let i = 1; i < s1.length; i++)\n      dist += s1[i] == s2[i] ? 0 : 1;\n    return dist / s1.length;\n  }\n}\n\nexport function categoricalDistance(s1: string, s2: string): number {\n  return s1 === s2 ? 0 : 1;\n}\n\n/** Unified class implementing different string measures. */\nexport class Measure {\n  protected method: KnownMetrics;\n  protected dataType: AvailableDataTypes;\n\n  /**\n   * Creates an instance of Measure with .\n   * @param {string} method Method to calculate distance between strings.\n   * @memberof Measurer\n   */\n  constructor(method: KnownMetrics) {\n    this.method = method;\n    this.dataType = MetricToDataType[method] as AvailableDataTypes;\n  }\n\n  /**\n   * Returns true if the metric needs arguments to be calculated.\n   * @param {KnownMetrics} method Metric to check if it needs arguments.\n   * @return {boolean} True if the metric needs arguments.\n   * @memberof Measure\n   */\n  public metricNeedsArgs(method: KnownMetrics): boolean {\n    return isMacroMoleculeMetric(method) || isNumericMetric(method) || isNumberArrayMetric(method);\n  }\n  /**\n   * Returns custom string distance function specified.\n   * @param {opts} opts Options for the measure. used for macromolecule distances\n   * @return {DistanceMetric} Callback of the measure chosen.\n   * @memberof Measurer\n   */\n  public getMeasure(opts?: any): DistanceMetric {\n    const dict: { [key: string]:\n      {[key2: string]: DistanceMetric | ((opts: any) => DistanceMetric)}\n    } = AvailableMetrics;\n    if (!dict.hasOwnProperty(this.dataType) || !dict[this.dataType].hasOwnProperty(this.method))\n      throw new Error(`Unknown measure ${this.method} for data type ${this.dataType}`);\n    return this.metricNeedsArgs(this.method) ?\n      (dict[this.dataType][this.method] as ((opts: any) => DistanceMetric))(opts) :\n      dict[this.dataType][this.method] as DistanceMetric;\n  }\n\n  /**\n   * Returns custom string distance by the given data type.\n   * @param {AvailableDataTypes} dataType Metric's data type\n   * @return {string[]} Metric names which expects the given data type\n   * @memberof Measurer\n   */\n  public static getMetricByDataType(dataType: AvailableDataTypes): string[] {\n    return Object.keys(AvailableMetrics[dataType]);\n  }\n\n  /** Returns metric names available.\n   * @memberof Measurer\n   */\n  static get availableMeasures(): string[] {\n    return Object.keys(AvailableMetrics);\n  }\n}\n"]}","import { DistanceAggregationMethods } from './types';\nexport class DistanceMatrixService {\n constructor(useConcurrentWorkers = true, terminateOnComplete = true) {\n const threadCount = navigator.hardwareConcurrency;\n this._workerCount = useConcurrentWorkers ? Math.max(threadCount - 2, 1) : 1;\n this._workers = new Array(this._workerCount).fill(null)\n .map(() => new Worker(new URL('./distance-matrix-worker', import.meta.url)));\n this._terminateOnComplete = terminateOnComplete;\n }\n ;\n async calc(values, fnName, normalize = true, opts) {\n return await this.calcMulti([values], [fnName], normalize, [opts ?? {}], [1], DistanceAggregationMethods.MANHATTAN);\n }\n async calcMulti(values, fnNames, normalize = true, opts = [{}], weights = [1], aggregationMethod = DistanceAggregationMethods.MANHATTAN) {\n if (values.length < 1)\n throw new Error('values must contain at least one array');\n if (fnNames.length !== values.length || opts.length !== values.length || weights.length !== values.length)\n throw new Error('values, fnNames, weights and opts must have the same length');\n return new Promise(async (resolve, reject) => {\n try {\n const len = values[0].length;\n const promises = new Array(this._workerCount);\n const totalLength = len * (len - 1) / 2; // size of reduced distance matrix\n this._workerCount = Math.min(this._workerCount, totalLength);\n const chunkSize = totalLength / this._workerCount;\n const distanceMatrix = new Float32Array(totalLength);\n let endRow = 0;\n let endCol = 1;\n // minmax for normalization\n let lmin = 0;\n let lmax = Number.MIN_VALUE;\n for (let i = 0; i < this._workerCount; i++) {\n const start = Math.floor(i * chunkSize);\n const end = (i === this._workerCount - 1) ? totalLength : Math.floor((i + 1) * chunkSize);\n const startRow = endRow;\n const startCol = endCol;\n if (i !== this._workerCount - 1) {\n // These formulas map the linear index to the upper triangular matrix indices\n endRow = len - 2 - Math.floor(Math.sqrt(-8 * end + 4 * len * (len - 1) - 7) / 2 - 0.5);\n endCol = end - len * endRow + Math.floor((endRow + 1) * (endRow + 2) / 2);\n }\n this._workers[i].postMessage({ values, fnNames, startRow, startCol, chunckSize: end - start, opts, weights, aggregationMethod });\n promises[i] = new Promise((resolveWorker, rejectWorker) => {\n this._workers[i].onmessage = ({ data: { error, distanceMatrixData, min, max } }) => {\n this._terminateOnComplete && setTimeout(() => this._workers[i].terminate());\n if (error) {\n rejectWorker(error);\n }\n else {\n distanceMatrix.set(distanceMatrixData, start);\n if (min < lmin)\n lmin = min;\n if (max > lmax)\n lmax = max;\n resolveWorker();\n }\n };\n });\n }\n await Promise.all(promises);\n if (normalize)\n distanceMatrix.forEach((value, index) => { distanceMatrix[index] = (value - lmin) / (lmax - lmin); });\n resolve(distanceMatrix);\n }\n catch (e) {\n reject(e);\n }\n });\n }\n terminate() {\n this._workers.forEach((worker) => worker.terminate());\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"distance-matrix-service.js","sourceRoot":"","sources":["distance-matrix-service.ts"],"names":[],"mappings":"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","sourcesContent":["import {KnownMetrics} from '../typed-metrics';\nimport {DistanceAggregationMethod, DistanceAggregationMethods} from './types';\n\nexport class DistanceMatrixService {\n    private _workers: Worker[];\n    private _workerCount: number;\n    private _terminateOnComplete: boolean;\n    public constructor(useConcurrentWorkers = true, terminateOnComplete = true) {\n      const threadCount = navigator.hardwareConcurrency;\n      this._workerCount = useConcurrentWorkers ? Math.max(threadCount - 2, 1) : 1;\n      this._workers = new Array(this._workerCount).fill(null)\n        .map(() => new Worker(new URL('./distance-matrix-worker', import.meta.url)));\n      this._terminateOnComplete = terminateOnComplete;\n    };\n\n    public async calc(values: ArrayLike<any>, fnName: KnownMetrics,\n      normalize = true, opts?: {[_: string]: any}): Promise<Float32Array> {\n      return await this.calcMulti([values], [fnName], normalize,\n        [opts ?? {}], [1], DistanceAggregationMethods.MANHATTAN);\n    }\n\n    public async calcMulti(\n      values: ArrayLike<any>[], fnNames: KnownMetrics[],\n      normalize = true, opts: {[_: string]: any}[] = [{}],\n      weights: number[] = [1], aggregationMethod: DistanceAggregationMethod = DistanceAggregationMethods.MANHATTAN\n    ): Promise<Float32Array> {\n      if (values.length < 1)\n        throw new Error('values must contain at least one array');\n      if (fnNames.length !== values.length || opts.length !== values.length || weights.length !== values.length)\n        throw new Error('values, fnNames, weights and opts must have the same length');\n      return new Promise(async (resolve, reject) => {\n        try {\n          const len = values[0].length;\n          const promises = new Array<Promise<void>>(this._workerCount);\n          const totalLength = len * (len - 1) / 2; // size of reduced distance matrix\n          this._workerCount = Math.min(this._workerCount, totalLength);\n          const chunkSize = totalLength / this._workerCount;\n          const distanceMatrix = new Float32Array(totalLength);\n          let endRow = 0;\n          let endCol = 1;\n          // minmax for normalization\n          let lmin = 0;\n          let lmax = Number.MIN_VALUE;\n          for (let i = 0; i < this._workerCount; i++) {\n            const start = Math.floor(i * chunkSize);\n            const end = (i === this._workerCount - 1) ? totalLength : Math.floor((i + 1) * chunkSize);\n            const startRow = endRow;\n            const startCol = endCol;\n            if (i !== this._workerCount - 1) {\n              // These formulas map the linear index to the upper triangular matrix indices\n              endRow = len - 2 - Math.floor(Math.sqrt(-8 * end + 4 * len * (len - 1) - 7) / 2 - 0.5);\n              endCol = end - len * endRow + Math.floor((endRow + 1) * (endRow + 2) / 2);\n            }\n            this._workers[i].postMessage(\n              {values, fnNames, startRow, startCol, chunckSize: end - start, opts, weights, aggregationMethod}\n            );\n            promises[i] = new Promise((resolveWorker, rejectWorker) => {\n              this._workers[i].onmessage = ({data: {error, distanceMatrixData, min, max}}): void => {\n                this._terminateOnComplete && setTimeout(() => this._workers[i].terminate());\n                if (error) {\n                  rejectWorker(error);\n                } else {\n                  distanceMatrix.set(distanceMatrixData, start);\n                  if (min < lmin)\n                    lmin = min;\n                  if (max > lmax)\n                    lmax = max;\n                  resolveWorker();\n                }\n              };\n            });\n          }\n          await Promise.all(promises);\n          if (normalize)\n            distanceMatrix.forEach((value, index) => { distanceMatrix[index] = (value - lmin) / (lmax - lmin); });\n          resolve(distanceMatrix);\n        } catch (e) {\n          reject(e);\n        }\n      });\n    }\n\n    public terminate(): void {\n      this._workers.forEach((worker) => worker.terminate());\n    }\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n/**\n * Simple random integer function\n */\nexport function tauRandInt(n, random) {\n return Math.floor(random() * n);\n}\n/**\n * Simple random float function\n */\nexport function tauRand(random) {\n return random();\n}\n/**\n * Compute the (standard l2) norm of a vector.\n */\nexport function norm(vec) {\n let result = 0;\n for (const item of vec)\n result += item ** 2;\n return Math.sqrt(result);\n}\n/**\n * Creates an empty array (filled with undefined)\n */\nexport function empty(n) {\n const output = [];\n for (let i = 0; i < n; i++)\n output.push(undefined);\n return output;\n}\n/**\n * Creates an array filled with index values\n */\nexport function range(n) {\n return empty(n).map((_, i) => i);\n}\n/**\n * Creates an array filled with a specific value\n */\nexport function filled(n, v) {\n return empty(n).map(() => v);\n}\n/**\n * Creates an array filled with zeros\n */\nexport function zeros(n) {\n return filled(n, 0);\n}\n/**\n * Creates an array filled with ones\n */\nexport function ones(n) {\n return filled(n, 1);\n}\n/**\n * Creates an array from a to b, of length len, inclusive\n */\nexport function linear(a, b, len) {\n return empty(len).map((_, i) => {\n return a + i * ((b - a) / (len - 1));\n });\n}\n/**\n * Returns the sum of an array\n */\nexport function sum(input) {\n return input.reduce((sum, val) => sum + val);\n}\n/**\n * Returns the mean of an array\n */\nexport function mean(input) {\n return sum(input) / input.length;\n}\n/**\n * Returns the maximum value of an array\n */\nexport function max(input) {\n let max = 0;\n for (let i = 0; i < input.length; i++)\n max = input[i] > max ? input[i] : max;\n return max;\n}\n/**\n * Returns the maximum value of a 2d array\n */\nexport function max2d(input) {\n let max = 0;\n for (let i = 0; i < input.length; i++) {\n for (let j = 0; j < input[i].length; j++)\n max = input[i][j] > max ? input[i][j] : max;\n }\n return max;\n}\n/**\n * Generate nSamples many integers from 0 to poolSize such that no\n * integer is selected twice. The duplication constraint is achieved via\n * rejection sampling.\n */\nexport function rejectionSample(nSamples, poolSize, random) {\n const result = zeros(nSamples);\n for (let i = 0; i < nSamples; i++) {\n let rejectSample = true;\n while (rejectSample) {\n const j = tauRandInt(poolSize, random);\n let broken = false;\n for (let k = 0; k < i; k++) {\n if (j === result[k]) {\n broken = true;\n break;\n }\n }\n if (!broken)\n rejectSample = false;\n result[i] = j;\n }\n }\n return result;\n}\n/**\n * Reshapes a 1d array into a 2D of given dimensions.\n */\nexport function reshape2d(x, a, b) {\n const rows = [];\n // let count = 0;\n let index = 0;\n if (x.length !== a * b)\n throw new Error('Array dimensions must match input length.');\n for (let i = 0; i < a; i++) {\n const col = [];\n for (let j = 0; j < b; j++) {\n col.push(x[index]);\n index += 1;\n }\n rows.push(col);\n // count += 1;\n }\n return rows;\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["utils.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\nimport {RandomFn} from './umap';\n\n/**\n * Simple random integer function\n */\nexport function tauRandInt(n: number, random: RandomFn) {\n  return Math.floor(random() * n);\n}\n\n/**\n * Simple random float function\n */\nexport function tauRand(random: RandomFn) {\n  return random();\n}\n/**\n * Compute the (standard l2) norm of a vector.\n */\nexport function norm(vec: number[]) {\n  let result = 0;\n  for (const item of vec)\n    result += item ** 2;\n\n  return Math.sqrt(result);\n}\n\n/**\n * Creates an empty array (filled with undefined)\n */\nexport function empty(n: number): undefined[] {\n  const output: undefined[] = [];\n  for (let i = 0; i < n; i++)\n    output.push(undefined);\n\n  return output;\n}\n\n/**\n * Creates an array filled with index values\n */\nexport function range(n: number): number[] {\n  return empty(n).map((_, i) => i);\n}\n\n/**\n * Creates an array filled with a specific value\n */\nexport function filled(n: number, v: number): number[] {\n  return empty(n).map(() => v);\n}\n\n/**\n * Creates an array filled with zeros\n */\nexport function zeros(n: number): number[] {\n  return filled(n, 0);\n}\n\n/**\n * Creates an array filled with ones\n */\nexport function ones(n: number): number[] {\n  return filled(n, 1);\n}\n\n/**\n * Creates an array from a to b, of length len, inclusive\n */\nexport function linear(a: number, b: number, len: number): number[] {\n  return empty(len).map((_, i) => {\n    return a + i * ((b - a) / (len - 1));\n  });\n}\n\n/**\n * Returns the sum of an array\n */\nexport function sum(input: number[]): number {\n  return input.reduce((sum, val) => sum + val);\n}\n\n/**\n * Returns the mean of an array\n */\nexport function mean(input: number[]): number {\n  return sum(input) / input.length;\n}\n\n/**\n * Returns the maximum value of an array\n */\nexport function max(input: number[]): number {\n  let max = 0;\n  for (let i = 0; i < input.length; i++)\n    max = input[i] > max ? input[i] : max;\n\n  return max;\n}\n\n/**\n * Returns the maximum value of a 2d array\n */\nexport function max2d(input: number[][]): number {\n  let max = 0;\n  for (let i = 0; i < input.length; i++) {\n    for (let j = 0; j < input[i].length; j++)\n      max = input[i][j] > max ? input[i][j] : max;\n  }\n  return max;\n}\n\n/**\n * Generate nSamples many integers from 0 to poolSize such that no\n * integer is selected twice. The duplication constraint is achieved via\n * rejection sampling.\n */\nexport function rejectionSample(\n  nSamples: number,\n  poolSize: number,\n  random: RandomFn\n): number[] {\n  const result = zeros(nSamples);\n  for (let i = 0; i < nSamples; i++) {\n    let rejectSample = true;\n    while (rejectSample) {\n      const j = tauRandInt(poolSize, random);\n      let broken = false;\n      for (let k = 0; k < i; k++) {\n        if (j === result[k]) {\n          broken = true;\n          break;\n        }\n      }\n      if (!broken)\n        rejectSample = false;\n\n      result[i] = j;\n    }\n  }\n  return result;\n}\n\n/**\n * Reshapes a 1d array into a 2D of given dimensions.\n */\nexport function reshape2d<T>(x: T[], a: number, b: number): T[][] {\n  const rows: T[][] = [];\n  // let count = 0;\n  let index = 0;\n\n  if (x.length !== a * b)\n    throw new Error('Array dimensions must match input length.');\n\n\n  for (let i = 0; i < a; i++) {\n    const col: T[] = [];\n    for (let j = 0; j < b; j++) {\n      col.push(x[index]);\n      index += 1;\n    }\n    rows.push(col);\n    // count += 1;\n  }\n  return rows;\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\nimport * as utils from './utils';\n/**\n * Constructor for the heap objects. The heaps are used\n * for approximate nearest neighbor search, maintaining a list of potential\n * neighbors sorted by their distance. We also flag if potential neighbors\n * are newly added to the list or not. Internally this is stored as\n * a single array; the first axis determines whether we are looking at the\n * array of candidate indices, the array of distances, or the flag array for\n * whether elements are new or not. Each of these arrays are of shape\n * (``nPoints``, ``size``)\n */\nexport function makeHeap(nPoints, size) {\n const makeArrays = (fillValue) => {\n return utils.empty(nPoints).map(() => {\n return utils.filled(size, fillValue);\n });\n };\n const heap = [];\n heap.push(makeArrays(-1));\n heap.push(makeArrays(Infinity));\n heap.push(makeArrays(0));\n return heap;\n}\n/**\n * Generate n_samples many integers from 0 to pool_size such that no\n * integer is selected twice. The duplication constraint is achieved via\n * rejection sampling.\n */\nexport function rejectionSample(nSamples, poolSize, random) {\n const result = utils.zeros(nSamples);\n for (let i = 0; i < nSamples; i++) {\n let rejectSample = true;\n let j = 0;\n while (rejectSample) {\n j = utils.tauRandInt(poolSize, random);\n let broken = false;\n for (let k = 0; k < i; k++) {\n if (j === result[k]) {\n broken = true;\n break;\n }\n }\n if (!broken)\n rejectSample = false;\n }\n result[i] = j;\n }\n return result;\n}\n/**\n * Push a new element onto the heap. The heap stores potential neighbors\n * for each data point. The ``row`` parameter determines which data point we\n * are addressing, the ``weight`` determines the distance (for heap sorting),\n * the ``index`` is the element to add, and the flag determines whether this\n * is to be considered a new addition.\n */\nexport function heapPush(heap, row, weight, index, flag) {\n row = Math.floor(row);\n const indices = heap[0][row];\n const weights = heap[1][row];\n //const isNew = heap[2][row];\n if (weight >= weights[0])\n return 0;\n // Break if we already have this element.\n for (let i = 0; i < indices.length; i++) {\n if (index === indices[i])\n return 0;\n }\n return uncheckedHeapPush(heap, row, weight, index, flag);\n}\n/**\n * Push a new element onto the heap. The heap stores potential neighbors\n * for each data point. The ``row`` parameter determines which data point we\n * are addressing, the ``weight`` determines the distance (for heap sorting),\n * the ``index`` is the element to add, and the flag determines whether this\n * is to be considered a new addition.\n */\nexport function uncheckedHeapPush(heap, row, weight, index, flag) {\n const indices = heap[0][row];\n const weights = heap[1][row];\n const isNew = heap[2][row];\n if (weight >= weights[0])\n return 0;\n // Insert val at position zero\n weights[0] = weight;\n indices[0] = index;\n isNew[0] = flag;\n // Descend the heap, swapping values until the max heap criterion is met\n let i = 0;\n let iSwap = 0;\n while (true) {\n const ic1 = 2 * i + 1;\n const ic2 = ic1 + 1;\n const heapShape2 = heap[0][0].length;\n if (ic1 >= heapShape2) {\n break;\n }\n else if (ic2 >= heapShape2) {\n if (weights[ic1] > weight)\n iSwap = ic1;\n else\n break;\n }\n else if (weights[ic1] >= weights[ic2]) {\n if (weight < weights[ic1])\n iSwap = ic1;\n else\n break;\n }\n else {\n if (weight < weights[ic2])\n iSwap = ic2;\n else\n break;\n }\n weights[i] = weights[iSwap];\n indices[i] = indices[iSwap];\n isNew[i] = isNew[iSwap];\n i = iSwap;\n }\n weights[i] = weight;\n indices[i] = index;\n isNew[i] = flag;\n return 1;\n}\n/**\n * Build a heap of candidate neighbors for nearest neighbor descent. For\n * each vertex the candidate neighbors are any current neighbors, and any\n * vertices that have the vertex as one of their nearest neighbors.\n */\nexport function buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random) {\n const candidateNeighbors = makeHeap(nVertices, maxCandidates);\n for (let i = 0; i < nVertices; i++) {\n for (let j = 0; j < nNeighbors; j++) {\n if (currentGraph[0][i][j] < 0)\n continue;\n const idx = currentGraph[0][i][j];\n const isn = currentGraph[2][i][j];\n const d = utils.tauRand(random);\n heapPush(candidateNeighbors, i, d, idx, isn);\n heapPush(candidateNeighbors, idx, d, i, isn);\n currentGraph[2][i][j] = 0;\n }\n }\n return candidateNeighbors;\n}\n/**\n * Given an array of heaps (of indices and weights), unpack the heap\n * out to give and array of sorted lists of indices and weights by increasing\n * weight. This is effectively just the second half of heap sort (the first\n * half not being required since we already have the data in a heap).\n */\nexport function deheapSort(heap) {\n const indices = heap[0];\n const weights = heap[1];\n for (let i = 0; i < indices.length; i++) {\n const indHeap = indices[i];\n const distHeap = weights[i];\n for (let j = 0; j < indHeap.length - 1; j++) {\n const indHeapIndex = indHeap.length - j - 1;\n const distHeapIndex = distHeap.length - j - 1;\n const temp1 = indHeap[0];\n indHeap[0] = indHeap[indHeapIndex];\n indHeap[indHeapIndex] = temp1;\n const temp2 = distHeap[0];\n distHeap[0] = distHeap[distHeapIndex];\n distHeap[distHeapIndex] = temp2;\n siftDown(distHeap, indHeap, distHeapIndex, 0);\n }\n }\n return { indices, weights };\n}\n/**\n * Restore the heap property for a heap with an out of place element\n * at position ``elt``. This works with a heap pair where heap1 carries\n * the weights and heap2 holds the corresponding elements.\n */\nfunction siftDown(heap1, heap2, ceiling, elt) {\n while (elt * 2 + 1 < ceiling) {\n const leftChild = elt * 2 + 1;\n const rightChild = leftChild + 1;\n let swap = elt;\n if (heap1[swap] < heap1[leftChild])\n swap = leftChild;\n if (rightChild < ceiling && heap1[swap] < heap1[rightChild])\n swap = rightChild;\n if (swap === elt) {\n break;\n }\n else {\n const temp1 = heap1[elt];\n heap1[elt] = heap1[swap];\n heap1[swap] = temp1;\n const temp2 = heap2[elt];\n heap2[elt] = heap2[swap];\n heap2[swap] = temp2;\n elt = swap;\n }\n }\n}\n/**\n * Search the heap for the smallest element that is still flagged.\n */\nexport function smallestFlagged(heap, row) {\n const ind = heap[0][row];\n const dist = heap[1][row];\n const flag = heap[2][row];\n let minDist = Infinity;\n let resultIndex = -1;\n for (let i = 0; i > ind.length; i++) {\n if (flag[i] === 1 && dist[i] < minDist) {\n minDist = dist[i];\n resultIndex = i;\n }\n }\n if (resultIndex >= 0) {\n flag[resultIndex] = 0;\n return Math.floor(ind[resultIndex]);\n }\n else {\n return -1;\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"heap.js","sourceRoot":"","sources":["heap.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AA2CH,OAAO,KAAK,KAAK,MAAM,SAAS,CAAC;AAIjC;;;;;;;;;GASG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAe,EAAE,IAAY;IACpD,MAAM,UAAU,GAAG,CAAC,SAAiB,EAAE,EAAE;QACvC,OAAO,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE;YACnC,OAAO,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QACvC,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,MAAM,IAAI,GAAS,EAAE,CAAC;IACtB,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC1B,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC;IAChC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;IACzB,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC7B,QAAgB,EAChB,QAAgB,EAChB,MAAgB;IAEhB,MAAM,MAAM,GAAG,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC;IACrC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,QAAQ,EAAE,CAAC,EAAE,EAAE,CAAC;QAClC,IAAI,YAAY,GAAG,IAAI,CAAC;QACxB,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,OAAO,YAAY,EAAE,CAAC;YACpB,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC;YACvC,IAAI,MAAM,GAAG,KAAK,CAAC;YACnB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC3B,IAAI,CAAC,KAAK,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC;oBACpB,MAAM,GAAG,IAAI,CAAC;oBACd,MAAM;gBACR,CAAC;YACH,CAAC;YACD,IAAI,CAAC,MAAM;gBAAE,YAAY,GAAG,KAAK,CAAC;QACpC,CAAC;QACD,MAAM,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAChB,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,QAAQ,CACtB,IAAU,EACV,GAAW,EACX,MAAc,EACd,KAAa,EACb,IAAY;IAEZ,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACtB,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC7B,6BAA6B;IAE7B,IAAI,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC;QACtB,OAAO,CAAC,CAAC;IAGX,yCAAyC;IACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,IAAI,KAAK,KAAK,OAAO,CAAC,CAAC,CAAC;YACtB,OAAO,CAAC,CAAC;IACb,CAAC;IAED,OAAO,iBAAiB,CAAC,IAAI,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AAC3D,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAC/B,IAAU,EACV,GAAW,EACX,MAAc,EACd,KAAa,EACb,IAAY;IAEZ,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC7B,MAAM,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAE3B,IAAI,MAAM,IAAI,OAAO,CAAC,CAAC,CAAC;QACtB,OAAO,CAAC,CAAC;IAGX,8BAA8B;IAC9B,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;IACpB,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IACnB,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAEhB,wEAAwE;IACxE,IAAI,CAAC,GAAG,CAAC,CAAC;IACV,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,OAAO,IAAI,EAAE,CAAC;QACZ,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACtB,MAAM,GAAG,GAAG,GAAG,GAAG,CAAC,CAAC;QAEpB,MAAM,UAAU,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QACrC,IAAI,GAAG,IAAI,UAAU,EAAE,CAAC;YACtB,MAAM;QACR,CAAC;aAAM,IAAI,GAAG,IAAI,UAAU,EAAE,CAAC;YAC7B,IAAI,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM;gBACvB,KAAK,GAAG,GAAG,CAAC;;gBAEZ,MAAM;QACV,CAAC;aAAM,IAAI,OAAO,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC;YACxC,IAAI,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;gBACvB,KAAK,GAAG,GAAG,CAAC;;gBAEZ,MAAM;QACV,CAAC;aAAM,CAAC;YACN,IAAI,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;gBACvB,KAAK,GAAG,GAAG,CAAC;;gBAEZ,MAAM;QACV,CAAC;QAED,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5B,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC;QAC5B,KAAK,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,KAAK,CAAC,CAAC;QAExB,CAAC,GAAG,KAAK,CAAC;IACZ,CAAC;IAED,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;IACpB,OAAO,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC;IACnB,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IAChB,OAAO,CAAC,CAAC;AACX,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAC7B,YAAkB,EAClB,SAAiB,EACjB,UAAkB,EAClB,aAAqB,EACrB,MAAgB;IAEhB,MAAM,kBAAkB,GAAG,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;IAC9D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,SAAS,EAAE,CAAC,EAAE,EAAE,CAAC;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;gBAC3B,SAAS;YAEX,MAAM,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,MAAM,GAAG,GAAG,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;YAClC,MAAM,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;YAChC,QAAQ,CAAC,kBAAkB,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,CAAC;YAC7C,QAAQ,CAAC,kBAAkB,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,GAAG,CAAC,CAAC;YAC7C,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;IACD,OAAO,kBAAkB,CAAC;AAC5B,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,UAAU,CAAC,IAAU;IACnC,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACxB,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IAExB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACxC,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QAC3B,MAAM,QAAQ,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;QAE5B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC5C,MAAM,YAAY,GAAG,OAAO,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC;YAC5C,MAAM,aAAa,GAAG,QAAQ,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC;YAE9C,MAAM,KAAK,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;YACzB,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC;YACnC,OAAO,CAAC,YAAY,CAAC,GAAG,KAAK,CAAC;YAE9B,MAAM,KAAK,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC;YAC1B,QAAQ,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,aAAa,CAAC,CAAC;YACtC,QAAQ,CAAC,aAAa,CAAC,GAAG,KAAK,CAAC;YAEhC,QAAQ,CAAC,QAAQ,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IACD,OAAO,EAAC,OAAO,EAAE,OAAO,EAAC,CAAC;AAC5B,CAAC;AAED;;;;GAIG;AACH,SAAS,QAAQ,CACf,KAAe,EACf,KAAe,EACf,OAAe,EACf,GAAW;IAEX,OAAO,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,OAAO,EAAE,CAAC;QAC7B,MAAM,SAAS,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,CAAC;QAC9B,MAAM,UAAU,GAAG,SAAS,GAAG,CAAC,CAAC;QACjC,IAAI,IAAI,GAAG,GAAG,CAAC;QAEf,IAAI,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC;YAChC,IAAI,GAAG,SAAS,CAAC;QAEnB,IAAI,UAAU,GAAG,OAAO,IAAI,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC,UAAU,CAAC;YACzD,IAAI,GAAG,UAAU,CAAC;QAGpB,IAAI,IAAI,KAAK,GAAG,EAAE,CAAC;YACjB,MAAM;QACR,CAAC;aAAM,CAAC;YACN,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;YACzB,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YACzB,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;YAEpB,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC;YACzB,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;YACzB,KAAK,CAAC,IAAI,CAAC,GAAG,KAAK,CAAC;YACpB,GAAG,GAAG,IAAI,CAAC;QACb,CAAC;IACH,CAAC;AACH,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,eAAe,CAAC,IAAU,EAAE,GAAW;IACrD,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IACzB,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAC1B,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;IAE1B,IAAI,OAAO,GAAG,QAAQ,CAAC;IACvB,IAAI,WAAW,GAAG,CAAC,CAAC,CAAC;IAErB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACpC,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,GAAG,OAAO,EAAE,CAAC;YACvC,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;YAClB,WAAW,GAAG,CAAC,CAAC;QAClB,CAAC;IACH,CAAC;IAED,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;QACrB,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;QACtB,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,CAAC;IACtC,CAAC;SAAM,CAAC;QACN,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC;AACH,CAAC","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n *   list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n *   this list of conditions and the following disclaimer in the documentation\n *   and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n *   contributors may be used to endorse or promote products derived from\n *   this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport {RandomFn} from './umap';\nimport * as utils from './utils';\n\nexport type Heap = number[][][];\n\n/**\n *  Constructor for the heap objects. The heaps are used\n * for approximate nearest neighbor search, maintaining a list of potential\n * neighbors sorted by their distance. We also flag if potential neighbors\n * are newly added to the list or not. Internally this is stored as\n * a single array; the first axis determines whether we are looking at the\n * array of candidate indices, the array of distances, or the flag array for\n * whether elements are new or not. Each of these arrays are of shape\n * (``nPoints``, ``size``)\n */\nexport function makeHeap(nPoints: number, size: number): Heap {\n  const makeArrays = (fillValue: number) => {\n    return utils.empty(nPoints).map(() => {\n      return utils.filled(size, fillValue);\n    });\n  };\n\n  const heap: Heap = [];\n  heap.push(makeArrays(-1));\n  heap.push(makeArrays(Infinity));\n  heap.push(makeArrays(0));\n  return heap;\n}\n\n/**\n * Generate n_samples many integers from 0 to pool_size such that no\n * integer is selected twice. The duplication constraint is achieved via\n * rejection sampling.\n */\nexport function rejectionSample(\n  nSamples: number,\n  poolSize: number,\n  random: RandomFn\n) {\n  const result = utils.zeros(nSamples);\n  for (let i = 0; i < nSamples; i++) {\n    let rejectSample = true;\n    let j = 0;\n    while (rejectSample) {\n      j = utils.tauRandInt(poolSize, random);\n      let broken = false;\n      for (let k = 0; k < i; k++) {\n        if (j === result[k]) {\n          broken = true;\n          break;\n        }\n      }\n      if (!broken) rejectSample = false;\n    }\n    result[i] = j;\n  }\n  return result;\n}\n\n/**\n * Push a new element onto the heap. The heap stores potential neighbors\n * for each data point. The ``row`` parameter determines which data point we\n * are addressing, the ``weight`` determines the distance (for heap sorting),\n * the ``index`` is the element to add, and the flag determines whether this\n * is to be considered a new addition.\n */\nexport function heapPush(\n  heap: Heap,\n  row: number,\n  weight: number,\n  index: number,\n  flag: number\n): number {\n  row = Math.floor(row);\n  const indices = heap[0][row];\n  const weights = heap[1][row];\n  //const isNew = heap[2][row];\n\n  if (weight >= weights[0])\n    return 0;\n\n\n  // Break if we already have this element.\n  for (let i = 0; i < indices.length; i++) {\n    if (index === indices[i])\n      return 0;\n  }\n\n  return uncheckedHeapPush(heap, row, weight, index, flag);\n}\n\n/**\n * Push a new element onto the heap. The heap stores potential neighbors\n * for each data point. The ``row`` parameter determines which data point we\n * are addressing, the ``weight`` determines the distance (for heap sorting),\n * the ``index`` is the element to add, and the flag determines whether this\n * is to be considered a new addition.\n */\nexport function uncheckedHeapPush(\n  heap: Heap,\n  row: number,\n  weight: number,\n  index: number,\n  flag: number\n): number {\n  const indices = heap[0][row];\n  const weights = heap[1][row];\n  const isNew = heap[2][row];\n\n  if (weight >= weights[0])\n    return 0;\n\n\n  // Insert val at position zero\n  weights[0] = weight;\n  indices[0] = index;\n  isNew[0] = flag;\n\n  // Descend the heap, swapping values until the max heap criterion is met\n  let i = 0;\n  let iSwap = 0;\n  while (true) {\n    const ic1 = 2 * i + 1;\n    const ic2 = ic1 + 1;\n\n    const heapShape2 = heap[0][0].length;\n    if (ic1 >= heapShape2) {\n      break;\n    } else if (ic2 >= heapShape2) {\n      if (weights[ic1] > weight)\n        iSwap = ic1;\n      else\n        break;\n    } else if (weights[ic1] >= weights[ic2]) {\n      if (weight < weights[ic1])\n        iSwap = ic1;\n      else\n        break;\n    } else {\n      if (weight < weights[ic2])\n        iSwap = ic2;\n      else\n        break;\n    }\n\n    weights[i] = weights[iSwap];\n    indices[i] = indices[iSwap];\n    isNew[i] = isNew[iSwap];\n\n    i = iSwap;\n  }\n\n  weights[i] = weight;\n  indices[i] = index;\n  isNew[i] = flag;\n  return 1;\n}\n\n/**\n * Build a heap of candidate neighbors for nearest neighbor descent. For\n * each vertex the candidate neighbors are any current neighbors, and any\n * vertices that have the vertex as one of their nearest neighbors.\n */\nexport function buildCandidates(\n  currentGraph: Heap,\n  nVertices: number,\n  nNeighbors: number,\n  maxCandidates: number,\n  random: RandomFn\n) {\n  const candidateNeighbors = makeHeap(nVertices, maxCandidates);\n  for (let i = 0; i < nVertices; i++) {\n    for (let j = 0; j < nNeighbors; j++) {\n      if (currentGraph[0][i][j] < 0)\n        continue;\n\n      const idx = currentGraph[0][i][j];\n      const isn = currentGraph[2][i][j];\n      const d = utils.tauRand(random);\n      heapPush(candidateNeighbors, i, d, idx, isn);\n      heapPush(candidateNeighbors, idx, d, i, isn);\n      currentGraph[2][i][j] = 0;\n    }\n  }\n  return candidateNeighbors;\n}\n\n/**\n * Given an array of heaps (of indices and weights), unpack the heap\n * out to give and array of sorted lists of indices and weights by increasing\n * weight. This is effectively just the second half of heap sort (the first\n * half not being required since we already have the data in a heap).\n */\nexport function deheapSort(heap: Heap) {\n  const indices = heap[0];\n  const weights = heap[1];\n\n  for (let i = 0; i < indices.length; i++) {\n    const indHeap = indices[i];\n    const distHeap = weights[i];\n\n    for (let j = 0; j < indHeap.length - 1; j++) {\n      const indHeapIndex = indHeap.length - j - 1;\n      const distHeapIndex = distHeap.length - j - 1;\n\n      const temp1 = indHeap[0];\n      indHeap[0] = indHeap[indHeapIndex];\n      indHeap[indHeapIndex] = temp1;\n\n      const temp2 = distHeap[0];\n      distHeap[0] = distHeap[distHeapIndex];\n      distHeap[distHeapIndex] = temp2;\n\n      siftDown(distHeap, indHeap, distHeapIndex, 0);\n    }\n  }\n  return {indices, weights};\n}\n\n/**\n * Restore the heap property for a heap with an out of place element\n * at position ``elt``. This works with a heap pair where heap1 carries\n * the weights and heap2 holds the corresponding elements.\n */\nfunction siftDown(\n  heap1: number[],\n  heap2: number[],\n  ceiling: number,\n  elt: number\n) {\n  while (elt * 2 + 1 < ceiling) {\n    const leftChild = elt * 2 + 1;\n    const rightChild = leftChild + 1;\n    let swap = elt;\n\n    if (heap1[swap] < heap1[leftChild])\n      swap = leftChild;\n\n    if (rightChild < ceiling && heap1[swap] < heap1[rightChild])\n      swap = rightChild;\n\n\n    if (swap === elt) {\n      break;\n    } else {\n      const temp1 = heap1[elt];\n      heap1[elt] = heap1[swap];\n      heap1[swap] = temp1;\n\n      const temp2 = heap2[elt];\n      heap2[elt] = heap2[swap];\n      heap2[swap] = temp2;\n      elt = swap;\n    }\n  }\n}\n\n/**\n * Search the heap for the smallest element that is still flagged.\n */\nexport function smallestFlagged(heap: Heap, row: number) {\n  const ind = heap[0][row];\n  const dist = heap[1][row];\n  const flag = heap[2][row];\n\n  let minDist = Infinity;\n  let resultIndex = -1;\n\n  for (let i = 0; i > ind.length; i++) {\n    if (flag[i] === 1 && dist[i] < minDist) {\n      minDist = dist[i];\n      resultIndex = i;\n    }\n  }\n\n  if (resultIndex >= 0) {\n    flag[resultIndex] = 0;\n    return Math.floor(ind[resultIndex]);\n  } else {\n    return -1;\n  }\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\nimport * as utils from './utils';\n/**\n * Internal 2-dimensional sparse matrix class\n */\nexport class SparseMatrix {\n constructor(rows, cols, values, dims) {\n this.entries = new Map();\n this.nRows = 0;\n this.nCols = 0;\n if (rows.length !== cols.length || rows.length !== values.length) {\n throw new Error('rows, cols and values arrays must all have the same length');\n }\n // TODO: Assert that dims are legit.\n this.nRows = dims[0];\n this.nCols = dims[1];\n for (let i = 0; i < values.length; i++) {\n const row = rows[i];\n const col = cols[i];\n this.checkDims(row, col);\n const key = this.makeKey(row, col);\n this.entries.set(key, { value: values[i], row, col });\n }\n }\n makeKey(row, col) {\n return `${row}:${col}`;\n }\n checkDims(row, col) {\n const withinBounds = row < this.nRows && col < this.nCols;\n if (!withinBounds)\n throw new Error('row and/or col specified outside of matrix dimensions');\n }\n set(row, col, value) {\n this.checkDims(row, col);\n const key = this.makeKey(row, col);\n if (!this.entries.has(key))\n this.entries.set(key, { value, row, col });\n else\n this.entries.get(key).value = value;\n }\n get(row, col, defaultValue = 0) {\n //this.checkDims(row, col);\n const key = this.makeKey(row, col);\n if (this.entries.has(key))\n return this.entries.get(key).value;\n else\n return defaultValue;\n }\n getAll(ordered = true) {\n const rowColValues = new Array(this.entries.size).fill(null);\n let i = 0;\n this.entries.forEach((value) => {\n rowColValues[i++] = value;\n });\n if (ordered) {\n // Ordering the result isn't required for processing but it does make it easier to write tests\n rowColValues.sort((a, b) => {\n if (a.row === b.row)\n return a.col - b.col;\n else\n return a.row - b.row;\n });\n }\n return rowColValues;\n }\n getDims() {\n return [this.nRows, this.nCols];\n }\n getRows() {\n return Array.from(this.entries, ([_key, value]) => value.row);\n // return this.rows as unknown as number[];\n }\n getCols() {\n return Array.from(this.entries, ([_key, value]) => value.col);\n // return this.cols as unknown as number[];\n }\n getValues() {\n return Array.from(this.entries, ([_key, value]) => value.value);\n //return this.values as unknown as number[];\n }\n forEach(fn) {\n this.entries.forEach((value) => fn(value.value, value.row, value.col));\n }\n map(fn) {\n const vals = new Float32Array(this.entries.size);\n let i = 0;\n this.entries.forEach((value) => {\n vals[i++] = fn(value.value, value.row, value.col);\n });\n const dims = [this.nRows, this.nCols];\n return new SparseMatrix(this.getRows(), this.getCols(), vals, dims);\n }\n toArray() {\n const rows = utils.empty(this.nRows);\n const output = rows.map(() => {\n return utils.zeros(this.nCols);\n });\n this.entries.forEach((value) => {\n output[value.row][value.col] = value.value;\n });\n return output;\n }\n}\n/**\n * Transpose a sparse matrix\n */\nexport function transpose(matrix) {\n const oldRows = matrix.getRows();\n const oldCols = matrix.getCols();\n const oldVals = matrix.getValues();\n const matlen = oldCols.length;\n const cols = new Int32Array(matlen);\n const rows = new Int32Array(matlen);\n const vals = new Float32Array(matlen);\n cols.set(oldRows);\n rows.set(oldCols);\n vals.set(oldVals);\n const dims = [matrix.nCols, matrix.nRows];\n return new SparseMatrix(rows, cols, vals, dims);\n}\n/**\n * Construct a sparse identity matrix\n */\nexport function identity(size) {\n const [rows] = size;\n const matrix = new SparseMatrix([], [], [], size);\n for (let i = 0; i < rows; i++)\n matrix.set(i, i, 1);\n return matrix;\n}\n/**\n * Element-wise multiplication of two matrices\n */\nexport function pairwiseMultiply(a, b) {\n return elementWise(a, b, (x, y) => x * y);\n}\n/**\n * Element-wise addition of two matrices\n */\nexport function add(a, b) {\n return elementWise(a, b, (x, y) => x + y);\n}\n/**\n * Element-wise subtraction of two matrices\n */\nexport function subtract(a, b) {\n return elementWise(a, b, (x, y) => x - y);\n}\n/**\n * Element-wise maximum of two matrices\n */\nexport function maximum(a, b) {\n return elementWise(a, b, (x, y) => (x > y ? x : y));\n}\n/**\n * Scalar multiplication of two matrices\n */\nexport function multiplyScalar(a, scalar) {\n return a.map((value) => {\n return value * scalar;\n });\n}\n/**\n * Returns a new matrix with zero entries removed.\n */\nexport function eliminateZeros(m) {\n const zeroIndices = new Set();\n const values = m.getValues();\n const rows = m.getRows();\n const cols = m.getCols();\n for (let i = 0; i < values.length; i++) {\n if (values[i] === 0)\n zeroIndices.add(i);\n }\n const removeByZeroIndex = (_, index) => !zeroIndices.has(index);\n const nextValues = values.filter(removeByZeroIndex);\n const nextRows = rows.filter(removeByZeroIndex);\n const nextCols = cols.filter(removeByZeroIndex);\n return new SparseMatrix(nextRows, nextCols, nextValues, m.getDims());\n}\n/**\n * Normalization of a sparse matrix.\n */\nexport function normalize(m, normType = \"l2\" /* NormType.l2 */) {\n const normFn = normFns[normType];\n const colsByRow = new Map();\n m.forEach((_, row, col) => {\n const cols = colsByRow.get(row) || [];\n cols.push(col);\n colsByRow.set(row, cols);\n });\n const nextMatrix = new SparseMatrix([], [], [], m.getDims());\n for (const row of colsByRow.keys()) {\n const cols = colsByRow.get(row).sort();\n const vals = cols.map((col) => m.get(row, col));\n const norm = normFn(vals);\n for (let i = 0; i < norm.length; i++)\n nextMatrix.set(row, cols[i], norm[i]);\n }\n return nextMatrix;\n}\nconst normFns = {\n [\"max\" /* NormType.max */]: (xs) => {\n let max = -Infinity;\n for (let i = 0; i < xs.length; i++)\n max = xs[i] > max ? xs[i] : max;\n return xs.map((x) => x / max);\n },\n [\"l1\" /* NormType.l1 */]: (xs) => {\n let sum = 0;\n for (let i = 0; i < xs.length; i++)\n sum += xs[i];\n return xs.map((x) => x / sum);\n },\n [\"l2\" /* NormType.l2 */]: (xs) => {\n let sum = 0;\n for (let i = 0; i < xs.length; i++)\n sum += xs[i] ** 2;\n return xs.map((x) => Math.sqrt(x ** 2 / sum));\n },\n};\n/**\n * Helper function for element-wise operations.\n */\nfunction elementWise(a, b, op) {\n const visited = new Set();\n const rows = [];\n const cols = [];\n const vals = [];\n const operate = (row, col) => {\n rows.push(row);\n cols.push(col);\n const nextValue = op(a.get(row, col), b.get(row, col));\n vals.push(nextValue);\n };\n const valuesA = a.getValues();\n const rowsA = a.getRows();\n const colsA = a.getCols();\n for (let i = 0; i < valuesA.length; i++) {\n const row = rowsA[i];\n const col = colsA[i];\n const key = `${row}:${col}`;\n visited.add(key);\n operate(row, col);\n }\n const valuesB = b.getValues();\n const rowsB = b.getRows();\n const colsB = b.getCols();\n for (let i = 0; i < valuesB.length; i++) {\n const row = rowsB[i];\n const col = colsB[i];\n const key = `${row}:${col}`;\n if (visited.has(key))\n continue;\n operate(row, col);\n }\n const dims = [a.nRows, a.nCols];\n return new SparseMatrix(rows, cols, vals, dims);\n}\n/**\n * Helper function for getting data, indices, and inptr arrays from a sparse\n * matrix to follow csr matrix conventions. Super inefficient (and kind of\n * defeats the purpose of this convention) but a lot of the ported python tree\n * search logic depends on this data format.\n */\nexport function getCSR(x) {\n const entries = [];\n x.forEach((value, row, col) => {\n entries.push({ value, row, col });\n });\n entries.sort((a, b) => {\n if (a.row === b.row)\n return a.col - b.col;\n else\n return a.row - b.row;\n });\n const indices = [];\n const values = [];\n const indptr = [];\n let currentRow = -1;\n for (let i = 0; i < entries.length; i++) {\n const { row, col, value } = entries[i];\n if (row !== currentRow) {\n currentRow = row;\n indptr.push(i);\n }\n indices.push(col);\n values.push(value);\n }\n return { indices, values, indptr };\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matrix.js","sourceRoot":"","sources":["matrix.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\nimport * as utils from './utils';\n\ntype Entry = { value: number; row: number; col: number };\n\n/**\n * Internal 2-dimensional sparse matrix class\n */\nexport class SparseMatrix {\n  private entries = new Map<string, Entry>();\n\n  readonly nRows: number = 0;\n  readonly nCols: number = 0;\n\n  constructor(\n    rows: number[] | Int32Array,\n    cols: number[] | Int32Array,\n    values: number[] | Float32Array,\n    dims: number[]\n  ) {\n    if (rows.length !== cols.length || rows.length !== values.length) {\n      throw new Error(\n        'rows, cols and values arrays must all have the same length'\n      );\n    }\n\n    // TODO: Assert that dims are legit.\n    this.nRows = dims[0];\n    this.nCols = dims[1];\n    for (let i = 0; i < values.length; i++) {\n      const row = rows[i];\n      const col = cols[i];\n      this.checkDims(row, col);\n      const key = this.makeKey(row, col);\n      this.entries.set(key, {value: values[i], row, col});\n    }\n  }\n\n  private makeKey(row: number, col: number): string {\n    return `${row}:${col}`;\n  }\n\n  private checkDims(row: number, col: number) {\n    const withinBounds = row < this.nRows && col < this.nCols;\n    if (!withinBounds)\n      throw new Error('row and/or col specified outside of matrix dimensions');\n  }\n\n  set(row: number, col: number, value: number) {\n    this.checkDims(row, col);\n    const key = this.makeKey(row, col);\n    if (!this.entries.has(key))\n      this.entries.set(key, {value, row, col});\n    else\n      this.entries.get(key)!.value = value;\n  }\n\n  get(row: number, col: number, defaultValue = 0) {\n    //this.checkDims(row, col);\n    const key = this.makeKey(row, col);\n    if (this.entries.has(key))\n      return this.entries.get(key)!.value;\n    else\n      return defaultValue;\n  }\n\n  getAll(ordered = true): { value: number; row: number; col: number }[] {\n    const rowColValues: Entry[] = new Array(this.entries.size).fill(null);\n    let i = 0;\n    this.entries.forEach((value) => {\n      rowColValues[i++] = value;\n    });\n    if (ordered) {\n      // Ordering the result isn't required for processing but it does make it easier to write tests\n      rowColValues.sort((a, b) => {\n        if (a.row === b.row)\n          return a.col - b.col;\n        else\n          return a.row - b.row;\n      });\n    }\n    return rowColValues;\n  }\n\n  getDims(): number[] {\n    return [this.nRows, this.nCols];\n  }\n\n  getRows(): number[] {\n    return Array.from(this.entries, ([_key, value]) => value.row);\n    // return this.rows as unknown as number[];\n  }\n\n  getCols(): number[] {\n    return Array.from(this.entries, ([_key, value]) => value.col);\n    // return this.cols as unknown as number[];\n  }\n\n  getValues(): number[] {\n    return Array.from(this.entries, ([_key, value]) => value.value);\n  //return this.values as unknown as number[];\n  }\n\n  forEach(fn: (value: number, row: number, col: number) => void): void {\n    this.entries.forEach((value) => fn(value.value, value.row, value.col));\n  }\n\n  map(fn: (value: number, row: number, col: number) => number): SparseMatrix {\n    const vals = new Float32Array(this.entries.size);\n    let i = 0;\n    this.entries.forEach((value) => {\n      vals[i++] = fn(value.value, value.row, value.col);\n    });\n    const dims = [this.nRows, this.nCols];\n    return new SparseMatrix(this.getRows(), this.getCols(), vals as unknown as number[], dims);\n  }\n\n  toArray() {\n    const rows: undefined[] = utils.empty(this.nRows);\n    const output = rows.map(() => {\n      return utils.zeros(this.nCols);\n    });\n    this.entries.forEach((value) => {\n      output[value.row][value.col] = value.value;\n    });\n    return output;\n  }\n}\n\n/**\n * Transpose a sparse matrix\n */\nexport function transpose(matrix: SparseMatrix): SparseMatrix {\n  const oldRows = matrix.getRows();\n  const oldCols = matrix.getCols();\n  const oldVals = matrix.getValues();\n  const matlen = oldCols.length;\n  const cols = new Int32Array(matlen);\n  const rows = new Int32Array(matlen);\n  const vals = new Float32Array(matlen);\n\n  cols.set(oldRows);\n  rows.set(oldCols);\n  vals.set(oldVals);\n  const dims = [matrix.nCols, matrix.nRows];\n  return new SparseMatrix(rows, cols, vals, dims);\n}\n\n/**\n * Construct a sparse identity matrix\n */\nexport function identity(size: number[]): SparseMatrix {\n  const [rows] = size;\n  const matrix = new SparseMatrix([], [], [], size);\n  for (let i = 0; i < rows; i++)\n    matrix.set(i, i, 1);\n\n  return matrix;\n}\n\n/**\n * Element-wise multiplication of two matrices\n */\nexport function pairwiseMultiply(\n  a: SparseMatrix,\n  b: SparseMatrix\n): SparseMatrix {\n  return elementWise(a, b, (x, y) => x * y);\n}\n\n/**\n * Element-wise addition of two matrices\n */\nexport function add(a: SparseMatrix, b: SparseMatrix): SparseMatrix {\n  return elementWise(a, b, (x, y) => x + y);\n}\n\n/**\n * Element-wise subtraction of two matrices\n */\nexport function subtract(a: SparseMatrix, b: SparseMatrix): SparseMatrix {\n  return elementWise(a, b, (x, y) => x - y);\n}\n\n/**\n * Element-wise maximum of two matrices\n */\nexport function maximum(a: SparseMatrix, b: SparseMatrix): SparseMatrix {\n  return elementWise(a, b, (x, y) => (x > y ? x : y));\n}\n\n/**\n * Scalar multiplication of two matrices\n */\nexport function multiplyScalar(a: SparseMatrix, scalar: number): SparseMatrix {\n  return a.map((value: number) => {\n    return value * scalar;\n  });\n}\n\n/**\n * Returns a new matrix with zero entries removed.\n */\nexport function eliminateZeros(m: SparseMatrix) {\n  const zeroIndices = new Set();\n  const values = m.getValues();\n  const rows = m.getRows();\n  const cols = m.getCols();\n  for (let i = 0; i < values.length; i++) {\n    if (values[i] === 0)\n      zeroIndices.add(i);\n  }\n  const removeByZeroIndex = (_: any, index: number) => !zeroIndices.has(index);\n  const nextValues = values.filter(removeByZeroIndex);\n  const nextRows = rows.filter(removeByZeroIndex);\n  const nextCols = cols.filter(removeByZeroIndex);\n\n  return new SparseMatrix(nextRows, nextCols, nextValues, m.getDims());\n}\n\n/**\n * Normalization of a sparse matrix.\n */\nexport function normalize(m: SparseMatrix, normType = NormType.l2) {\n  const normFn = normFns[normType];\n\n  const colsByRow = new Map<number, number[]>();\n  m.forEach((_, row, col) => {\n    const cols = colsByRow.get(row) || [];\n    cols.push(col);\n    colsByRow.set(row, cols);\n  });\n\n  const nextMatrix = new SparseMatrix([], [], [], m.getDims());\n\n  for (const row of colsByRow.keys()) {\n    const cols = colsByRow.get(row)!.sort();\n\n    const vals = cols.map((col) => m.get(row, col));\n    const norm = normFn(vals);\n    for (let i = 0; i < norm.length; i++)\n      nextMatrix.set(row, cols[i], norm[i]);\n  }\n\n  return nextMatrix;\n}\n\n/**\n * Vector normalization functions\n */\ntype NormFns = { [key in NormType]: (v: number[]) => number[] };\nconst normFns: NormFns = {\n  [NormType.max]: (xs: number[]) => {\n    let max = -Infinity;\n    for (let i = 0; i < xs.length; i++)\n      max = xs[i] > max ? xs[i] : max;\n\n    return xs.map((x) => x / max);\n  },\n  [NormType.l1]: (xs: number[]) => {\n    let sum = 0;\n    for (let i = 0; i < xs.length; i++)\n      sum += xs[i];\n\n    return xs.map((x) => x / sum);\n  },\n  [NormType.l2]: (xs: number[]) => {\n    let sum = 0;\n    for (let i = 0; i < xs.length; i++)\n      sum += xs[i] ** 2;\n\n    return xs.map((x) => Math.sqrt(x ** 2 / sum));\n  },\n};\n\nexport const enum NormType {\n  max = 'max',\n  l1 = 'l1',\n  l2 = 'l2',\n}\n\n/**\n * Helper function for element-wise operations.\n */\nfunction elementWise(\n  a: SparseMatrix,\n  b: SparseMatrix,\n  op: (x: number, y: number) => number\n): SparseMatrix {\n  const visited = new Set<string>();\n  const rows: number[] = [];\n  const cols: number[] = [];\n  const vals: number[] = [];\n\n  const operate = (row: number, col: number) => {\n    rows.push(row);\n    cols.push(col);\n    const nextValue = op(a.get(row, col), b.get(row, col));\n    vals.push(nextValue);\n  };\n  const valuesA = a.getValues();\n  const rowsA = a.getRows();\n  const colsA = a.getCols();\n  for (let i = 0; i < valuesA.length; i++) {\n    const row = rowsA[i];\n    const col = colsA[i];\n    const key = `${row}:${col}`;\n    visited.add(key);\n    operate(row, col);\n  }\n\n  const valuesB = b.getValues();\n  const rowsB = b.getRows();\n  const colsB = b.getCols();\n  for (let i = 0; i < valuesB.length; i++) {\n    const row = rowsB[i];\n    const col = colsB[i];\n    const key = `${row}:${col}`;\n    if (visited.has(key)) continue;\n    operate(row, col);\n  }\n\n  const dims = [a.nRows, a.nCols];\n  return new SparseMatrix(rows, cols, vals, dims);\n}\n\n/**\n * Helper function for getting data, indices, and inptr arrays from a sparse\n * matrix to follow csr matrix conventions. Super inefficient (and kind of\n * defeats the purpose of this convention) but a lot of the ported python tree\n * search logic depends on this data format.\n */\nexport function getCSR(x: SparseMatrix) {\n  const entries: Entry[] = [];\n\n  x.forEach((value, row, col) => {\n    entries.push({value, row, col});\n  });\n\n  entries.sort((a, b) => {\n    if (a.row === b.row)\n      return a.col - b.col;\n    else\n      return a.row - b.row;\n  });\n\n  const indices: number[] = [];\n  const values: number[] = [];\n  const indptr: number[] = [];\n\n  let currentRow = -1;\n  for (let i = 0; i < entries.length; i++) {\n    const {row, col, value} = entries[i];\n    if (row !== currentRow) {\n      currentRow = row;\n      indptr.push(i);\n    }\n    indices.push(col);\n    values.push(value);\n  }\n\n  return {indices, values, indptr};\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n * contributors may be used to endorse or promote products derived from\n * this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\nimport * as utils from './utils';\nexport class FlatTree {\n constructor(hyperplanes, offsets, children, indices) {\n this.hyperplanes = hyperplanes;\n this.offsets = offsets;\n this.children = children;\n this.indices = indices;\n }\n}\n/**\n * Build a random projection forest with ``nTrees``.\n */\nexport function makeForest(data, nNeighbors, nTrees, random) {\n const leafSize = Math.max(10, nNeighbors);\n const trees = utils\n .range(nTrees)\n .map((_, i) => makeTree(data, leafSize, i, random));\n const forest = trees.map((tree) => flattenTree(tree, leafSize));\n return forest;\n}\n/**\n * Construct a random projection tree based on ``data`` with leaves\n * of size at most ``leafSize``\n */\nfunction makeTree(data, leafSize = 30, n, random) {\n const indices = utils.range(data.length);\n const tree = makeEuclideanTree(data, indices, leafSize, n, random);\n return tree;\n}\nfunction makeEuclideanTree(data, indices, leafSize = 30, q, random) {\n if (indices.length > leafSize) {\n const splitResults = euclideanRandomProjectionSplit(data, indices, random);\n const { indicesLeft, indicesRight, hyperplane, offset } = splitResults;\n const leftChild = makeEuclideanTree(data, indicesLeft, leafSize, q + 1, random);\n const rightChild = makeEuclideanTree(data, indicesRight, leafSize, q + 1, random);\n const node = { leftChild, rightChild, isLeaf: false, hyperplane, offset };\n return node;\n }\n else {\n const node = { indices, isLeaf: true };\n return node;\n }\n}\n/**\n * Given a set of ``indices`` for data points from ``data``, create\n * a random hyperplane to split the data, returning two arrays indices\n * that fall on either side of the hyperplane. This is the basis for a\n * random projection tree, which simply uses this splitting recursively.\n * This particular split uses euclidean distance to determine the hyperplane\n * and which side each data sample falls on.\n */\nfunction euclideanRandomProjectionSplit(data, indices, random) {\n //const dim = 1;\n // Select two random points, set the hyperplane between them\n const leftIndex = utils.tauRandInt(indices.length, random);\n let rightIndex = utils.tauRandInt(indices.length, random);\n rightIndex += leftIndex === rightIndex ? 1 : 0;\n rightIndex = rightIndex % indices.length;\n const left = indices[leftIndex];\n const right = indices[rightIndex];\n // Compute the normal vector to the hyperplane (the vector between the two\n // points) and the offset from the origin\n let hyperplaneOffset = 0;\n let hyperplaneVector = 0;\n hyperplaneVector = data[left] - data[right];\n hyperplaneOffset -=\n (hyperplaneVector * (data[left] + data[right])) / 2.0;\n // For each point compute the margin (project into normal vector)\n // If we are on lower side of the hyperplane put in one pile, otherwise\n // put it in the other pile (if we hit hyperplane on the nose, flip a coin)\n let nLeft = 0;\n let nRight = 0;\n const side = utils.zeros(indices.length);\n for (let i = 0; i < indices.length; i++) {\n let margin = hyperplaneOffset;\n margin += hyperplaneVector * data[indices[i]];\n if (margin === 0) {\n side[i] = utils.tauRandInt(2, random);\n if (side[i] === 0)\n nLeft += 1;\n else\n nRight += 1;\n }\n else if (margin > 0) {\n side[i] = 0;\n nLeft += 1;\n }\n else {\n side[i] = 1;\n nRight += 1;\n }\n }\n // Now that we have the counts, allocate arrays\n const indicesLeft = utils.zeros(nLeft);\n const indicesRight = utils.zeros(nRight);\n // Populate the arrays with indices according to which side they fell on\n nLeft = 0;\n nRight = 0;\n for (let i = 0; i < side.length; i++) {\n if (side[i] === 0) {\n indicesLeft[nLeft] = indices[i];\n nLeft += 1;\n }\n else {\n indicesRight[nRight] = indices[i];\n nRight += 1;\n }\n }\n return {\n indicesLeft,\n indicesRight,\n hyperplane: hyperplaneVector,\n offset: hyperplaneOffset,\n };\n}\nfunction flattenTree(tree, leafSize) {\n const nNodes = numNodes(tree);\n const nLeaves = numLeaves(tree);\n // TODO: Verify that sparse code is not relevant...\n const hyperplanes = utils\n .range(nNodes)\n .map(() => tree.hyperplane ? 1 : 0);\n const offsets = utils.zeros(nNodes);\n const children = utils.range(nNodes).map(() => [-1, -1]);\n const indices = utils\n .range(nLeaves)\n .map(() => utils.range(leafSize).map(() => -1));\n recursiveFlatten(tree, hyperplanes, offsets, children, indices, 0, 0);\n return new FlatTree(hyperplanes, offsets, children, indices);\n}\nfunction recursiveFlatten(tree, hyperplanes, offsets, children, indices, nodeNum, leafNum) {\n if (tree.isLeaf) {\n children[nodeNum][0] = -leafNum;\n // TODO: Triple check this operation corresponds to\n // indices[leafNum : tree.indices.shape[0]] = tree.indices\n indices[leafNum].splice(0, tree.indices.length, ...tree.indices);\n leafNum += 1;\n return { nodeNum, leafNum };\n }\n else {\n hyperplanes[nodeNum] = tree.hyperplane;\n offsets[nodeNum] = tree.offset;\n children[nodeNum][0] = nodeNum + 1;\n const oldNodeNum = nodeNum;\n let res = recursiveFlatten(tree.leftChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);\n nodeNum = res.nodeNum;\n leafNum = res.leafNum;\n children[oldNodeNum][1] = nodeNum + 1;\n res = recursiveFlatten(tree.rightChild, hyperplanes, offsets, children, indices, nodeNum + 1, leafNum);\n return { nodeNum: res.nodeNum, leafNum: res.leafNum };\n }\n}\nfunction numNodes(tree) {\n if (tree.isLeaf)\n return 1;\n else\n return 1 + numNodes(tree.leftChild) + numNodes(tree.rightChild);\n}\nfunction numLeaves(tree) {\n if (tree.isLeaf)\n return 1;\n else\n return numLeaves(tree.leftChild) + numLeaves(tree.rightChild);\n}\n/**\n * Generate an array of sets of candidate nearest neighbors by\n * constructing a random projection forest and taking the leaves of all the\n * trees. Any given tree has leaves that are a set of potential nearest\n * neighbors. Given enough trees the set of all such leaves gives a good\n * likelihood of getting a good set of nearest neighbors in composite. Since\n * such a random projection forest is inexpensive to compute, this can be a\n * useful means of seeding other nearest neighbor algorithms.\n */\nexport function makeLeafArray(rpForest) {\n if (rpForest.length > 0) {\n const output = [];\n for (const tree of rpForest)\n output.push(...tree.indices);\n return output;\n }\n else {\n return [[-1]];\n }\n}\n/**\n * Selects the side of the tree to search during flat tree search.\n */\nfunction selectSide(hyperplane, offset, point, random) {\n let margin = offset;\n margin += hyperplane * point;\n if (margin === 0) {\n const side = utils.tauRandInt(2, random);\n return side;\n }\n else if (margin > 0) {\n return 0;\n }\n else {\n return 1;\n }\n}\n/**\n * Searches a flattened rp-tree for a point.\n */\nexport function searchFlatTree(point, tree, random) {\n let node = 0;\n while (tree.children[node][0] > 0) {\n const side = selectSide(tree.hyperplanes[node], tree.offsets[node], point, random);\n if (side === 0)\n node = tree.children[node][0];\n else\n node = tree.children[node][1];\n }\n const index = -1 * tree.children[node][0];\n return tree.indices[index];\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tree.js","sourceRoot":"","sources":["tree.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n *   list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n *   this list of conditions and the following disclaimer in the documentation\n *   and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n *   contributors may be used to endorse or promote products derived from\n *   this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport * as utils from './utils';\nimport {RandomFn, Vector} from './umap';\n\n/**\n * Tree functionality for approximating nearest neighbors\n */\ninterface RandomProjectionTreeNode {\n  isLeaf: boolean;\n  indices?: number[];\n  leftChild?: RandomProjectionTreeNode;\n  rightChild?: RandomProjectionTreeNode;\n  hyperplane?: number;\n  offset?: number;\n}\n\nexport class FlatTree {\n  constructor(\n    public hyperplanes: number[],\n    public offsets: number[],\n    public children: number[][],\n    public indices: number[][]\n  ) {}\n}\n\n/**\n * Build a random projection forest with ``nTrees``.\n */\nexport function makeForest(\n  data: Vector,\n  nNeighbors: number,\n  nTrees: number,\n  random: RandomFn\n) {\n  const leafSize = Math.max(10, nNeighbors);\n\n  const trees = utils\n    .range(nTrees)\n    .map((_, i) => makeTree(data, leafSize, i, random));\n  const forest = trees.map((tree) => flattenTree(tree, leafSize));\n\n  return forest;\n}\n\n/**\n * Construct a random projection tree based on ``data`` with leaves\n * of size at most ``leafSize``\n */\nfunction makeTree(\n  data: Vector,\n  leafSize = 30,\n  n: number,\n  random: RandomFn\n): RandomProjectionTreeNode {\n  const indices = utils.range(data.length);\n  const tree = makeEuclideanTree(data, indices, leafSize, n, random);\n  return tree;\n}\n\nfunction makeEuclideanTree(\n  data: Vector,\n  indices: number[],\n  leafSize = 30,\n  q: number,\n  random: RandomFn\n): RandomProjectionTreeNode {\n  if (indices.length > leafSize) {\n    const splitResults = euclideanRandomProjectionSplit(data, indices, random);\n    const {indicesLeft, indicesRight, hyperplane, offset} = splitResults;\n\n    const leftChild = makeEuclideanTree(\n      data,\n      indicesLeft,\n      leafSize,\n      q + 1,\n      random\n    );\n    const rightChild = makeEuclideanTree(\n      data,\n      indicesRight,\n      leafSize,\n      q + 1,\n      random\n    );\n\n    const node = {leftChild, rightChild, isLeaf: false, hyperplane, offset};\n    return node;\n  } else {\n    const node = {indices, isLeaf: true};\n    return node;\n  }\n}\n\n/**\n * Given a set of ``indices`` for data points from ``data``, create\n * a random hyperplane to split the data, returning two arrays indices\n * that fall on either side of the hyperplane. This is the basis for a\n * random projection tree, which simply uses this splitting recursively.\n * This particular split uses euclidean distance to determine the hyperplane\n * and which side each data sample falls on.\n */\nfunction euclideanRandomProjectionSplit(\n  data: Vector,\n  indices: number[],\n  random: RandomFn\n) {\n  //const dim = 1;\n\n  // Select two random points, set the hyperplane between them\n  const leftIndex = utils.tauRandInt(indices.length, random);\n  let rightIndex = utils.tauRandInt(indices.length, random);\n  rightIndex += leftIndex === rightIndex ? 1 : 0;\n  rightIndex = rightIndex % indices.length;\n  const left = indices[leftIndex];\n  const right = indices[rightIndex];\n\n  // Compute the normal vector to the hyperplane (the vector between the two\n  // points) and the offset from the origin\n  let hyperplaneOffset = 0;\n  let hyperplaneVector = 0;\n\n\n  hyperplaneVector = data[left] - data[right];\n  hyperplaneOffset -=\n    (hyperplaneVector * (data[left] + data[right])) / 2.0;\n\n\n  // For each point compute the margin (project into normal vector)\n  // If we are on lower side of the hyperplane put in one pile, otherwise\n  // put it in the other pile (if we hit hyperplane on the nose, flip a coin)\n  let nLeft = 0;\n  let nRight = 0;\n  const side = utils.zeros(indices.length);\n  for (let i = 0; i < indices.length; i++) {\n    let margin = hyperplaneOffset;\n\n    margin += hyperplaneVector * data[indices[i]];\n\n    if (margin === 0) {\n      side[i] = utils.tauRandInt(2, random);\n      if (side[i] === 0)\n        nLeft += 1;\n      else\n        nRight += 1;\n    } else if (margin > 0) {\n      side[i] = 0;\n      nLeft += 1;\n    } else {\n      side[i] = 1;\n      nRight += 1;\n    }\n  }\n\n  // Now that we have the counts, allocate arrays\n  const indicesLeft = utils.zeros(nLeft);\n  const indicesRight = utils.zeros(nRight);\n\n  // Populate the arrays with indices according to which side they fell on\n  nLeft = 0;\n  nRight = 0;\n  for (let i = 0; i < side.length; i++) {\n    if (side[i] === 0) {\n      indicesLeft[nLeft] = indices[i];\n      nLeft += 1;\n    } else {\n      indicesRight[nRight] = indices[i];\n      nRight += 1;\n    }\n  }\n\n  return {\n    indicesLeft,\n    indicesRight,\n    hyperplane: hyperplaneVector,\n    offset: hyperplaneOffset,\n  };\n}\n\nfunction flattenTree(tree: RandomProjectionTreeNode, leafSize: number) {\n  const nNodes = numNodes(tree);\n  const nLeaves = numLeaves(tree);\n\n  // TODO: Verify that sparse code is not relevant...\n  const hyperplanes = utils\n    .range(nNodes)\n    .map(() => tree.hyperplane ? 1 : 0);\n\n  const offsets = utils.zeros(nNodes);\n  const children = utils.range(nNodes).map(() => [-1, -1]);\n  const indices = utils\n    .range(nLeaves)\n    .map(() => utils.range(leafSize).map(() => -1));\n  recursiveFlatten(tree, hyperplanes, offsets, children, indices, 0, 0);\n  return new FlatTree(hyperplanes, offsets, children, indices);\n}\n\nfunction recursiveFlatten(\n  tree: RandomProjectionTreeNode,\n  hyperplanes: number[],\n  offsets: number[],\n  children: number[][],\n  indices: number[][],\n  nodeNum: number,\n  leafNum: number\n): { nodeNum: number; leafNum: number } {\n  if (tree.isLeaf) {\n    children[nodeNum][0] = -leafNum;\n\n    // TODO: Triple check this operation corresponds to\n    // indices[leafNum : tree.indices.shape[0]] = tree.indices\n    indices[leafNum].splice(0, tree.indices!.length, ...tree.indices!);\n    leafNum += 1;\n    return {nodeNum, leafNum};\n  } else {\n    hyperplanes[nodeNum] = tree.hyperplane!;\n    offsets[nodeNum] = tree.offset!;\n    children[nodeNum][0] = nodeNum + 1;\n    const oldNodeNum = nodeNum;\n\n    let res = recursiveFlatten(\n      tree.leftChild!,\n      hyperplanes,\n      offsets,\n      children,\n      indices,\n      nodeNum + 1,\n      leafNum\n    );\n    nodeNum = res.nodeNum;\n    leafNum = res.leafNum;\n\n    children[oldNodeNum][1] = nodeNum + 1;\n\n    res = recursiveFlatten(\n      tree.rightChild!,\n      hyperplanes,\n      offsets,\n      children,\n      indices,\n      nodeNum + 1,\n      leafNum\n    );\n    return {nodeNum: res.nodeNum, leafNum: res.leafNum};\n  }\n}\n\nfunction numNodes(tree: RandomProjectionTreeNode): number {\n  if (tree.isLeaf)\n    return 1;\n  else\n    return 1 + numNodes(tree.leftChild!) + numNodes(tree.rightChild!);\n}\n\nfunction numLeaves(tree: RandomProjectionTreeNode): number {\n  if (tree.isLeaf)\n    return 1;\n  else\n    return numLeaves(tree.leftChild!) + numLeaves(tree.rightChild!);\n}\n\n/**\n * Generate an array of sets of candidate nearest neighbors by\n * constructing a random projection forest and taking the leaves of all the\n * trees. Any given tree has leaves that are a set of potential nearest\n * neighbors. Given enough trees the set of all such leaves gives a good\n * likelihood of getting a good set of nearest neighbors in composite. Since\n * such a random projection forest is inexpensive to compute, this can be a\n * useful means of seeding other nearest neighbor algorithms.\n */\nexport function makeLeafArray(rpForest: FlatTree[]): number[][] {\n  if (rpForest.length > 0) {\n    const output: number[][] = [];\n    for (const tree of rpForest)\n      output.push(...tree.indices!);\n\n    return output;\n  } else {\n    return [[-1]];\n  }\n}\n\n/**\n * Selects the side of the tree to search during flat tree search.\n */\nfunction selectSide(\n  hyperplane: number,\n  offset: number,\n  point: number,\n  random: RandomFn\n) {\n  let margin = offset;\n\n  margin += hyperplane * point;\n\n\n  if (margin === 0) {\n    const side = utils.tauRandInt(2, random);\n    return side;\n  } else if (margin > 0) {\n    return 0;\n  } else {\n    return 1;\n  }\n}\n\n/**\n * Searches a flattened rp-tree for a point.\n */\nexport function searchFlatTree(\n  point: number,\n  tree: FlatTree,\n  random: RandomFn\n) {\n  let node = 0;\n  while (tree.children[node][0] > 0) {\n    const side = selectSide(\n      tree.hyperplanes[node],\n      tree.offsets[node],\n      point,\n      random\n    );\n    if (side === 0)\n      node = tree.children[node][0];\n    else\n      node = tree.children[node][1];\n  }\n\n  const index = -1 * tree.children[node][0];\n  return tree.indices[index];\n}\n"]}","const toString = Object.prototype.toString;\n\nexport default function isAnyArray(object) {\n return toString.call(object).endsWith('Array]');\n}\n","/**\n * Calculate current error\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} parameters - Array of current parameter values\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {number}\n */\nexport default function errorCalculation(\n data,\n parameters,\n parameterizedFunction,\n) {\n let error = 0;\n const func = parameterizedFunction(parameters);\n\n for (let i = 0; i < data.x.length; i++) {\n error += Math.abs(data.y[i] - func(data.x[i]));\n }\n\n return error;\n}\n","import { inverse, Matrix } from 'ml-matrix';\n\n/**\n * Difference of the matrix function over the parameters\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} evaluatedData - Array of previous evaluated function values\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} gradientDifference - Adjustment for decrease the damping parameter\n * @param {function} paramFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Matrix}\n */\nfunction gradientFunction(\n data,\n evaluatedData,\n params,\n gradientDifference,\n paramFunction,\n) {\n const n = params.length;\n const m = data.x.length;\n\n let ans = new Array(n);\n\n for (let param = 0; param < n; param++) {\n ans[param] = new Array(m);\n let auxParams = params.slice();\n auxParams[param] += gradientDifference;\n let funcParam = paramFunction(auxParams);\n\n for (let point = 0; point < m; point++) {\n ans[param][point] = evaluatedData[point] - funcParam(data.x[point]);\n }\n }\n return new Matrix(ans);\n}\n\n/**\n * Matrix function over the samples\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} evaluatedData - Array of previous evaluated function values\n * @return {Matrix}\n */\nfunction matrixFunction(data, evaluatedData) {\n const m = data.x.length;\n\n let ans = new Array(m);\n\n for (let point = 0; point < m; point++) {\n ans[point] = [data.y[point] - evaluatedData[point]];\n }\n\n return new Matrix(ans);\n}\n\n/**\n * Iteration for Levenberg-Marquardt\n * @ignore\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} damping - Levenberg-Marquardt parameter\n * @param {number} gradientDifference - Adjustment for decrease the damping parameter\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Array<number>}\n */\nexport default function step(\n data,\n params,\n damping,\n gradientDifference,\n parameterizedFunction,\n) {\n let value = damping * gradientDifference * gradientDifference;\n let identity = Matrix.eye(params.length, params.length, value);\n\n const func = parameterizedFunction(params);\n\n let evaluatedData = new Float64Array(data.x.length);\n for (let i = 0; i < data.x.length; i++) {\n evaluatedData[i] = func(data.x[i]);\n }\n\n let gradientFunc = gradientFunction(\n data,\n evaluatedData,\n params,\n gradientDifference,\n parameterizedFunction,\n );\n let matrixFunc = matrixFunction(data, evaluatedData);\n let inverseMatrix = inverse(\n identity.add(gradientFunc.mmul(gradientFunc.transpose())),\n );\n\n params = new Matrix([params]);\n params = params.sub(\n inverseMatrix\n .mmul(gradientFunc)\n .mmul(matrixFunc)\n .mul(gradientDifference)\n .transpose(),\n );\n\n return params.to1DArray();\n}\n","/* eslint-disable max-len */\n/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n * contributors may be used to endorse or promote products derived from\n * this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\nimport * as heap from './heap';\nimport * as matrix from './matrix';\nimport * as nnDescent from './nn_descent';\nimport * as tree from './tree';\nimport * as utils from './utils';\nimport LM from 'ml-levenberg-marquardt';\nconst SMOOTH_K_TOLERANCE = 1e-5;\nconst MIN_K_DIST_SCALE = 1e-3;\n/**\n * UMAP projection system, based on the python implementation from McInnes, L,\n * Healy, J, UMAP: Uniform Manifold Approximation and Projection for Dimension\n * Reduction (https://github.com/lmcinnes/umap).\n *\n * This implementation differs in a few regards:\n * a) The initialization of the embedding for optimization is not computed using\n * a spectral method, rather it is initialized randomly. This avoids some\n * computationally intensive matrix eigen computations that aren't easily\n * ported to JavaScript.\n * b) A lot of \"extra\" functionality has been omitted from this implementation,\n * most notably a great deal of alternate distance functions.\n *\n * This implementation provides three methods of reducing dimensionality:\n * 1) fit: fit the data synchronously\n * 2) fitAsync: fit the data asynchronously, with a callback function provided\n * that is invoked on each optimization step.\n * 3) initializeFit / step: manually initialize the algorithm then explictly\n * step through each epoch of the SGD optimization\n */\nexport class UMAP {\n get neighbors() {\n return this.nNeighbors;\n }\n constructor(params = {}) {\n this.learningRate = 1.0;\n this.localConnectivity = 1.0;\n this.minDist = 0.1;\n this.nComponents = 2;\n this.nEpochs = 0;\n this.nNeighbors = 15;\n this.negativeSampleRate = 5;\n this.random = Math.random;\n this.repulsionStrength = 1.0;\n this.setOpMixRatio = 1.0;\n this.spread = 1.0;\n this.transformQueueSize = 4.0;\n // Supervised projection params\n this.targetMetric = \"categorical\" /* TargetMetric.categorical */;\n this.targetWeight = 0.5;\n this.targetNNeighbors = 15;\n this.distanceFn = numeric;\n this.isInitialized = false;\n this.rpForest = [];\n // Projected embedding\n this.embedding = [];\n this.optimizationState = new OptimizationState();\n const setParam = (key) => {\n //@ts-ignore\n if (params[key] !== undefined)\n this[key] = params[key];\n };\n setParam('distanceFn');\n setParam('learningRate');\n setParam('localConnectivity');\n setParam('minDist');\n setParam('nComponents');\n setParam('nEpochs');\n setParam('nNeighbors');\n setParam('negativeSampleRate');\n setParam('random');\n setParam('repulsionStrength');\n setParam('setOpMixRatio');\n setParam('spread');\n setParam('transformQueueSize');\n this.targetNNeighbors = params.nNeighbors || this.nNeighbors || this.targetNNeighbors;\n }\n /**\n * Fit the data to a projected embedding space synchronously.\n */\n fit(X) {\n this.initializeFit(X);\n this.optimizeLayout();\n return this.embedding;\n }\n /**\n * Fit the data to a projected embedding space asynchronously, with a callback\n * function invoked on every epoch of optimization.\n */\n async fitAsync(X, callback = () => true) {\n this.initializeFit(X);\n await this.optimizeLayoutAsync(callback);\n return this.embedding;\n }\n /**\n * Initializes parameters needed for supervised projection.\n */\n setSupervisedProjection(Y, params = {}) {\n this.Y = Y;\n this.targetMetric = params.targetMetric || this.targetMetric;\n this.targetWeight = params.targetWeight || this.targetWeight;\n this.targetNNeighbors = params.targetNNeighbors || this.targetNNeighbors;\n }\n /**\n * Initializes umap with precomputed KNN indices and distances.\n */\n setPrecomputedKNN(knnIndices, knnDistances) {\n this.knnIndices = knnIndices;\n this.knnDistances = knnDistances;\n }\n /**\n * Initializes fit by computing KNN and a fuzzy simplicial set, as well as\n * initializing the projected embeddings. Sets the optimization state ahead\n * of optimization steps. Returns the number of epochs to be used for the\n * SGD optimization.\n */\n initializeFit(X) {\n if (X.length <= this.nNeighbors)\n throw new Error(`Not enough data points (${X.length}) to create nNeighbors: ${this.nNeighbors}. Add more data points or adjust the configuration.`);\n // We don't need to reinitialize if we've already initialized for this data.\n if (this.X === X && this.isInitialized)\n return this.getNEpochs();\n this.X = X;\n if (!this.knnIndices && !this.knnDistances) {\n const knnResults = this.nearestNeighbors(X);\n this.knnIndices = knnResults.knnIndices;\n this.knnDistances = knnResults.knnDistances;\n }\n this.graph = this.fuzzySimplicialSet(X, this.nNeighbors, this.setOpMixRatio);\n // Set up the search graph for subsequent transformation.\n this.makeSearchFns();\n this.searchGraph = this.makeSearchGraph(X);\n // Check if supervised projection, then adjust the graph.\n this.processGraphForSupervisedProjection();\n const { head, tail, epochsPerSample, } = this.initializeSimplicialSetEmbedding();\n // Set the optimization routine state\n this.optimizationState.head = head;\n this.optimizationState.tail = tail;\n this.optimizationState.epochsPerSample = epochsPerSample;\n // Now, initialize the optimization steps\n this.initializeOptimization();\n this.prepareForOptimizationLoop();\n this.isInitialized = true;\n return this.getNEpochs();\n }\n makeSearchFns() {\n const { initFromTree, initFromRandom } = nnDescent.makeInitializations(this.distanceFn);\n this.initFromTree = initFromTree;\n this.initFromRandom = initFromRandom;\n this.search = nnDescent.makeInitializedNNSearch(this.distanceFn);\n }\n makeSearchGraph(X) {\n const knnIndices = this.knnIndices;\n const knnDistances = this.knnDistances;\n const dims = [X.length, X.length];\n const searchGraph = new matrix.SparseMatrix([], [], [], dims);\n for (let i = 0; i < knnIndices.length; i++) {\n const knn = knnIndices[i];\n const distances = knnDistances[i];\n for (let j = 0; j < knn.length; j++) {\n const neighbor = knn[j];\n const distance = distances[j];\n if (distance > 0)\n searchGraph.set(i, neighbor, distance);\n }\n }\n const transpose = matrix.transpose(searchGraph);\n return matrix.maximum(searchGraph, transpose);\n }\n /**\n * Transforms data to the existing embedding space.\n */\n transform(toTransform) {\n // Use the previous rawData\n const rawData = this.X;\n if (rawData === undefined || rawData.length === 0)\n throw new Error('No data has been fit.');\n let nNeighbors = Math.floor(this.nNeighbors * this.transformQueueSize);\n nNeighbors = Math.min(rawData.length, nNeighbors);\n const init = nnDescent.initializeSearch(this.rpForest, rawData, toTransform, nNeighbors, this.initFromRandom, this.initFromTree, this.random);\n const result = this.search(rawData, this.searchGraph, init, toTransform);\n let { indices, weights: distances } = heap.deheapSort(result);\n indices = indices.map((x) => x.slice(0, this.nNeighbors));\n distances = distances.map((x) => x.slice(0, this.nNeighbors));\n const adjustedLocalConnectivity = Math.max(0, this.localConnectivity - 1);\n const { sigmas, rhos } = this.smoothKNNDistance(distances, this.nNeighbors, adjustedLocalConnectivity);\n const { rows, cols, vals } = this.computeMembershipStrengths(indices, distances, sigmas, rhos);\n const size = [toTransform.length, rawData.length];\n let graph = new matrix.SparseMatrix(rows, cols, vals, size);\n // This was a very specially constructed graph with constant degree.\n // That lets us do fancy unpacking by reshaping the csr matrix indices\n // and data. Doing so relies on the constant degree assumption!\n const normed = matrix.normalize(graph, \"l1\" /* matrix.NormType.l1 */);\n const csrMatrix = matrix.getCSR(normed);\n const nPoints = toTransform.length;\n const eIndices = utils.reshape2d(csrMatrix.indices, nPoints, this.nNeighbors);\n const eWeights = utils.reshape2d(csrMatrix.values, nPoints, this.nNeighbors);\n const embedding = initTransform(eIndices, eWeights, this.embedding);\n const nEpochs = this.nEpochs ?\n this.nEpochs / 3 :\n graph.nRows <= 10000 ?\n 100 :\n 30;\n const graphMax = graph\n .getValues()\n .reduce((max, val) => (val > max ? val : max), 0);\n graph = graph.map((value) => (value < graphMax / nEpochs ? 0 : value));\n graph = matrix.eliminateZeros(graph);\n const epochsPerSample = this.makeEpochsPerSample(graph.getValues(), nEpochs);\n const head = graph.getRows();\n const tail = graph.getCols();\n // Initialize optimization slightly differently than the fit method.\n this.assignOptimizationStateParameters({\n headEmbedding: embedding,\n tailEmbedding: this.embedding,\n head,\n tail,\n currentEpoch: 0,\n nEpochs,\n nVertices: graph.getDims()[1],\n epochsPerSample,\n });\n this.prepareForOptimizationLoop();\n return this.optimizeLayout();\n }\n /**\n * Checks if we're using supervised projection, then process the graph\n * accordingly.\n */\n processGraphForSupervisedProjection() {\n const { Y, X } = this;\n if (Y) {\n if (Y.length !== X.length)\n throw new Error('Length of X and y must be equal');\n if (this.targetMetric === \"categorical\" /* TargetMetric.categorical */) {\n const lt = this.targetWeight < 1.0;\n const farDist = lt ? 2.5 * (1.0 / (1.0 - this.targetWeight)) : 1.0e12;\n this.graph = this.categoricalSimplicialSetIntersection(this.graph, Y, farDist);\n }\n // TODO (andycoenen@): add non-categorical supervised embeddings.\n }\n }\n /**\n * Manually step through the optimization process one epoch at a time.\n */\n step() {\n const { currentEpoch } = this.optimizationState;\n if (currentEpoch < this.getNEpochs())\n this.optimizeLayoutStep(currentEpoch);\n return this.optimizationState.currentEpoch;\n }\n /**\n * Returns the computed projected embedding.\n */\n getEmbedding() {\n return this.embedding;\n }\n /**\n * Compute the ``nNeighbors`` nearest points for each data point in ``X``\n * This may be exact, but more likely is approximated via nearest neighbor\n * descent.\n */\n nearestNeighbors(X) {\n const { distanceFn, nNeighbors } = this;\n const log2 = (n) => Math.log(n) / Math.log(2);\n const metricNNDescent = nnDescent.makeNNDescent(distanceFn, this.random);\n // Handle python3 rounding down from 0.5 discrpancy\n const round = (n) => {\n return n === 0.5 ? 0 : Math.round(n);\n };\n const nTrees = 5 + Math.floor(round(X.length ** 0.5 / 20.0));\n const nIters = Math.max(5, Math.floor(Math.round(log2(X.length))));\n this.rpForest = tree.makeForest(X, nNeighbors, nTrees, this.random);\n const leafArray = tree.makeLeafArray(this.rpForest);\n const { indices, weights } = metricNNDescent(X, leafArray, nNeighbors, nIters);\n return { knnIndices: indices, knnDistances: weights };\n }\n /**\n * Given a set of data X, a neighborhood size, and a measure of distance\n * compute the fuzzy simplicial set (here represented as a fuzzy graph in\n * the form of a sparse matrix) associated to the data. This is done by\n * locally approximating geodesic distance at each point, creating a fuzzy\n * simplicial set for each such point, and then combining all the local\n * fuzzy simplicial sets into a global one via a fuzzy union.\n */\n fuzzySimplicialSet(X, nNeighbors, setOpMixRatio = 1.0) {\n const { knnIndices = [], knnDistances = [], localConnectivity } = this;\n const { sigmas, rhos } = this.smoothKNNDistance(knnDistances, nNeighbors, localConnectivity);\n const { rows, cols, vals } = this.computeMembershipStrengths(knnIndices, knnDistances, sigmas, rhos);\n const size = [X.length, X.length];\n const sparseMatrix = new matrix.SparseMatrix(rows, cols, vals, size);\n const transpose = matrix.transpose(sparseMatrix);\n const prodMatrix = matrix.pairwiseMultiply(sparseMatrix, transpose);\n const a = matrix.subtract(matrix.add(sparseMatrix, transpose), prodMatrix);\n const b = matrix.multiplyScalar(a, setOpMixRatio);\n const c = matrix.multiplyScalar(prodMatrix, 1.0 - setOpMixRatio);\n const result = matrix.add(b, c);\n return result;\n }\n /**\n * Combine a fuzzy simplicial set with another fuzzy simplicial set\n * generated from categorical data using categorical distances. The target\n * data is assumed to be categorical label data (a vector of labels),\n * and this will update the fuzzy simplicial set to respect that label data.\n */\n categoricalSimplicialSetIntersection(simplicialSet, target, farDist, unknownDist = 1.0) {\n let intersection = fastIntersection(simplicialSet, target, unknownDist, farDist);\n intersection = matrix.eliminateZeros(intersection);\n return resetLocalConnectivity(intersection);\n }\n /**\n * Compute a continuous version of the distance to the kth nearest\n * neighbor. That is, this is similar to knn-distance but allows continuous\n * k values rather than requiring an integral k. In esscence we are simply\n * computing the distance such that the cardinality of fuzzy set we generate\n * is k.\n */\n smoothKNNDistance(distances, k, localConnectivity = 1.0, nIter = 64, bandwidth = 1.0) {\n const target = (Math.log(k) / Math.log(2)) * bandwidth;\n const rho = utils.zeros(distances.length);\n const result = utils.zeros(distances.length);\n for (let i = 0; i < distances.length; i++) {\n let lo = 0.0;\n let hi = Infinity;\n let mid = 1.0;\n // TODO: This is very inefficient, but will do for now. FIXME\n const ithDistances = distances[i];\n const nonZeroDists = ithDistances.filter((d) => d > 0.0);\n if (nonZeroDists.length >= localConnectivity) {\n const index = Math.floor(localConnectivity);\n const interpolation = localConnectivity - index;\n if (index > 0) {\n rho[i] = nonZeroDists[index - 1];\n if (interpolation > SMOOTH_K_TOLERANCE) {\n rho[i] +=\n interpolation * (nonZeroDists[index] - nonZeroDists[index - 1]);\n }\n }\n else {\n rho[i] = interpolation * nonZeroDists[0];\n }\n }\n else if (nonZeroDists.length > 0) {\n rho[i] = utils.max(nonZeroDists);\n }\n for (let n = 0; n < nIter; n++) {\n let psum = 0.0;\n for (let j = 1; j < distances[i].length; j++) {\n const d = distances[i][j] - rho[i];\n if (d > 0)\n psum += Math.exp(-(d / mid));\n else\n psum += 1.0;\n }\n if (Math.abs(psum - target) < SMOOTH_K_TOLERANCE)\n break;\n if (psum > target) {\n hi = mid;\n mid = (lo + hi) / 2.0;\n }\n else {\n lo = mid;\n if (hi === Infinity)\n mid *= 2;\n else\n mid = (lo + hi) / 2.0;\n }\n }\n result[i] = mid;\n // TODO: This is very inefficient, but will do for now. FIXME\n if (rho[i] > 0.0) {\n const meanIthDistances = utils.mean(ithDistances);\n if (result[i] < MIN_K_DIST_SCALE * meanIthDistances)\n result[i] = MIN_K_DIST_SCALE * meanIthDistances;\n }\n else {\n const meanDistances = utils.mean(distances.map(utils.mean));\n if (result[i] < MIN_K_DIST_SCALE * meanDistances)\n result[i] = MIN_K_DIST_SCALE * meanDistances;\n }\n }\n return { sigmas: result, rhos: rho };\n }\n /**\n * Construct the membership strength data for the 1-skeleton of each local\n * fuzzy simplicial set -- this is formed as a sparse matrix where each row is\n * a local fuzzy simplicial set, with a membership strength for the\n * 1-simplex to each other data point.\n */\n computeMembershipStrengths(knnIndices, knnDistances, sigmas, rhos) {\n const nSamples = knnIndices.length;\n const nNeighbors = knnIndices[0].length;\n const rows = utils.zeros(nSamples * nNeighbors);\n const cols = utils.zeros(nSamples * nNeighbors);\n const vals = utils.zeros(nSamples * nNeighbors);\n for (let i = 0; i < nSamples; i++) {\n for (let j = 0; j < nNeighbors; j++) {\n let val = 0;\n if (knnIndices[i][j] === -1)\n continue; // We didn't get the full knn for i\n if (knnIndices[i][j] === i)\n val = 0.0;\n else if (knnDistances[i][j] - rhos[i] <= 0.0)\n val = 1.0;\n else\n val = Math.exp(-((knnDistances[i][j] - rhos[i]) / sigmas[i]));\n rows[i * nNeighbors + j] = i;\n cols[i * nNeighbors + j] = knnIndices[i][j];\n vals[i * nNeighbors + j] = val;\n }\n }\n return { rows, cols, vals };\n }\n /**\n * Initialize a fuzzy simplicial set embedding, using a specified\n * initialisation method and then minimizing the fuzzy set cross entropy\n * between the 1-skeletons of the high and low dimensional fuzzy simplicial\n * sets.\n */\n initializeSimplicialSetEmbedding() {\n const nEpochs = this.getNEpochs();\n const { nComponents } = this;\n const graphValues = this.graph.getValues();\n let graphMax = 0;\n for (let i = 0; i < graphValues.length; i++) {\n const value = graphValues[i];\n if (graphMax < graphValues[i])\n graphMax = value;\n }\n const graph = this.graph.map((value) => {\n if (value < graphMax / nEpochs)\n return 0;\n else\n return value;\n });\n // We're not computing the spectral initialization in this implementation\n // until we determine a better eigenvalue/eigenvector computation\n // approach\n this.embedding = utils.zeros(graph.nRows).map(() => {\n return utils.zeros(nComponents).map(() => {\n return utils.tauRand(this.random) * 20 + -10; // Random from -10 to 10\n });\n });\n // Get graph data in ordered way...\n const weights = [];\n const head = [];\n const tail = [];\n const rowColValues = graph.getAll();\n for (let i = 0; i < rowColValues.length; i++) {\n const entry = rowColValues[i];\n if (entry.value) {\n weights.push(entry.value);\n tail.push(entry.row);\n head.push(entry.col);\n }\n }\n const epochsPerSample = this.makeEpochsPerSample(weights, nEpochs);\n return { head, tail, epochsPerSample };\n }\n /**\n * Given a set of weights and number of epochs generate the number of\n * epochs per sample for each weight.\n */\n makeEpochsPerSample(weights, nEpochs) {\n const result = utils.filled(weights.length, -1.0);\n const max = utils.max(weights);\n const nSamples = weights.map((w) => (w / max) * nEpochs);\n nSamples.forEach((n, i) => {\n if (n > 0)\n result[i] = nEpochs / nSamples[i];\n });\n return result;\n }\n /**\n * Assigns optimization state parameters from a partial optimization state.\n */\n assignOptimizationStateParameters(state) {\n Object.assign(this.optimizationState, state);\n }\n /**\n * Sets a few optimization state parameters that are necessary before entering\n * the optimization step loop.\n */\n prepareForOptimizationLoop() {\n // Hyperparameters\n const { repulsionStrength, learningRate, negativeSampleRate } = this;\n const { epochsPerSample, headEmbedding, tailEmbedding, } = this.optimizationState;\n const dim = headEmbedding[0].length;\n const moveOther = headEmbedding.length === tailEmbedding.length;\n const epochsPerNegativeSample = epochsPerSample.map((e) => e / negativeSampleRate);\n const epochOfNextNegativeSample = [...epochsPerNegativeSample];\n const epochOfNextSample = [...epochsPerSample];\n this.assignOptimizationStateParameters({\n epochOfNextSample,\n epochOfNextNegativeSample,\n epochsPerNegativeSample,\n moveOther,\n initialAlpha: learningRate,\n alpha: learningRate,\n gamma: repulsionStrength,\n dim,\n });\n }\n /**\n * Initializes optimization state for stepwise optimization.\n */\n initializeOptimization() {\n // Algorithm state\n const headEmbedding = this.embedding;\n const tailEmbedding = this.embedding;\n // Initialized in initializeSimplicialSetEmbedding()\n const { head, tail, epochsPerSample } = this.optimizationState;\n const nEpochs = this.getNEpochs();\n const nVertices = this.graph.nCols;\n const { a, b } = findABParams(this.spread, this.minDist);\n this.assignOptimizationStateParameters({\n headEmbedding,\n tailEmbedding,\n head,\n tail,\n epochsPerSample,\n a,\n b,\n nEpochs,\n nVertices,\n });\n }\n /**\n * Improve an embedding using stochastic gradient descent to minimize the\n * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n * and low dimensional fuzzy simplicial sets. In practice this is done by\n * sampling edges based on their membership strength (with the (1-p) terms\n * coming from negative sampling similar to word2vec).\n */\n optimizeLayoutStep(n) {\n const { optimizationState } = this;\n const { head, tail, headEmbedding, tailEmbedding, epochsPerSample, epochOfNextSample, epochOfNextNegativeSample, epochsPerNegativeSample, moveOther, initialAlpha, alpha, gamma, a, b, dim, nEpochs, nVertices, } = optimizationState;\n const clipValue = 4.0;\n for (let i = 0; i < epochsPerSample.length; i++) {\n if (epochOfNextSample[i] > n)\n continue;\n const j = head[i];\n const k = tail[i];\n const current = headEmbedding[j];\n const other = tailEmbedding[k];\n const distSquared = rDist(current, other);\n let gradCoeff = 0;\n if (distSquared > 0) {\n gradCoeff = -2.0 * a * b * Math.pow(distSquared, b - 1.0);\n gradCoeff /= a * Math.pow(distSquared, b) + 1.0;\n }\n for (let d = 0; d < dim; d++) {\n const gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n current[d] += gradD * alpha;\n if (moveOther)\n other[d] += -gradD * alpha;\n }\n epochOfNextSample[i] += epochsPerSample[i];\n const nNegSamples = Math.floor((n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]);\n for (let p = 0; p < nNegSamples; p++) {\n const k = utils.tauRandInt(nVertices, this.random);\n const other = tailEmbedding[k];\n const distSquared = rDist(current, other);\n let gradCoeff = 0.0;\n if (distSquared > 0.0) {\n gradCoeff = 2.0 * gamma * b;\n gradCoeff /=\n (0.001 + distSquared) * (a * Math.pow(distSquared, b) + 1);\n }\n else if (j === k) {\n continue;\n }\n for (let d = 0; d < dim; d++) {\n let gradD = 4.0;\n if (gradCoeff > 0.0)\n gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n current[d] += gradD * alpha;\n }\n }\n epochOfNextNegativeSample[i] += nNegSamples * epochsPerNegativeSample[i];\n }\n optimizationState.alpha = initialAlpha * (1.0 - n / nEpochs);\n optimizationState.currentEpoch += 1;\n return headEmbedding;\n }\n /**\n * Improve an embedding using stochastic gradient descent to minimize the\n * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n * and low dimensional fuzzy simplicial sets. In practice this is done by\n * sampling edges based on their membership strength (with the (1-p) terms\n * coming from negative sampling similar to word2vec).\n */\n optimizeLayoutAsync(epochCallback = () => true) {\n return new Promise((resolve, reject) => {\n const step = async () => {\n try {\n const { nEpochs, currentEpoch } = this.optimizationState;\n this.embedding = this.optimizeLayoutStep(currentEpoch);\n const epochCompleted = this.optimizationState.currentEpoch;\n const shouldStop = epochCallback(epochCompleted) === false;\n const isFinished = epochCompleted === nEpochs;\n if (!shouldStop && !isFinished)\n setTimeout(() => step(), 0);\n else\n return resolve(isFinished);\n }\n catch (err) {\n reject(err);\n }\n };\n setTimeout(() => step(), 0);\n });\n }\n /**\n * Improve an embedding using stochastic gradient descent to minimize the\n * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n * and low dimensional fuzzy simplicial sets. In practice this is done by\n * sampling edges based on their membership strength (with the (1-p) terms\n * coming from negative sampling similar to word2vec).\n */\n optimizeLayout(epochCallback = () => true) {\n let isFinished = false;\n let embedding = [];\n while (!isFinished) {\n const { nEpochs, currentEpoch } = this.optimizationState;\n embedding = this.optimizeLayoutStep(currentEpoch);\n const epochCompleted = this.optimizationState.currentEpoch;\n const shouldStop = epochCallback(epochCompleted) === false;\n isFinished = epochCompleted === nEpochs || shouldStop;\n }\n return embedding;\n }\n /**\n * Gets the number of epochs for optimizing the projection.\n * NOTE: This heuristic differs from the python version\n */\n getNEpochs() {\n const graph = this.graph;\n if (this.nEpochs > 0)\n return this.nEpochs;\n if (!graph)\n return 200;\n const length = graph.nRows;\n if (length <= 2500)\n return 500;\n else if (length <= 5000)\n return 400;\n else if (length <= 7500)\n return 300;\n else\n return 200;\n }\n}\nexport function euclidean(x, y) {\n let result = 0;\n for (let i = 0; i < x.length; i++)\n result += (x[i] - y[i]) ** 2;\n return Math.sqrt(result);\n}\nexport function numeric(x, y) {\n const result = Math.abs(x - y);\n return result;\n}\nexport function cosine(x, y) {\n let result = 0.0;\n let normX = 0.0;\n let normY = 0.0;\n for (let i = 0; i < x.length; i++) {\n result += x[i] * y[i];\n normX += x[i] ** 2;\n normY += y[i] ** 2;\n }\n if (normX === 0 && normY === 0)\n return 0;\n else if (normX === 0 || normY === 0)\n return 1.0;\n else\n return 1.0 - result / Math.sqrt(normX * normY);\n}\n/**\n * An interface representing the optimization state tracked between steps of\n * the SGD optimization\n */\nclass OptimizationState {\n constructor() {\n this.currentEpoch = 0;\n // Data tracked during optimization steps.\n this.headEmbedding = [];\n this.tailEmbedding = [];\n this.head = [];\n this.tail = [];\n this.epochsPerSample = [];\n this.epochOfNextSample = [];\n this.epochOfNextNegativeSample = [];\n this.epochsPerNegativeSample = [];\n this.moveOther = true;\n this.initialAlpha = 1.0;\n this.alpha = 1.0;\n this.gamma = 1.0;\n this.a = 1.5769434603113077;\n this.b = 0.8950608779109733;\n this.dim = 2;\n this.nEpochs = 500;\n this.nVertices = 0;\n }\n}\n/**\n * Standard clamping of a value into a fixed range\n */\nfunction clip(x, clipValue) {\n if (x > clipValue)\n return clipValue;\n else if (x < -clipValue)\n return -clipValue;\n else\n return x;\n}\n/**\n * Reduced Euclidean distance.\n */\nfunction rDist(x, y) {\n let result = 0.0;\n for (let i = 0; i < x.length; i++)\n result += Math.pow(x[i] - y[i], 2);\n return result;\n}\n/**\n * Fit a, b params for the differentiable curve used in lower\n * dimensional fuzzy simplicial complex construction. We want the\n * smooth curve (from a pre-defined family with simple gradient) that\n * best matches an offset exponential decay.\n */\nexport function findABParams(spread, minDist) {\n const curve = ([a, b]) => (x) => {\n return 1.0 / (1.0 + a * x ** (2 * b));\n };\n const xv = utils\n .linear(0, spread * 3, 300)\n .map((val) => (val < minDist ? 1.0 : val));\n const yv = utils.zeros(xv.length).map((val, index) => {\n const gte = xv[index] >= minDist;\n return gte ? Math.exp(-(xv[index] - minDist) / spread) : val;\n });\n const initialValues = [0.5, 0.5];\n const data = { x: xv, y: yv };\n // Default options for the algorithm (from github example)\n const options = {\n damping: 1.5,\n initialValues,\n gradientDifference: 10e-2,\n maxIterations: 100,\n errorTolerance: 10e-3,\n };\n // eslint-disable-next-line new-cap\n const { parameterValues } = LM(data, curve, options);\n const [a, b] = parameterValues;\n return { a, b };\n}\n/**\n * Under the assumption of categorical distance for the intersecting\n * simplicial set perform a fast intersection.\n */\nexport function fastIntersection(graph, target, unknownDist = 1.0, farDist = 5.0) {\n return graph.map((value, row, col) => {\n if (target[row] === -1 || target[col] === -1)\n return value * Math.exp(-unknownDist);\n else if (target[row] !== target[col])\n return value * Math.exp(-farDist);\n else\n return value;\n });\n}\n/**\n * Reset the local connectivity requirement -- each data sample should\n * have complete confidence in at least one 1-simplex in the simplicial set.\n * We can enforce this by locally rescaling confidences, and then remerging the\n * different local simplicial sets together.\n */\nexport function resetLocalConnectivity(simplicialSet) {\n simplicialSet = matrix.normalize(simplicialSet, \"max\" /* matrix.NormType.max */);\n const transpose = matrix.transpose(simplicialSet);\n const prodMatrix = matrix.pairwiseMultiply(transpose, simplicialSet);\n simplicialSet = matrix.add(simplicialSet, matrix.subtract(transpose, prodMatrix));\n return matrix.eliminateZeros(simplicialSet);\n}\n/**\n * Given indices and weights and an original embeddings\n * initialize the positions of new points relative to the\n * indices and weights (of their neighbors in the source data).\n */\nexport function initTransform(indices, weights, embedding) {\n const result = utils\n .zeros(indices.length)\n .map((_z) => utils.zeros(embedding[0].length));\n for (let i = 0; i < indices.length; i++) {\n for (let j = 0; j < indices[0].length; j++) {\n for (let d = 0; d < embedding[0].length; d++) {\n const a = indices[i][j];\n result[i][d] += weights[i][j] * embedding[a][d];\n }\n }\n }\n return result;\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"umap.js","sourceRoot":"","sources":["umap.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable max-len */\n/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n *   list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n *   this list of conditions and the following disclaimer in the documentation\n *   and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n *   contributors may be used to endorse or promote products derived from\n *   this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport * as heap from './heap';\nimport * as matrix from './matrix';\nimport * as nnDescent from './nn_descent';\nimport * as tree from './tree';\nimport * as utils from './utils';\nimport LM from 'ml-levenberg-marquardt';\n\nexport type DistanceFn = (x: number, y: number) => number;\nexport type RandomFn = () => number;\nexport type EpochCallback = (epoch: number) => boolean | void;\nexport type Vector = number[];\nexport type Vectors = Vector[];\nexport const enum TargetMetric {\n  categorical = 'categorical',\n  l1 = 'l1',\n  l2 = 'l2',\n}\n\nconst SMOOTH_K_TOLERANCE = 1e-5;\nconst MIN_K_DIST_SCALE = 1e-3;\n\nexport interface UMAPParameters {\n  /**\n   * The distance function with which to assess nearest neighbors, defaults\n   * to euclidean distance.\n   */\n  distanceFn?: DistanceFn;\n  /**\n   * The initial learning rate for the embedding optimization.\n   */\n  learningRate?: number;\n  /**\n   * The local connectivity required -- i.e. the number of nearest\n   * neighbors that should be assumed to be connected at a local level.\n   * The higher this value the more connected the manifold becomes\n   * locally. In practice this should be not more than the local intrinsic\n   * dimension of the manifold.\n   */\n  localConnectivity?: number;\n  /**\n   * The effective minimum distance between embedded points. Smaller values\n   * will result in a more clustered/clumped embedding where nearby points\n   * on the manifold are drawn closer together, while larger values will\n   * result on a more even dispersal of points. The value should be set\n   * relative to the ``spread`` value, which determines the scale at which\n   * embedded points will be spread out.\n   */\n  minDist?: number;\n  /**\n   * The dimension of the space to embed into. This defaults to 2 to\n   * provide easy visualization, but can reasonably be set to any\n   * integer value in the range 2 to 100.\n   */\n  nComponents?: number;\n  /**\n   * The number of training epochs to be used in optimizing the\n   * low dimensional embedding. Larger values result in more accurate\n   * embeddings. If None is specified a value will be selected based on\n   * the size of the input dataset (200 for large datasets, 500 for small).\n   */\n  nEpochs?: number;\n  /**\n   * The size of local neighborhood (in terms of number of neighboring\n   * sample points) used for manifold approximation. Larger values\n   * result in more global views of the manifold, while smaller\n   * values result in more local data being preserved. In general\n   * values should be in the range 2 to 100.\n   */\n  nNeighbors?: number;\n  /**\n   * The number of negative samples to select per positive sample\n   * in the optimization process. Increasing this value will result\n   * in greater repulsive force being applied, greater optimization\n   * cost, but slightly more accuracy.\n   */\n  negativeSampleRate?: number;\n  /**\n   * Weighting applied to negative samples in low dimensional embedding\n   * optimization. Values higher than one will result in greater weight\n   * being given to negative samples.\n   */\n  repulsionStrength?: number;\n  /**\n   * The pseudo-random number generator used by the stochastic parts of the\n   * algorithm.\n   */\n  random?: RandomFn;\n  /**\n   * Interpolate between (fuzzy) union and intersection as the set operation\n   * used to combine local fuzzy simplicial sets to obtain a global fuzzy\n   * simplicial sets. Both fuzzy set operations use the product t-norm.\n   * The value of this parameter should be between 0.0 and 1.0; a value of\n   * 1.0 will use a pure fuzzy union, while 0.0 will use a pure fuzzy\n   * intersection.\n   */\n  setOpMixRatio?: number;\n  /**\n   * The effective scale of embedded points. In combination with ``min_dist``\n   * this determines how clustered/clumped the embedded points are.\n   */\n  spread?: number;\n  /**\n   * For transform operations (embedding new points using a trained model)\n   * this will control how aggressively to search for nearest neighbors.\n   * Larger values will result in slower performance but more accurate\n   * nearest neighbor evaluation.\n   */\n  transformQueueSize?: number;\n}\n\nexport interface UMAPSupervisedParams {\n  /**\n   * The metric used to measure distance for a target array is using supervised\n   * dimension reduction. By default this is 'categorical' which will measure\n   * distance in terms of whether categories match or are different. Furthermore,\n   * if semi-supervised is required target values of -1 will be treated as\n   * unlabelled under the 'categorical' metric. If the target array takes\n   * continuous values (e.g. for a regression problem) then metric of 'l1'\n   * or 'l2' is probably more appropriate.\n   */\n  targetMetric?: TargetMetric;\n  /**\n   * Weighting factor between data topology and target topology. A value of\n   * 0.0 weights entirely on data, a value of 1.0 weights entirely on target.\n   * The default of 0.5 balances the weighting equally between data and target.\n   */\n  targetWeight?: number;\n  /**\n   * The number of nearest neighbors to use to construct the target simplcial\n   * set. Defaults to the `nearestNeighbors` parameter.\n   */\n  targetNNeighbors?: number;\n}\n\n/**\n * UMAP projection system, based on the python implementation from McInnes, L,\n * Healy, J, UMAP: Uniform Manifold Approximation and Projection for Dimension\n * Reduction (https://github.com/lmcinnes/umap).\n *\n * This implementation differs in a few regards:\n * a) The initialization of the embedding for optimization is not computed using\n *    a spectral method, rather it is initialized randomly. This avoids some\n *    computationally intensive matrix eigen computations that aren't easily\n *    ported to JavaScript.\n * b) A lot of \"extra\" functionality has been omitted from this implementation,\n *    most notably a great deal of alternate distance functions.\n *\n * This implementation provides three methods of reducing dimensionality:\n * 1) fit: fit the data synchronously\n * 2) fitAsync: fit the data asynchronously, with a callback function provided\n *      that is invoked on each optimization step.\n * 3) initializeFit / step: manually initialize the algorithm then explictly\n *      step through each epoch of the SGD optimization\n */\nexport class UMAP {\n  public learningRate = 1.0;\n  public localConnectivity = 1.0;\n  public minDist = 0.1;\n  public nComponents = 2;\n  private nEpochs = 0;\n  private nNeighbors = 15;\n  public negativeSampleRate = 5;\n  public random = Math.random;\n  public repulsionStrength = 1.0;\n  public setOpMixRatio = 1.0;\n  public spread = 1.0;\n  private transformQueueSize = 4.0;\n\n  // Supervised projection params\n  private targetMetric = TargetMetric.categorical;\n  private targetWeight = 0.5;\n  private targetNNeighbors = 15;\n\n  private distanceFn: DistanceFn = numeric;\n\n  // KNN state (can be precomputed and supplied via initializeFit)\n  private knnIndices?: number[][];\n  private knnDistances?: number[][];\n\n  // Internal graph connectivity representation\n  private graph!: matrix.SparseMatrix;\n  private X!: Vector;\n  private isInitialized = false;\n  private rpForest: tree.FlatTree[] = [];\n  private initFromRandom!: nnDescent.InitFromRandomFn;\n  private initFromTree!: nnDescent.InitFromTreeFn;\n  private search!: nnDescent.SearchFn;\n  private searchGraph!: matrix.SparseMatrix;\n\n  // Supervised projection labels / targets\n  private Y?: number[];\n\n  // Projected embedding\n  private embedding: number[][] = [];\n  private optimizationState = new OptimizationState();\n\n\n  get neighbors() {\n    return this.nNeighbors;\n  }\n  constructor(params: UMAPParameters = {}) {\n    const setParam = (key: keyof UMAPParameters) => {\n      //@ts-ignore\n      if (params[key] !== undefined) this[key] = params[key];\n    };\n\n    setParam('distanceFn');\n    setParam('learningRate');\n    setParam('localConnectivity');\n    setParam('minDist');\n    setParam('nComponents');\n    setParam('nEpochs');\n    setParam('nNeighbors');\n    setParam('negativeSampleRate');\n    setParam('random');\n    setParam('repulsionStrength');\n    setParam('setOpMixRatio');\n    setParam('spread');\n    setParam('transformQueueSize');\n    this.targetNNeighbors = params.nNeighbors || this.nNeighbors || this.targetNNeighbors;\n  }\n\n  /**\n   * Fit the data to a projected embedding space synchronously.\n   */\n  fit(X: Vector) {\n    this.initializeFit(X);\n    this.optimizeLayout();\n\n    return this.embedding;\n  }\n\n  /**\n   * Fit the data to a projected embedding space asynchronously, with a callback\n   * function invoked on every epoch of optimization.\n   */\n  async fitAsync(\n    X: Vector,\n    callback: (epochNumber: number) => void | boolean = () => true\n  ) {\n    this.initializeFit(X);\n\n    await this.optimizeLayoutAsync(callback);\n    return this.embedding;\n  }\n\n  /**\n   * Initializes parameters needed for supervised projection.\n   */\n  setSupervisedProjection(Y: number[], params: UMAPSupervisedParams = {}) {\n    this.Y = Y;\n    this.targetMetric = params.targetMetric || this.targetMetric;\n    this.targetWeight = params.targetWeight || this.targetWeight;\n    this.targetNNeighbors = params.targetNNeighbors || this.targetNNeighbors;\n  }\n\n  /**\n   * Initializes umap with precomputed KNN indices and distances.\n   */\n  setPrecomputedKNN(knnIndices: number[][], knnDistances: number[][]) {\n    this.knnIndices = knnIndices;\n    this.knnDistances = knnDistances;\n  }\n\n  /**\n   * Initializes fit by computing KNN and a fuzzy simplicial set, as well as\n   * initializing the projected embeddings. Sets the optimization state ahead\n   * of optimization steps. Returns the number of epochs to be used for the\n   * SGD optimization.\n   */\n  initializeFit(X: Vector): number {\n    if (X.length <= this.nNeighbors)\n      throw new Error(`Not enough data points (${X.length}) to create nNeighbors: ${this.nNeighbors}.  Add more data points or adjust the configuration.`);\n\n\n    // We don't need to reinitialize if we've already initialized for this data.\n    if (this.X === X && this.isInitialized)\n      return this.getNEpochs();\n\n\n    this.X = X;\n\n    if (!this.knnIndices && !this.knnDistances) {\n      const knnResults = this.nearestNeighbors(X);\n      this.knnIndices = knnResults.knnIndices;\n      this.knnDistances = knnResults.knnDistances;\n    }\n\n    this.graph = this.fuzzySimplicialSet(\n      X,\n      this.nNeighbors,\n      this.setOpMixRatio\n    );\n\n    // Set up the search graph for subsequent transformation.\n    this.makeSearchFns();\n    this.searchGraph = this.makeSearchGraph(X);\n\n    // Check if supervised projection, then adjust the graph.\n    this.processGraphForSupervisedProjection();\n\n    const {\n      head,\n      tail,\n      epochsPerSample,\n    } = this.initializeSimplicialSetEmbedding();\n\n    // Set the optimization routine state\n    this.optimizationState.head = head;\n    this.optimizationState.tail = tail;\n    this.optimizationState.epochsPerSample = epochsPerSample;\n\n    // Now, initialize the optimization steps\n    this.initializeOptimization();\n    this.prepareForOptimizationLoop();\n    this.isInitialized = true;\n\n    return this.getNEpochs();\n  }\n\n  private makeSearchFns() {\n    const {initFromTree, initFromRandom} = nnDescent.makeInitializations(\n      this.distanceFn\n    );\n    this.initFromTree = initFromTree;\n    this.initFromRandom = initFromRandom;\n    this.search = nnDescent.makeInitializedNNSearch(this.distanceFn);\n  }\n\n  private makeSearchGraph(X: Vector) {\n    const knnIndices = this.knnIndices!;\n    const knnDistances = this.knnDistances!;\n    const dims = [X.length, X.length];\n    const searchGraph = new matrix.SparseMatrix([], [], [], dims);\n    for (let i = 0; i < knnIndices.length; i++) {\n      const knn = knnIndices[i];\n      const distances = knnDistances[i];\n      for (let j = 0; j < knn.length; j++) {\n        const neighbor = knn[j];\n        const distance = distances[j];\n        if (distance > 0)\n          searchGraph.set(i, neighbor, distance);\n      }\n    }\n\n    const transpose = matrix.transpose(searchGraph);\n    return matrix.maximum(searchGraph, transpose);\n  }\n\n  /**\n   * Transforms data to the existing embedding space.\n   */\n  transform(toTransform: Vector) {\n    // Use the previous rawData\n    const rawData = this.X;\n    if (rawData === undefined || rawData.length === 0)\n      throw new Error('No data has been fit.');\n\n\n    let nNeighbors = Math.floor(this.nNeighbors * this.transformQueueSize);\n    nNeighbors = Math.min(rawData.length, nNeighbors);\n    const init = nnDescent.initializeSearch(\n      this.rpForest,\n      rawData,\n      toTransform,\n      nNeighbors,\n      this.initFromRandom,\n      this.initFromTree,\n      this.random\n    );\n\n    const result = this.search(rawData, this.searchGraph, init, toTransform);\n\n    let {indices, weights: distances} = heap.deheapSort(result);\n\n    indices = indices.map((x) => x.slice(0, this.nNeighbors));\n    distances = distances.map((x) => x.slice(0, this.nNeighbors));\n\n    const adjustedLocalConnectivity = Math.max(0, this.localConnectivity - 1);\n    const {sigmas, rhos} = this.smoothKNNDistance(\n      distances,\n      this.nNeighbors,\n      adjustedLocalConnectivity\n    );\n\n    const {rows, cols, vals} = this.computeMembershipStrengths(\n      indices,\n      distances,\n      sigmas,\n      rhos\n    );\n\n    const size = [toTransform.length, rawData.length];\n    let graph = new matrix.SparseMatrix(rows, cols, vals, size);\n\n    // This was a very specially constructed graph with constant degree.\n    // That lets us do fancy unpacking by reshaping the csr matrix indices\n    // and data. Doing so relies on the constant degree assumption!\n\n    const normed = matrix.normalize(graph, matrix.NormType.l1);\n\n    const csrMatrix = matrix.getCSR(normed);\n    const nPoints = toTransform.length;\n\n    const eIndices = utils.reshape2d(\n      csrMatrix.indices,\n      nPoints,\n      this.nNeighbors\n    );\n\n    const eWeights = utils.reshape2d(\n      csrMatrix.values,\n      nPoints,\n      this.nNeighbors\n    );\n\n    const embedding = initTransform(eIndices, eWeights, this.embedding);\n\n    const nEpochs = this.nEpochs ?\n      this.nEpochs / 3 :\n      graph.nRows <= 10000 ?\n        100 :\n        30;\n\n    const graphMax = graph\n      .getValues()\n      .reduce((max, val) => (val > max ? val : max), 0);\n    graph = graph.map((value) => (value < graphMax / nEpochs ? 0 : value));\n    graph = matrix.eliminateZeros(graph);\n\n    const epochsPerSample = this.makeEpochsPerSample(\n      graph.getValues(),\n      nEpochs\n    );\n    const head = graph.getRows();\n    const tail = graph.getCols();\n\n    // Initialize optimization slightly differently than the fit method.\n    this.assignOptimizationStateParameters({\n      headEmbedding: embedding,\n      tailEmbedding: this.embedding,\n      head,\n      tail,\n      currentEpoch: 0,\n      nEpochs,\n      nVertices: graph.getDims()[1],\n      epochsPerSample,\n    });\n    this.prepareForOptimizationLoop();\n\n    return this.optimizeLayout();\n  }\n\n  /**\n   * Checks if we're using supervised projection, then process the graph\n   * accordingly.\n   */\n  private processGraphForSupervisedProjection() {\n    const {Y, X} = this;\n    if (Y) {\n      if (Y.length !== X.length)\n        throw new Error('Length of X and y must be equal');\n\n\n      if (this.targetMetric === TargetMetric.categorical) {\n        const lt = this.targetWeight < 1.0;\n        const farDist = lt ? 2.5 * (1.0 / (1.0 - this.targetWeight)) : 1.0e12;\n        this.graph = this.categoricalSimplicialSetIntersection(\n          this.graph,\n          Y,\n          farDist\n        );\n      }\n      // TODO (andycoenen@): add non-categorical supervised embeddings.\n    }\n  }\n\n  /**\n   * Manually step through the optimization process one epoch at a time.\n   */\n  step() {\n    const {currentEpoch} = this.optimizationState;\n\n    if (currentEpoch < this.getNEpochs())\n      this.optimizeLayoutStep(currentEpoch);\n\n    return this.optimizationState.currentEpoch;\n  }\n\n  /**\n   * Returns the computed projected embedding.\n   */\n  getEmbedding() {\n    return this.embedding;\n  }\n\n  /**\n   * Compute the ``nNeighbors`` nearest points for each data point in ``X``\n   * This may be exact, but more likely is approximated via nearest neighbor\n   * descent.\n   */\n  private nearestNeighbors(X: Vector) {\n    const {distanceFn, nNeighbors} = this;\n    const log2 = (n: number) => Math.log(n) / Math.log(2);\n    const metricNNDescent = nnDescent.makeNNDescent(distanceFn, this.random);\n\n    // Handle python3 rounding down from 0.5 discrpancy\n    const round = (n: number) => {\n      return n === 0.5 ? 0 : Math.round(n);\n    };\n\n    const nTrees = 5 + Math.floor(round(X.length ** 0.5 / 20.0));\n    const nIters = Math.max(5, Math.floor(Math.round(log2(X.length))));\n\n    this.rpForest = tree.makeForest(X, nNeighbors, nTrees, this.random);\n\n    const leafArray = tree.makeLeafArray(this.rpForest);\n    const {indices, weights} = metricNNDescent(\n      X,\n      leafArray,\n      nNeighbors,\n      nIters\n    );\n    return {knnIndices: indices, knnDistances: weights};\n  }\n\n  /**\n   * Given a set of data X, a neighborhood size, and a measure of distance\n   * compute the fuzzy simplicial set (here represented as a fuzzy graph in\n   * the form of a sparse matrix) associated to the data. This is done by\n   * locally approximating geodesic distance at each point, creating a fuzzy\n   * simplicial set for each such point, and then combining all the local\n   * fuzzy simplicial sets into a global one via a fuzzy union.\n   */\n  private fuzzySimplicialSet(\n    X: Vector,\n    nNeighbors: number,\n    setOpMixRatio = 1.0\n  ) {\n    const {knnIndices = [], knnDistances = [], localConnectivity} = this;\n\n    const {sigmas, rhos} = this.smoothKNNDistance(\n      knnDistances,\n      nNeighbors,\n      localConnectivity\n    );\n\n    const {rows, cols, vals} = this.computeMembershipStrengths(\n      knnIndices,\n      knnDistances,\n      sigmas,\n      rhos\n    );\n\n    const size = [X.length, X.length];\n    const sparseMatrix = new matrix.SparseMatrix(rows, cols, vals, size);\n\n    const transpose = matrix.transpose(sparseMatrix);\n    const prodMatrix = matrix.pairwiseMultiply(sparseMatrix, transpose);\n\n    const a = matrix.subtract(matrix.add(sparseMatrix, transpose), prodMatrix);\n    const b = matrix.multiplyScalar(a, setOpMixRatio);\n    const c = matrix.multiplyScalar(prodMatrix, 1.0 - setOpMixRatio);\n    const result = matrix.add(b, c);\n\n    return result;\n  }\n\n  /**\n   * Combine a fuzzy simplicial set with another fuzzy simplicial set\n   * generated from categorical data using categorical distances. The target\n   * data is assumed to be categorical label data (a vector of labels),\n   * and this will update the fuzzy simplicial set to respect that label data.\n   */\n  private categoricalSimplicialSetIntersection(\n    simplicialSet: matrix.SparseMatrix,\n    target: number[],\n    farDist: number,\n    unknownDist = 1.0\n  ) {\n    let intersection = fastIntersection(\n      simplicialSet,\n      target,\n      unknownDist,\n      farDist\n    );\n    intersection = matrix.eliminateZeros(intersection);\n    return resetLocalConnectivity(intersection);\n  }\n\n  /**\n   * Compute a continuous version of the distance to the kth nearest\n   * neighbor. That is, this is similar to knn-distance but allows continuous\n   * k values rather than requiring an integral k. In esscence we are simply\n   * computing the distance such that the cardinality of fuzzy set we generate\n   * is k.\n   */\n  private smoothKNNDistance(\n    distances: Vectors,\n    k: number,\n    localConnectivity = 1.0,\n    nIter = 64,\n    bandwidth = 1.0\n  ) {\n    const target = (Math.log(k) / Math.log(2)) * bandwidth;\n    const rho = utils.zeros(distances.length);\n    const result = utils.zeros(distances.length);\n\n    for (let i = 0; i < distances.length; i++) {\n      let lo = 0.0;\n      let hi = Infinity;\n      let mid = 1.0;\n\n      // TODO: This is very inefficient, but will do for now. FIXME\n      const ithDistances = distances[i];\n      const nonZeroDists = ithDistances.filter((d) => d > 0.0);\n\n      if (nonZeroDists.length >= localConnectivity) {\n        const index = Math.floor(localConnectivity);\n        const interpolation = localConnectivity - index;\n        if (index > 0) {\n          rho[i] = nonZeroDists[index - 1];\n          if (interpolation > SMOOTH_K_TOLERANCE) {\n            rho[i] +=\n              interpolation * (nonZeroDists[index] - nonZeroDists[index - 1]);\n          }\n        } else {\n          rho[i] = interpolation * nonZeroDists[0];\n        }\n      } else if (nonZeroDists.length > 0) {\n        rho[i] = utils.max(nonZeroDists);\n      }\n\n      for (let n = 0; n < nIter; n++) {\n        let psum = 0.0;\n        for (let j = 1; j < distances[i].length; j++) {\n          const d = distances[i][j] - rho[i];\n          if (d > 0)\n            psum += Math.exp(-(d / mid));\n          else\n            psum += 1.0;\n        }\n\n        if (Math.abs(psum - target) < SMOOTH_K_TOLERANCE)\n          break;\n\n\n        if (psum > target) {\n          hi = mid;\n          mid = (lo + hi) / 2.0;\n        } else {\n          lo = mid;\n          if (hi === Infinity)\n            mid *= 2;\n          else\n            mid = (lo + hi) / 2.0;\n        }\n      }\n\n      result[i] = mid;\n\n      // TODO: This is very inefficient, but will do for now. FIXME\n      if (rho[i] > 0.0) {\n        const meanIthDistances = utils.mean(ithDistances);\n        if (result[i] < MIN_K_DIST_SCALE * meanIthDistances)\n          result[i] = MIN_K_DIST_SCALE * meanIthDistances;\n      } else {\n        const meanDistances = utils.mean(distances.map(utils.mean));\n        if (result[i] < MIN_K_DIST_SCALE * meanDistances)\n          result[i] = MIN_K_DIST_SCALE * meanDistances;\n      }\n    }\n\n    return {sigmas: result, rhos: rho};\n  }\n\n  /**\n   * Construct the membership strength data for the 1-skeleton of each local\n   * fuzzy simplicial set -- this is formed as a sparse matrix where each row is\n   * a local fuzzy simplicial set, with a membership strength for the\n   * 1-simplex to each other data point.\n   */\n  private computeMembershipStrengths(\n    knnIndices: Vectors,\n    knnDistances: Vectors,\n    sigmas: number[],\n    rhos: number[]\n  ): { rows: number[]; cols: number[]; vals: number[] } {\n    const nSamples = knnIndices.length;\n    const nNeighbors = knnIndices[0].length;\n\n    const rows = utils.zeros(nSamples * nNeighbors);\n    const cols = utils.zeros(nSamples * nNeighbors);\n    const vals = utils.zeros(nSamples * nNeighbors);\n\n    for (let i = 0; i < nSamples; i++) {\n      for (let j = 0; j < nNeighbors; j++) {\n        let val = 0;\n        if (knnIndices[i][j] === -1)\n          continue; // We didn't get the full knn for i\n\n        if (knnIndices[i][j] === i)\n          val = 0.0;\n        else if (knnDistances[i][j] - rhos[i] <= 0.0)\n          val = 1.0;\n        else\n          val = Math.exp(-((knnDistances[i][j] - rhos[i]) / sigmas[i]));\n\n\n        rows[i * nNeighbors + j] = i;\n        cols[i * nNeighbors + j] = knnIndices[i][j];\n        vals[i * nNeighbors + j] = val;\n      }\n    }\n\n    return {rows, cols, vals};\n  }\n\n  /**\n   * Initialize a fuzzy simplicial set embedding, using a specified\n   * initialisation method and then minimizing the fuzzy set cross entropy\n   * between the 1-skeletons of the high and low dimensional fuzzy simplicial\n   * sets.\n   */\n  private initializeSimplicialSetEmbedding() {\n    const nEpochs = this.getNEpochs();\n\n    const {nComponents} = this;\n    const graphValues = this.graph.getValues();\n    let graphMax = 0;\n    for (let i = 0; i < graphValues.length; i++) {\n      const value = graphValues[i];\n      if (graphMax < graphValues[i])\n        graphMax = value;\n    }\n\n    const graph = this.graph.map((value) => {\n      if (value < graphMax / nEpochs)\n        return 0;\n      else\n        return value;\n    });\n\n    // We're not computing the spectral initialization in this implementation\n    // until we determine a better eigenvalue/eigenvector computation\n    // approach\n    this.embedding = utils.zeros(graph.nRows).map(() => {\n      return utils.zeros(nComponents).map(() => {\n        return utils.tauRand(this.random) * 20 + -10; // Random from -10 to 10\n      });\n    });\n\n    // Get graph data in ordered way...\n    const weights: number[] = [];\n    const head: number[] = [];\n    const tail: number[] = [];\n    const rowColValues = graph.getAll();\n    for (let i = 0; i < rowColValues.length; i++) {\n      const entry = rowColValues[i];\n      if (entry.value) {\n        weights.push(entry.value);\n        tail.push(entry.row);\n        head.push(entry.col);\n      }\n    }\n    const epochsPerSample = this.makeEpochsPerSample(weights, nEpochs);\n\n    return {head, tail, epochsPerSample};\n  }\n\n  /**\n   * Given a set of weights and number of epochs generate the number of\n   * epochs per sample for each weight.\n   */\n  private makeEpochsPerSample(weights: number[], nEpochs: number) {\n    const result = utils.filled(weights.length, -1.0);\n    const max = utils.max(weights);\n    const nSamples = weights.map((w) => (w / max) * nEpochs);\n    nSamples.forEach((n, i) => {\n      if (n > 0) result[i] = nEpochs / nSamples[i];\n    });\n    return result;\n  }\n\n  /**\n   * Assigns optimization state parameters from a partial optimization state.\n   */\n  private assignOptimizationStateParameters(state: Partial<OptimizationState>) {\n    Object.assign(this.optimizationState, state);\n  }\n\n  /**\n   * Sets a few optimization state parameters that are necessary before entering\n   * the optimization step loop.\n   */\n  private prepareForOptimizationLoop() {\n    // Hyperparameters\n    const {repulsionStrength, learningRate, negativeSampleRate} = this;\n\n    const {\n      epochsPerSample,\n      headEmbedding,\n      tailEmbedding,\n    } = this.optimizationState;\n\n    const dim = headEmbedding[0].length;\n    const moveOther = headEmbedding.length === tailEmbedding.length;\n\n    const epochsPerNegativeSample = epochsPerSample.map(\n      (e) => e / negativeSampleRate\n    );\n    const epochOfNextNegativeSample = [...epochsPerNegativeSample];\n    const epochOfNextSample = [...epochsPerSample];\n\n    this.assignOptimizationStateParameters({\n      epochOfNextSample,\n      epochOfNextNegativeSample,\n      epochsPerNegativeSample,\n      moveOther,\n      initialAlpha: learningRate,\n      alpha: learningRate,\n      gamma: repulsionStrength,\n      dim,\n    });\n  }\n\n  /**\n   * Initializes optimization state for stepwise optimization.\n   */\n  private initializeOptimization() {\n    // Algorithm state\n    const headEmbedding = this.embedding;\n    const tailEmbedding = this.embedding;\n\n    // Initialized in initializeSimplicialSetEmbedding()\n    const {head, tail, epochsPerSample} = this.optimizationState;\n\n    const nEpochs = this.getNEpochs();\n    const nVertices = this.graph.nCols;\n\n    const {a, b} = findABParams(this.spread, this.minDist);\n\n    this.assignOptimizationStateParameters({\n      headEmbedding,\n      tailEmbedding,\n      head,\n      tail,\n      epochsPerSample,\n      a,\n      b,\n      nEpochs,\n      nVertices,\n    });\n  }\n\n  /**\n   * Improve an embedding using stochastic gradient descent to minimize the\n   * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n   * and low dimensional fuzzy simplicial sets. In practice this is done by\n   * sampling edges based on their membership strength (with the (1-p) terms\n   * coming from negative sampling similar to word2vec).\n   */\n  private optimizeLayoutStep(n: number) {\n    const {optimizationState} = this;\n    const {\n      head,\n      tail,\n      headEmbedding,\n      tailEmbedding,\n      epochsPerSample,\n      epochOfNextSample,\n      epochOfNextNegativeSample,\n      epochsPerNegativeSample,\n      moveOther,\n      initialAlpha,\n      alpha,\n      gamma,\n      a,\n      b,\n      dim,\n      nEpochs,\n      nVertices,\n    } = optimizationState;\n\n    const clipValue = 4.0;\n\n    for (let i = 0; i < epochsPerSample.length; i++) {\n      if (epochOfNextSample[i] > n)\n        continue;\n\n\n      const j = head[i];\n      const k = tail[i];\n\n      const current = headEmbedding[j];\n      const other = tailEmbedding[k];\n\n      const distSquared = rDist(current, other);\n\n      let gradCoeff = 0;\n      if (distSquared > 0) {\n        gradCoeff = -2.0 * a * b * Math.pow(distSquared, b - 1.0);\n        gradCoeff /= a * Math.pow(distSquared, b) + 1.0;\n      }\n\n      for (let d = 0; d < dim; d++) {\n        const gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n        current[d] += gradD * alpha;\n        if (moveOther)\n          other[d] += -gradD * alpha;\n      }\n\n      epochOfNextSample[i] += epochsPerSample[i];\n\n      const nNegSamples = Math.floor(\n        (n - epochOfNextNegativeSample[i]) / epochsPerNegativeSample[i]\n      );\n\n      for (let p = 0; p < nNegSamples; p++) {\n        const k = utils.tauRandInt(nVertices, this.random);\n        const other = tailEmbedding[k];\n\n        const distSquared = rDist(current, other);\n\n        let gradCoeff = 0.0;\n        if (distSquared > 0.0) {\n          gradCoeff = 2.0 * gamma * b;\n          gradCoeff /=\n            (0.001 + distSquared) * (a * Math.pow(distSquared, b) + 1);\n        } else if (j === k) {\n          continue;\n        }\n\n        for (let d = 0; d < dim; d++) {\n          let gradD = 4.0;\n          if (gradCoeff > 0.0)\n            gradD = clip(gradCoeff * (current[d] - other[d]), clipValue);\n\n          current[d] += gradD * alpha;\n        }\n      }\n      epochOfNextNegativeSample[i] += nNegSamples * epochsPerNegativeSample[i];\n    }\n    optimizationState.alpha = initialAlpha * (1.0 - n / nEpochs);\n\n    optimizationState.currentEpoch += 1;\n    return headEmbedding;\n  }\n\n  /**\n   * Improve an embedding using stochastic gradient descent to minimize the\n   * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n   * and low dimensional fuzzy simplicial sets. In practice this is done by\n   * sampling edges based on their membership strength (with the (1-p) terms\n   * coming from negative sampling similar to word2vec).\n   */\n  private optimizeLayoutAsync(\n    epochCallback: (epochNumber: number) => void | boolean = () => true\n  ): Promise<boolean> {\n    return new Promise((resolve, reject) => {\n      const step = async () => {\n        try {\n          const {nEpochs, currentEpoch} = this.optimizationState;\n          this.embedding = this.optimizeLayoutStep(currentEpoch);\n          const epochCompleted = this.optimizationState.currentEpoch;\n          const shouldStop = epochCallback(epochCompleted) === false;\n          const isFinished = epochCompleted === nEpochs;\n          if (!shouldStop && !isFinished)\n            setTimeout(() => step(), 0);\n          else\n            return resolve(isFinished);\n        } catch (err) {\n          reject(err);\n        }\n      };\n      setTimeout(() => step(), 0);\n    });\n  }\n\n  /**\n   * Improve an embedding using stochastic gradient descent to minimize the\n   * fuzzy set cross entropy between the 1-skeletons of the high dimensional\n   * and low dimensional fuzzy simplicial sets. In practice this is done by\n   * sampling edges based on their membership strength (with the (1-p) terms\n   * coming from negative sampling similar to word2vec).\n   */\n  private optimizeLayout(\n    epochCallback: (epochNumber: number) => void | boolean = () => true\n  ): Vectors {\n    let isFinished = false;\n    let embedding: Vectors = [];\n    while (!isFinished) {\n      const {nEpochs, currentEpoch} = this.optimizationState;\n      embedding = this.optimizeLayoutStep(currentEpoch);\n      const epochCompleted = this.optimizationState.currentEpoch;\n      const shouldStop = epochCallback(epochCompleted) === false;\n      isFinished = epochCompleted === nEpochs || shouldStop;\n    }\n    return embedding;\n  }\n\n  /**\n   * Gets the number of epochs for optimizing the projection.\n   * NOTE: This heuristic differs from the python version\n   */\n  public getNEpochs() {\n    const graph = this.graph;\n\n    if (this.nEpochs > 0)\n      return this.nEpochs;\n\n\n    if (!graph)\n      return 200;\n\n\n    const length = graph.nRows;\n    if (length <= 2500)\n      return 500;\n    else if (length <= 5000)\n      return 400;\n    else if (length <= 7500)\n      return 300;\n    else\n      return 200;\n  }\n}\n\nexport function euclidean(x: Vector, y: Vector) {\n  let result = 0;\n  for (let i = 0; i < x.length; i++)\n    result += (x[i] - y[i]) ** 2;\n\n  return Math.sqrt(result);\n}\n\nexport function numeric(x: number, y: number) {\n  const result = Math.abs(x - y);\n  return result;\n}\n\nexport function cosine(x: Vector, y: Vector) {\n  let result = 0.0;\n  let normX = 0.0;\n  let normY = 0.0;\n\n  for (let i = 0; i < x.length; i++) {\n    result += x[i] * y[i];\n    normX += x[i] ** 2;\n    normY += y[i] ** 2;\n  }\n\n  if (normX === 0 && normY === 0)\n    return 0;\n  else if (normX === 0 || normY === 0)\n    return 1.0;\n  else\n    return 1.0 - result / Math.sqrt(normX * normY);\n}\n\n/**\n * An interface representing the optimization state tracked between steps of\n * the SGD optimization\n */\nclass OptimizationState {\n  currentEpoch = 0;\n\n  // Data tracked during optimization steps.\n  headEmbedding: number[][] = [];\n  tailEmbedding: number[][] = [];\n  head: number[] = [];\n  tail: number[] = [];\n  epochsPerSample: number[] = [];\n  epochOfNextSample: number[] = [];\n  epochOfNextNegativeSample: number[] = [];\n  epochsPerNegativeSample: number[] = [];\n  moveOther = true;\n  initialAlpha = 1.0;\n  alpha = 1.0;\n  gamma = 1.0;\n  a = 1.5769434603113077;\n  b = 0.8950608779109733;\n  dim = 2;\n  nEpochs = 500;\n  nVertices = 0;\n}\n\n/**\n * Standard clamping of a value into a fixed range\n */\nfunction clip(x: number, clipValue: number) {\n  if (x > clipValue) return clipValue;\n  else if (x < -clipValue) return -clipValue;\n  else return x;\n}\n\n/**\n * Reduced Euclidean distance.\n */\nfunction rDist(x: number[], y: number[]) {\n  let result = 0.0;\n  for (let i = 0; i < x.length; i++)\n    result += Math.pow(x[i] - y[i], 2);\n\n  return result;\n}\n\n/**\n * Fit a, b params for the differentiable curve used in lower\n * dimensional fuzzy simplicial complex construction. We want the\n * smooth curve (from a pre-defined family with simple gradient) that\n * best matches an offset exponential decay.\n */\nexport function findABParams(spread: number, minDist: number) {\n  const curve = ([a, b]: number[]) => (x: number) => {\n    return 1.0 / (1.0 + a * x ** (2 * b));\n  };\n\n  const xv = utils\n    .linear(0, spread * 3, 300)\n    .map((val) => (val < minDist ? 1.0 : val));\n\n  const yv = utils.zeros(xv.length).map((val, index) => {\n    const gte = xv[index] >= minDist;\n    return gte ? Math.exp(-(xv[index] - minDist) / spread) : val;\n  });\n\n  const initialValues = [0.5, 0.5];\n  const data = {x: xv, y: yv};\n\n  // Default options for the algorithm (from github example)\n  const options = {\n    damping: 1.5,\n    initialValues,\n    gradientDifference: 10e-2,\n    maxIterations: 100,\n    errorTolerance: 10e-3,\n  };\n\n  // eslint-disable-next-line new-cap\n  const {parameterValues} = LM(data, curve, options);\n  const [a, b] = parameterValues as number[];\n  return {a, b};\n}\n\n/**\n * Under the assumption of categorical distance for the intersecting\n * simplicial set perform a fast intersection.\n */\nexport function fastIntersection(\n  graph: matrix.SparseMatrix,\n  target: number[],\n  unknownDist = 1.0,\n  farDist = 5.0\n) {\n  return graph.map((value, row, col) => {\n    if (target[row] === -1 || target[col] === -1)\n      return value * Math.exp(-unknownDist);\n    else if (target[row] !== target[col])\n      return value * Math.exp(-farDist);\n    else\n      return value;\n  });\n}\n\n/**\n * Reset the local connectivity requirement -- each data sample should\n * have complete confidence in at least one 1-simplex in the simplicial set.\n * We can enforce this by locally rescaling confidences, and then remerging the\n * different local simplicial sets together.\n */\nexport function resetLocalConnectivity(simplicialSet: matrix.SparseMatrix) {\n  simplicialSet = matrix.normalize(simplicialSet, matrix.NormType.max);\n  const transpose = matrix.transpose(simplicialSet);\n  const prodMatrix = matrix.pairwiseMultiply(transpose, simplicialSet);\n  simplicialSet = matrix.add(\n    simplicialSet,\n    matrix.subtract(transpose, prodMatrix)\n  );\n  return matrix.eliminateZeros(simplicialSet);\n}\n\n/**\n * Given indices and weights and an original embeddings\n * initialize the positions of new points relative to the\n * indices and weights (of their neighbors in the source data).\n */\nexport function initTransform(\n  indices: number[][],\n  weights: number[][],\n  embedding: Vectors\n) {\n  const result = utils\n    .zeros(indices.length)\n    .map((_z) => utils.zeros(embedding[0].length));\n\n  for (let i = 0; i < indices.length; i++) {\n    for (let j = 0; j < indices[0].length; j++) {\n      for (let d = 0; d < embedding[0].length; d++) {\n        const a = indices[i][j];\n        result[i][d] += weights[i][j] * embedding[a][d];\n      }\n    }\n  }\n  return result;\n}\n"]}","/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n * list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n * this list of conditions and the following disclaimer in the documentation\n * and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n * contributors may be used to endorse or promote products derived from\n * this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\nimport * as heap from './heap';\nimport * as matrix from './matrix';\nimport * as tree from './tree';\nimport * as utils from './utils';\n/**\n * Create a version of nearest neighbor descent.\n */\nexport function makeNNDescent(distanceFn, random) {\n return function nNDescent(data, leafArray, nNeighbors, nIters = 10, maxCandidates = 50, delta = 0.001, rho = 0.5, rpTreeInit = true) {\n const nVertices = data.length;\n const currentGraph = heap.makeHeap(data.length, nNeighbors);\n for (let i = 0; i < data.length; i++) {\n const indices = heap.rejectionSample(nNeighbors, data.length, random);\n for (let j = 0; j < indices.length; j++) {\n const d = distanceFn(data[i], data[indices[j]]);\n heap.heapPush(currentGraph, i, d, indices[j], 1);\n heap.heapPush(currentGraph, indices[j], d, i, 1);\n }\n }\n if (rpTreeInit) {\n for (let n = 0; n < leafArray.length; n++) {\n for (let i = 0; i < leafArray[n].length; i++) {\n if (leafArray[n][i] < 0)\n break;\n for (let j = i + 1; j < leafArray[n].length; j++) {\n if (leafArray[n][j] < 0)\n break;\n const d = distanceFn(data[leafArray[n][i]], data[leafArray[n][j]]);\n heap.heapPush(currentGraph, leafArray[n][i], d, leafArray[n][j], 1);\n heap.heapPush(currentGraph, leafArray[n][j], d, leafArray[n][i], 1);\n }\n }\n }\n }\n for (let n = 0; n < nIters; n++) {\n const candidateNeighbors = heap.buildCandidates(currentGraph, nVertices, nNeighbors, maxCandidates, random);\n let c = 0;\n for (let i = 0; i < nVertices; i++) {\n for (let j = 0; j < maxCandidates; j++) {\n const p = Math.floor(candidateNeighbors[0][i][j]);\n if (p < 0 || utils.tauRand(random) < rho)\n continue;\n for (let k = 0; k < maxCandidates; k++) {\n const q = Math.floor(candidateNeighbors[0][i][k]);\n const cj = candidateNeighbors[2][i][j];\n const ck = candidateNeighbors[2][i][k];\n if (q < 0 || (!cj && !ck))\n continue;\n const d = distanceFn(data[p], data[q]);\n c += heap.heapPush(currentGraph, p, d, q, 1);\n c += heap.heapPush(currentGraph, q, d, p, 1);\n }\n }\n }\n if (c <= delta * nNeighbors * data.length)\n break;\n }\n const sorted = heap.deheapSort(currentGraph);\n return sorted;\n };\n}\nexport function makeInitializations(distanceFn) {\n function initFromRandom(nNeighbors, data, queryPoints, _heap, random) {\n for (let i = 0; i < queryPoints.length; i++) {\n const indices = utils.rejectionSample(nNeighbors, data.length, random);\n for (let j = 0; j < indices.length; j++) {\n if (indices[j] < 0)\n continue;\n const d = distanceFn(data[indices[j]], queryPoints[i]);\n heap.heapPush(_heap, i, d, indices[j], 1);\n }\n }\n }\n function initFromTree(_tree, data, queryPoints, _heap, random) {\n for (let i = 0; i < queryPoints.length; i++) {\n const indices = tree.searchFlatTree(queryPoints[i], _tree, random);\n for (let j = 0; j < indices.length; j++) {\n if (indices[j] < 0)\n return;\n const d = distanceFn(data[indices[j]], queryPoints[i]);\n heap.heapPush(_heap, i, d, indices[j], 1);\n }\n }\n return;\n }\n return { initFromRandom, initFromTree };\n}\nexport function makeInitializedNNSearch(distanceFn) {\n return function nnSearchFn(data, graph, initialization, queryPoints) {\n const { indices, indptr } = matrix.getCSR(graph);\n for (let i = 0; i < queryPoints.length; i++) {\n const tried = new Set(initialization[0][i]);\n while (true) {\n // Find smallest flagged vertex\n const vertex = heap.smallestFlagged(initialization, i);\n if (vertex === -1)\n break;\n const candidates = indices.slice(indptr[vertex], indptr[vertex + 1]);\n for (const candidate of candidates) {\n if (candidate === vertex ||\n candidate === -1 ||\n tried.has(candidate))\n continue;\n const d = distanceFn(data[candidate], queryPoints[i]);\n heap.uncheckedHeapPush(initialization, i, d, candidate, 1);\n tried.add(candidate);\n }\n }\n }\n return initialization;\n };\n}\nexport function initializeSearch(forest, data, queryPoints, nNeighbors, initFromRandom, initFromTree, random) {\n const results = heap.makeHeap(queryPoints.length, nNeighbors);\n initFromRandom(nNeighbors, data, queryPoints, results, random);\n if (forest) {\n for (const tree of forest)\n initFromTree(tree, data, queryPoints, results, random);\n }\n return results;\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nn_descent.js","sourceRoot":"","sources":["nn_descent.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n *\n * Copyright 2019 Google LLC. All Rights Reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * ==============================================================================\n */\n\n/**\n * This is a JavaScript reimplementation of UMAP (original license below), from\n * the python implementation found at https://github.com/lmcinnes/umap.\n *\n * @author andycoenen@google.com (Andy Coenen)\n */\n\n/**\n * @license\n * BSD 3-Clause License\n *\n * Copyright (c) 2017, Leland McInnes\n * All rights reserved.\n *\n * Redistribution and use in source and binary forms, with or without\n * modification, are permitted provided that the following conditions are met:\n *\n * * Redistributions of source code must retain the above copyright notice, this\n *   list of conditions and the following disclaimer.\n *\n * * Redistributions in binary form must reproduce the above copyright notice,\n *   this list of conditions and the following disclaimer in the documentation\n *   and/or other materials provided with the distribution.\n *\n * * Neither the name of the copyright holder nor the names of its\n *   contributors may be used to endorse or promote products derived from\n *   this software without specific prior written permission.\n *\n * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\"\n * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\n * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\n * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\n * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\n * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\n * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\n * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\n * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\n */\n\nimport * as heap from './heap';\nimport * as matrix from './matrix';\nimport * as tree from './tree';\nimport * as utils from './utils';\nimport {RandomFn, Vectors, DistanceFn, Vector} from './umap';\n\n/**\n * Create a version of nearest neighbor descent.\n */\nexport function makeNNDescent(distanceFn: DistanceFn, random: RandomFn) {\n  return function nNDescent(\n    data: Vector,\n    leafArray: Vectors,\n    nNeighbors: number,\n    nIters = 10,\n    maxCandidates = 50,\n    delta = 0.001,\n    rho = 0.5,\n    rpTreeInit = true\n  ) {\n    const nVertices = data.length;\n    const currentGraph = heap.makeHeap(data.length, nNeighbors);\n\n    for (let i = 0; i < data.length; i++) {\n      const indices = heap.rejectionSample(nNeighbors, data.length, random);\n      for (let j = 0; j < indices.length; j++) {\n        const d = distanceFn(data[i], data[indices[j]]);\n\n        heap.heapPush(currentGraph, i, d, indices[j], 1);\n        heap.heapPush(currentGraph, indices[j], d, i, 1);\n      }\n    }\n    if (rpTreeInit) {\n      for (let n = 0; n < leafArray.length; n++) {\n        for (let i = 0; i < leafArray[n].length; i++) {\n          if (leafArray[n][i] < 0)\n            break;\n\n          for (let j = i + 1; j < leafArray[n].length; j++) {\n            if (leafArray[n][j] < 0)\n              break;\n\n            const d = distanceFn(data[leafArray[n][i]], data[leafArray[n][j]]);\n            heap.heapPush(currentGraph, leafArray[n][i], d, leafArray[n][j], 1);\n            heap.heapPush(currentGraph, leafArray[n][j], d, leafArray[n][i], 1);\n          }\n        }\n      }\n    }\n\n    for (let n = 0; n < nIters; n++) {\n      const candidateNeighbors = heap.buildCandidates(\n        currentGraph,\n        nVertices,\n        nNeighbors,\n        maxCandidates,\n        random\n      );\n\n      let c = 0;\n      for (let i = 0; i < nVertices; i++) {\n        for (let j = 0; j < maxCandidates; j++) {\n          const p = Math.floor(candidateNeighbors[0][i][j]);\n          if (p < 0 || utils.tauRand(random) < rho)\n            continue;\n\n          for (let k = 0; k < maxCandidates; k++) {\n            const q = Math.floor(candidateNeighbors[0][i][k]);\n            const cj = candidateNeighbors[2][i][j];\n            const ck = candidateNeighbors[2][i][k];\n            if (q < 0 || (!cj && !ck))\n              continue;\n\n\n            const d = distanceFn(data[p], data[q]);\n            c += heap.heapPush(currentGraph, p, d, q, 1);\n            c += heap.heapPush(currentGraph, q, d, p, 1);\n          }\n        }\n      }\n      if (c <= delta * nNeighbors * data.length)\n        break;\n    }\n    const sorted = heap.deheapSort(currentGraph);\n    return sorted;\n  };\n}\n\nexport type InitFromRandomFn = (\n  nNeighbors: number,\n  data: Vector,\n  queryPoints: Vector,\n  _heap: heap.Heap,\n  random: RandomFn\n) => void;\n\nexport type InitFromTreeFn = (\n  _tree: tree.FlatTree,\n  data: Vector,\n  queryPoints: Vector,\n  _heap: heap.Heap,\n  random: RandomFn\n) => void;\n\nexport function makeInitializations(distanceFn: DistanceFn) {\n  function initFromRandom(\n    nNeighbors: number,\n    data: Vector,\n    queryPoints: Vector,\n    _heap: heap.Heap,\n    random: RandomFn\n  ) {\n    for (let i = 0; i < queryPoints.length; i++) {\n      const indices = utils.rejectionSample(nNeighbors, data.length, random);\n      for (let j = 0; j < indices.length; j++) {\n        if (indices[j] < 0)\n          continue;\n\n        const d = distanceFn(data[indices[j]], queryPoints[i]);\n        heap.heapPush(_heap, i, d, indices[j], 1);\n      }\n    }\n  }\n\n  function initFromTree(\n    _tree: tree.FlatTree,\n    data: Vector,\n    queryPoints: Vector,\n    _heap: heap.Heap,\n    random: RandomFn\n  ) {\n    for (let i = 0; i < queryPoints.length; i++) {\n      const indices = tree.searchFlatTree(queryPoints[i], _tree, random);\n\n      for (let j = 0; j < indices.length; j++) {\n        if (indices[j] < 0)\n          return;\n\n        const d = distanceFn(data[indices[j]], queryPoints[i]);\n        heap.heapPush(_heap, i, d, indices[j], 1);\n      }\n    }\n    return;\n  }\n\n  return {initFromRandom, initFromTree};\n}\n\nexport type SearchFn = (\n  data: Vector,\n  graph: matrix.SparseMatrix,\n  initialization: heap.Heap,\n  queryPoints: Vector\n) => heap.Heap;\n\nexport function makeInitializedNNSearch(distanceFn: DistanceFn) {\n  return function nnSearchFn(\n    data: Vector,\n    graph: matrix.SparseMatrix,\n    initialization: heap.Heap,\n    queryPoints: Vector\n  ) {\n    const {indices, indptr} = matrix.getCSR(graph);\n\n    for (let i = 0; i < queryPoints.length; i++) {\n      const tried = new Set(initialization[0][i]);\n      while (true) {\n        // Find smallest flagged vertex\n        const vertex = heap.smallestFlagged(initialization, i);\n\n        if (vertex === -1)\n          break;\n\n        const candidates = indices.slice(indptr[vertex], indptr[vertex + 1]);\n        for (const candidate of candidates) {\n          if (\n            candidate === vertex ||\n            candidate === -1 ||\n            tried.has(candidate)\n          )\n            continue;\n\n          const d = distanceFn(data[candidate], queryPoints[i]);\n          heap.uncheckedHeapPush(initialization, i, d, candidate, 1);\n          tried.add(candidate);\n        }\n      }\n    }\n    return initialization;\n  };\n}\n\nexport function initializeSearch(\n  forest: tree.FlatTree[],\n  data: Vector,\n  queryPoints: Vector,\n  nNeighbors: number,\n  initFromRandom: InitFromRandomFn,\n  initFromTree: InitFromTreeFn,\n  random: RandomFn\n) {\n  const results = heap.makeHeap(queryPoints.length, nNeighbors);\n  initFromRandom(nNeighbors, data, queryPoints, results, random);\n  if (forest) {\n    for (const tree of forest)\n      initFromTree(tree, data, queryPoints, results, random);\n  }\n  return results;\n}\n"]}","import isArray from 'is-any-array';\n\nimport errorCalculation from './errorCalculation';\nimport step from './step';\n\n/**\n * Curve fitting algorithm\n * @param {{x:Array<number>, y:Array<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @param {object} [options] - Options object\n * @param {number} [options.damping] - Levenberg-Marquardt parameter\n * @param {number} [options.gradientDifference = 10e-2] - Adjustment for decrease the damping parameter\n * @param {Array<number>} [options.minValues] - Minimum allowed values for parameters\n * @param {Array<number>} [options.maxValues] - Maximum allowed values for parameters\n * @param {Array<number>} [options.initialValues] - Array of initial parameter values\n * @param {number} [options.maxIterations = 100] - Maximum of allowed iterations\n * @param {number} [options.errorTolerance = 10e-3] - Minimum uncertainty allowed for each point\n * @return {{parameterValues: Array<number>, parameterError: number, iterations: number}}\n */\nexport default function levenbergMarquardt(\n data,\n parameterizedFunction,\n options = {},\n) {\n let {\n maxIterations = 100,\n gradientDifference = 10e-2,\n damping = 0,\n errorTolerance = 10e-3,\n minValues,\n maxValues,\n initialValues,\n } = options;\n\n if (damping <= 0) {\n throw new Error('The damping option must be a positive number');\n } else if (!data.x || !data.y) {\n throw new Error('The data parameter must have x and y elements');\n } else if (\n !isArray(data.x) ||\n data.x.length < 2 ||\n !isArray(data.y) ||\n data.y.length < 2\n ) {\n throw new Error(\n 'The data parameter elements must be an array with more than 2 points',\n );\n } else if (data.x.length !== data.y.length) {\n throw new Error('The data parameter elements must have the same size');\n }\n\n let parameters =\n initialValues || new Array(parameterizedFunction.length).fill(1);\n let parLen = parameters.length;\n maxValues = maxValues || new Array(parLen).fill(Number.MAX_SAFE_INTEGER);\n minValues = minValues || new Array(parLen).fill(Number.MIN_SAFE_INTEGER);\n\n if (maxValues.length !== minValues.length) {\n throw new Error('minValues and maxValues must be the same size');\n }\n\n if (!isArray(parameters)) {\n throw new Error('initialValues must be an array');\n }\n\n let error = errorCalculation(data, parameters, parameterizedFunction);\n\n let converged = error <= errorTolerance;\n\n let iteration;\n for (iteration = 0; iteration < maxIterations && !converged; iteration++) {\n parameters = step(\n data,\n parameters,\n damping,\n gradientDifference,\n parameterizedFunction,\n );\n\n for (let k = 0; k < parLen; k++) {\n parameters[k] = Math.min(\n Math.max(minValues[k], parameters[k]),\n maxValues[k],\n );\n }\n\n error = errorCalculation(data, parameters, parameterizedFunction);\n if (isNaN(error)) break;\n converged = error <= errorTolerance;\n }\n\n return {\n parameterValues: parameters,\n parameterError: error,\n iterations: iteration,\n };\n}\n","import { dmLinearIndex } from '../distance-matrix';\nexport class TSNE {\n assert(condition, message) {\n if (!condition)\n throw message || 'Assertion failed';\n }\n // syntax sugar\n getopt(opt, field, defaultval) {\n if (opt.hasOwnProperty(field))\n return opt[field];\n else\n return defaultval;\n }\n gaussRandom() {\n if (this.returnV) {\n this.returnV = false;\n return this.vValue;\n }\n const u = 2 * this.random() - 1;\n const v = 2 * this.random() - 1;\n const r = u * u + v * v;\n if (r === 0 || r > 1)\n return this.gaussRandom();\n const c = Math.sqrt(-2 * Math.log(r) / r);\n this.vValue = v * c; // cache this for next function call for efficiency\n this.returnV = true;\n return u * c;\n }\n // return random normal number\n randn(mu, std) {\n return mu + this.gaussRandom() * std;\n }\n // utilitity that creates contiguous vector of zeros of size n\n zeros(n) {\n if (typeof (n) === 'undefined' || isNaN(n))\n return new Float32Array();\n if (typeof ArrayBuffer === 'undefined') {\n // lacking browser support\n const arr = new Float32Array(n);\n for (let i = 0; i < n; i++)\n arr[i] = 0;\n return arr;\n }\n else {\n return new Float32Array(n); // typed arrays are faster\n }\n }\n // utility that returns 2d array filled with random numbers\n // or with value s, if provided\n randn2d(n, d, s) {\n const uses = typeof s !== 'undefined';\n const x = (new Array(n)).fill(null).map(() => new Float32Array(d));\n if (uses) {\n for (let i = 0; i < n; i++)\n x[i] = new Float32Array(d).fill(s);\n }\n else {\n for (let i = 0; i < n; i++) {\n for (let j = 0; j < d; j++)\n x[i][j] = this.randn(0.0, 1e-4);\n }\n }\n return x;\n }\n // compute L2 distance between two vectors\n l2(x1, x2) {\n const D = x1.length;\n let d = 0;\n for (let i = 0; i < D; i++) {\n const x1i = x1[i];\n const x2i = x2[i];\n d += (x1i - x2i) * (x1i - x2i);\n }\n return d;\n }\n // compute pairwise distance in all vectors in X\n xtod(X) {\n const N = X.length;\n const dist = this.zeros(N * N); // allocate contiguous array\n for (let i = 0; i < N; i++) {\n for (let j = i + 1; j < N; j++) {\n const d = this.l2(X[i], X[j]);\n dist[i * N + j] = d;\n dist[j * N + i] = d;\n }\n }\n return dist;\n }\n getIterSize(rowSize) {\n if (rowSize <= 2000)\n return 100;\n else if (rowSize <= 3000)\n return 90;\n else if (rowSize <= 5000)\n return 80;\n else\n return 70;\n }\n // compute (p_{i|j} + p_{j|i})/(2n)\n d2p(D, perplexity, tol, rowSize) {\n // const nf = Math.sqrt(D.length); // this better be an integer\n // const n = Math.floor(nf);\n // this.assert(n === nf, 'D should have square number of elements.');\n const indexer = dmLinearIndex(rowSize);\n const distances = new Float32Array(rowSize * rowSize);\n for (let i = 0; i < rowSize; i++) {\n for (let j = i + 1; j < rowSize; j++)\n distances[i * rowSize + j] = distances[j * rowSize + i] = D[indexer(i, j)];\n }\n const n = rowSize;\n const hTarget = Math.log(perplexity); // target entropy of distribution\n const P = this.zeros(n * n); // temporary probability matrix\n const prow = this.zeros(n); // a temporary storage compartment\n for (let i = 0; i < n; i++) {\n let betamin = -Infinity;\n let betamax = Infinity;\n let beta = 1; // initial value of precision\n let done = false;\n const maxtries = Math.floor(this.getIterSize(rowSize) / 5);\n // perform binary search to find a suitable precision beta\n // so that the entropy of the distribution is appropriate\n let num = 0;\n while (!done) {\n //debugger;\n // compute entropy and kernel row with beta precision\n let psum = 0.0;\n for (let j = 0; j < n; j++) {\n const pj = i === j ? 0 : Math.exp(-distances[i * n + j] * beta);\n prow[j] = pj;\n psum += pj;\n }\n // normalize p and compute entropy\n let nHere = 0.0;\n for (let j = 0; j < n; j++) {\n let pj;\n if (psum === 0)\n pj = 0;\n else\n pj = prow[j] / psum;\n prow[j] = pj;\n if (pj > 1e-7)\n nHere -= pj * Math.log(pj);\n }\n // adjust beta based on result\n if (nHere > hTarget) {\n // entropy was too high (distribution too diffuse)\n // so we need to increase the precision for more peaky distribution\n betamin = beta; // move up the bounds\n if (betamax === Infinity)\n beta = beta * 2;\n else\n beta = (beta + betamax) / 2;\n }\n else {\n // converse case. make distrubtion less peaky\n betamax = beta;\n if (betamin === -Infinity)\n beta = beta / 2;\n else\n beta = (beta + betamin) / 2;\n }\n // stopping conditions: too many tries or got a good precision\n num++;\n if (Math.abs(nHere - hTarget) < tol)\n done = true;\n if (num >= maxtries)\n done = true;\n }\n // console.log('data point ' + i + ' gets precision ' + beta + ' after ' + num + ' binary search steps.');\n // copy over the final prow to P at row i\n for (let j = 0; j < n; j++)\n P[i * n + j] = prow[j];\n } // end loop over examples i\n // symmetrize P and normalize it to sum to 1 over all ij\n const pOut = this.zeros(n * n);\n const N2 = n * 2;\n for (let i = 0; i < n; i++) {\n for (let j = 0; j < n; j++)\n pOut[i * n + j] = Math.max((P[i * n + j] + P[j * n + i]) / N2, 1e-100);\n }\n return pOut;\n }\n // helper function\n sign(x) { return x > 0 ? 1 : x < 0 ? -1 : 0; }\n constructor(opt) {\n this.iter = 0;\n this.random = Math.random;\n // return 0 mean unit standard deviation random number\n this.returnV = false;\n this.vValue = 0.0;\n opt = opt || {};\n this.perplexity = this.getopt(opt, 'perplexity', 30); // effective number of nearest neighbors\n this.dim = this.getopt(opt, 'dim', 2); // by default 2-D tSNE\n this.epsilon = this.getopt(opt, 'epsilon', 10); // learning rate\n this.random = this.getopt(opt, 'random', Math.random); // random number generator\n }\n // this function takes a set of high-dimensional points\n // and creates matrix P from them using gaussian kernel\n initDataRaw(X) {\n const N = X.length;\n const D = X[0].length;\n this.assert(N > 0, ' X is empty? You must have some data!');\n this.assert(D > 0, ' X[0] is empty? Where is the data?');\n const dists = this.xtod(X); // convert X to distances using gaussian kernel\n this.P = this.d2p(dists, this.perplexity, 1e-4, D); // attach to object\n this.N = N; // back up the size of the dataset\n this.initSolution(); // refresh this\n }\n // this function takes a given distance matrix and creates\n // matrix P from them.\n // D is assumed to be provided as a list of lists, and should be symmetric\n initDataDist(D, rowSize) {\n const N = D.length;\n this.assert(N > 0, ' X is empty? You must have some data!');\n // convert D to a (fast) typed array version\n // dists.forEach((d) => console.log(d));\n console.time('distances to matrix');\n this.P = this.d2p(D, this.perplexity, 1e-4, rowSize);\n console.timeEnd('distances to matrix');\n this.N = rowSize;\n this.initSolution(); // refresh this\n }\n // (re)initializes the solution to random\n initSolution() {\n // generate random solution to t-SNE\n this.Y = this.randn2d(this.N, this.dim); // the solution\n this.gains = this.randn2d(this.N, this.dim, 1.0); // step gains to accelerate progress in unchanging directions\n this.ystep = this.randn2d(this.N, this.dim, 0.0); // momentum accumulator\n this.iter = 0;\n }\n // return pointer to current solution\n getSolution() {\n return this.Y;\n }\n // perform a single step of optimization to improve the embedding\n step() {\n this.iter += 1;\n const N = this.N;\n const cg = this.costGrad(this.Y); // evaluate gradient\n const cost = cg.cost;\n const grad = cg.grad;\n // perform gradient step\n const ymean = this.zeros(this.dim);\n for (let i = 0; i < N; i++) {\n for (let d = 0; d < this.dim; d++) {\n const gid = grad[i][d];\n const sid = this.ystep[i][d];\n const gainid = this.gains[i][d];\n // compute gain update\n let newgain = this.sign(gid) === this.sign(sid) ? gainid * 0.8 : gainid + 0.2;\n if (newgain < 0.01)\n newgain = 0.01; // clamp\n this.gains[i][d] = newgain; // store for next turn\n // compute momentum step direction\n const momval = this.iter < 250 ? 0.5 : 0.8;\n const newsid = momval * sid - this.epsilon * newgain * grad[i][d];\n this.ystep[i][d] = newsid; // remember the step we took\n // step!\n this.Y[i][d] += newsid;\n ymean[d] += this.Y[i][d]; // accumulate mean so that we can center later\n }\n }\n // reproject Y to be zero mean\n for (let i = 0; i < N; i++) {\n for (let d = 0; d < this.dim; d++)\n this.Y[i][d] -= ymean[d] / N;\n }\n //if(this.iter%100===0) console.log('iter ' + this.iter + ', cost: ' + cost);\n return cost; // return current cost\n }\n // for debugging: gradient check\n debugGrad() {\n const N = this.N;\n const cg = this.costGrad(this.Y); // evaluate gradient\n //const cost = cg.cost;\n const grad = cg.grad;\n const e = 1e-5;\n for (let i = 0; i < N; i++) {\n for (let d = 0; d < this.dim; d++) {\n const yold = this.Y[i][d];\n this.Y[i][d] = yold + e;\n const cg0 = this.costGrad(this.Y);\n this.Y[i][d] = yold - e;\n const cg1 = this.costGrad(this.Y);\n const analytic = grad[i][d];\n const numerical = (cg0.cost - cg1.cost) / (2 * e);\n console.log(i + ',' + d + ': gradcheck analytic: ' + analytic + ' vs. numerical: ' + numerical);\n this.Y[i][d] = yold;\n }\n }\n }\n // return cost and gradient, given an arrangement\n costGrad(Y) {\n const N = this.N;\n const dim = this.dim; // dim of output space\n const P = this.P;\n const pmul = this.iter < 100 ? 4 : 1; // trick that helps with local optima\n // compute current Q distribution, unnormalized first\n this.quArr ?? (this.quArr = this.zeros(N * N));\n let qsum = 0.0;\n for (let i = 0; i < N; i++) {\n for (let j = i + 1; j < N; j++) {\n const dsum = new Array(dim).reduce((prev, _, d) => prev + Math.pow(Y[i][d] - Y[j][d], 2), 0);\n const qu = 1.0 / (1.0 + dsum); // Student t-distribution\n this.quArr[i * N + j] = qu;\n this.quArr[j * N + i] = qu;\n qsum += 2 * qu;\n }\n }\n // normalize Q distribution to sum to 1\n //const NN = N * N;\n //const Q = this.zeros(NN);\n let cost = 0.0;\n const grad = new Array(N).fill(null).map(() => (new Float32Array(dim)).fill(0.0));\n for (let i = 0; i < N; i++) {\n // const gsum = new Float32Array(dim).fill(0.0); // init grad for point i\n for (let j = i + 1; j < N; j++) {\n const Q = Math.max(this.quArr[i * N + j] / qsum, 1e-100);\n cost += (-P[i * N + j] * Math.log(Q)) * 2; // accumulate cost (the non-constant portion at least...)\n const premult = 4 * (pmul * P[i * N + j] - Q) * this.quArr[i * N + j];\n //console.log(premult, Q, i, j);\n for (let d = 0; d < dim; d++) {\n grad[i][d] += premult * (Y[i][d] - Y[j][d]);\n grad[j][d] += premult * (Y[j][d] - Y[i][d]);\n }\n }\n //grad[i] = gsum;\n }\n return { cost, grad };\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"t-sne.js","sourceRoot":"","sources":["t-sne.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AAGjD,MAAM,OAAO,IAAI;IAWP,MAAM,CAAC,SAAc,EAAE,OAAY;QACzC,IAAI,CAAC,SAAS;YAAE,MAAM,OAAO,IAAI,kBAAkB,CAAC;IACtD,CAAC;IAED,eAAe;IACP,MAAM,CAAC,GAAuB,EAAE,KAAa,EAAE,UAAe;QACpE,IAAI,GAAG,CAAC,cAAc,CAAC,KAAK,CAAC;YAC3B,OAAO,GAAG,CAAC,KAAK,CAAC,CAAC;;YAElB,OAAO,UAAU,CAAC;IACtB,CAAC;IAKC,WAAW;QACT,IAAI,IAAI,CAAC,OAAO,EAAE,CAAC;YACjB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;YACrB,OAAO,IAAI,CAAC,MAAM,CAAC;QACrB,CAAC;QACD,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAChC,MAAM,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;QAChC,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC;YAAE,OAAO,IAAI,CAAC,WAAW,EAAE,CAAC;QAChD,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC1C,IAAI,CAAC,MAAM,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,mDAAmD;QACxE,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QACpB,OAAO,CAAC,GAAG,CAAC,CAAC;IACf,CAAC;IAED,8BAA8B;IACtB,KAAK,CAAC,EAAU,EAAE,GAAW;QACnC,OAAO,EAAE,GAAG,IAAI,CAAC,WAAW,EAAE,GAAG,GAAG,CAAC;IACvC,CAAC;IAED,8DAA8D;IACtD,KAAK,CAAC,CAAS;QACrB,IAAI,OAAO,CAAC,CAAC,CAAC,KAAK,WAAW,IAAI,KAAK,CAAC,CAAC,CAAC;YAAE,OAAO,IAAI,YAAY,EAAE,CAAC;QACtE,IAAI,OAAO,WAAW,KAAK,WAAW,EAAE,CAAC;YACvC,0BAA0B;YAC1B,MAAM,GAAG,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC;YAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;gBAAE,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;YACvC,OAAO,GAAG,CAAC;QACb,CAAC;aAAM,CAAC;YACN,OAAO,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,0BAA0B;QACxD,CAAC;IACH,CAAC;IAED,2DAA2D;IAC3D,+BAA+B;IACvB,OAAO,CAAC,CAAS,EAAE,CAAS,EAAE,CAAU;QAC9C,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,WAAW,CAAC;QACtC,MAAM,CAAC,GAAG,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC;QACnE,IAAI,IAAI,EAAE,CAAC;YACT,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;gBACxB,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,YAAY,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACvC,CAAC;aAAM,CAAC;YACN,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;oBACxB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC;YACpC,CAAC;QACH,CAAC;QACD,OAAO,CAAC,CAAC;IACX,CAAC;IAED,0CAA0C;IAClC,EAAE,CAAC,EAAY,EAAE,EAAY;QACnC,MAAM,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC;QACpB,IAAI,CAAC,GAAG,CAAC,CAAC;QACV,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,MAAM,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;YAClB,MAAM,GAAG,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;YAClB,CAAC,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,CAAC,GAAG,GAAG,GAAG,CAAC,CAAC;QACjC,CAAC;QACD,OAAO,CAAC,CAAC;IACX,CAAC;IAED,gDAAgD;IACxC,IAAI,CAAC,CAAyB;QACpC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;QACnB,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,4BAA4B;QAC5D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC/B,MAAM,CAAC,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC9B,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;gBACpB,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC;YACtB,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAEM,WAAW,CAAC,OAAe;QAChC,IAAI,OAAO,IAAI,IAAI;YACjB,OAAO,GAAG,CAAC;aACR,IAAI,OAAO,IAAI,IAAI;YACtB,OAAO,EAAE,CAAC;aACP,IAAI,OAAO,IAAI,IAAI;YACtB,OAAO,EAAE,CAAC;;YAEV,OAAO,EAAE,CAAC;IACd,CAAC;IAED,mCAAmC;IAC3B,GAAG,CAAC,CAAe,EAAE,UAAkB,EAAE,GAAW,EAAE,OAAe;QAC3E,+DAA+D;QAC/D,4BAA4B;QAC5B,qEAAqE;QACrE,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,CAAC;QACvC,MAAM,SAAS,GAAG,IAAI,YAAY,CAAC,OAAO,GAAG,OAAO,CAAC,CAAC;QACtD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE,EAAE,CAAC;YACjC,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,OAAO,EAAE,CAAC,EAAE;gBAClC,SAAS,CAAC,CAAC,GAAG,OAAO,GAAG,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,GAAG,OAAO,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QAC/E,CAAC;QACD,MAAM,CAAC,GAAG,OAAO,CAAC;QAClB,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,CAAC,iCAAiC;QACvE,MAAM,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,+BAA+B;QAC5D,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,kCAAkC;QAC9D,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,IAAI,OAAO,GAAG,CAAC,QAAQ,CAAC;YACxB,IAAI,OAAO,GAAG,QAAQ,CAAC;YACvB,IAAI,IAAI,GAAG,CAAC,CAAC,CAAC,6BAA6B;YAC3C,IAAI,IAAI,GAAG,KAAK,CAAC;YACjB,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC;YAE3D,0DAA0D;YAC1D,yDAAyD;YACzD,IAAI,GAAG,GAAG,CAAC,CAAC;YACZ,OAAO,CAAC,IAAI,EAAE,CAAC;gBACb,WAAW;gBAEX,qDAAqD;gBACrD,IAAI,IAAI,GAAG,GAAG,CAAC;gBACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC3B,MAAM,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAE,SAAS,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;oBACjE,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;oBACb,IAAI,IAAI,EAAE,CAAC;gBACb,CAAC;gBACD,kCAAkC;gBAClC,IAAI,KAAK,GAAG,GAAG,CAAC;gBAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC3B,IAAI,EAAE,CAAC;oBACP,IAAI,IAAI,KAAK,CAAC;wBACZ,EAAE,GAAG,CAAC,CAAC;;wBAEP,EAAE,GAAG,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;oBAEtB,IAAI,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC;oBACb,IAAI,EAAE,GAAG,IAAI;wBAAE,KAAK,IAAI,EAAE,GAAG,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBAC5C,CAAC;gBAED,8BAA8B;gBAC9B,IAAI,KAAK,GAAG,OAAO,EAAE,CAAC;oBACpB,kDAAkD;oBAClD,mEAAmE;oBACnE,OAAO,GAAG,IAAI,CAAC,CAAC,qBAAqB;oBACrC,IAAI,OAAO,KAAK,QAAQ;wBAAE,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC;;wBAAM,IAAI,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;gBAC9E,CAAC;qBAAM,CAAC;oBACN,6CAA6C;oBAC7C,OAAO,GAAG,IAAI,CAAC;oBACf,IAAI,OAAO,KAAK,CAAC,QAAQ;wBAAE,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC;;wBAAM,IAAI,GAAG,CAAC,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;gBAC/E,CAAC;gBAED,8DAA8D;gBAC9D,GAAG,EAAE,CAAC;gBACN,IAAI,IAAI,CAAC,GAAG,CAAC,KAAK,GAAG,OAAO,CAAC,GAAG,GAAG;oBAAE,IAAI,GAAG,IAAI,CAAC;gBACjD,IAAI,GAAG,IAAI,QAAQ;oBAAE,IAAI,GAAG,IAAI,CAAC;YACnC,CAAC;YAED,0GAA0G;YAC1G,yCAAyC;YACzC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;gBAAE,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;QACrD,CAAC,CAAC,2BAA2B;QAE7B,wDAAwD;QACxD,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/B,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAAC;QACjB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE;gBACxB,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC;QAC3E,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IACV,IAAI,CAAC,CAAS,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAE9D,YAAY,GAAuB;QAlM7B,SAAI,GAAG,CAAC,CAAC;QAMT,WAAM,GAAiB,IAAI,CAAC,MAAM,CAAC;QAazC,sDAAsD;QAC9C,YAAO,GAAG,KAAK,CAAC;QAChB,WAAM,GAAG,GAAG,CAAC;QA8KnB,GAAG,GAAG,GAAG,IAAI,EAAE,CAAC;QAChB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,YAAY,EAAE,EAAE,CAAC,CAAC,CAAC,wCAAwC;QAC9F,IAAI,CAAC,GAAG,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,sBAAsB;QAC7D,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC,CAAC,gBAAgB;QAChE,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,0BAA0B;IACnF,CAAC;IAED,uDAAuD;IACvD,uDAAuD;IAChD,WAAW,CAAC,CAAoB;QACrC,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;QACnB,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC;QACtB,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,uCAAuC,CAAC,CAAC;QAC5D,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,oCAAoC,CAAC,CAAC;QACzD,MAAM,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,+CAA+C;QAC3E,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAC,mBAAmB;QACvE,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,kCAAkC;QAC9C,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,eAAe;IACtC,CAAC;IAED,0DAA0D;IAC1D,sBAAsB;IACtB,0EAA0E;IACnE,YAAY,CAAC,CAAe,EAAE,OAAe;QAClD,MAAM,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC;QACnB,IAAI,CAAC,MAAM,CAAC,CAAC,GAAG,CAAC,EAAE,uCAAuC,CAAC,CAAC;QAC5D,4CAA4C;QAC5C,wCAAwC;QACxC,OAAO,CAAC,IAAI,CAAC,qBAAqB,CAAC,CAAC;QACpC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;QACrD,OAAO,CAAC,OAAO,CAAC,qBAAqB,CAAC,CAAC;QACvC,IAAI,CAAC,CAAC,GAAG,OAAO,CAAC;QACjB,IAAI,CAAC,YAAY,EAAE,CAAC,CAAC,eAAe;IACtC,CAAC;IAED,yCAAyC;IAClC,YAAY;QACjB,oCAAoC;QACpC,IAAI,CAAC,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,eAAe;QACxD,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,6DAA6D;QAC/G,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC,uBAAuB;QACzE,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;IAChB,CAAC;IAED,qCAAqC;IAC9B,WAAW;QAChB,OAAO,IAAI,CAAC,CAAC,CAAC;IAChB,CAAC;IAED,iEAAiE;IAC1D,IAAI;QACT,IAAI,CAAC,IAAI,IAAI,CAAC,CAAC;QACf,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACjB,MAAM,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,oBAAoB;QACtD,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC;QACrB,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC;QAErB,wBAAwB;QACxB,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACnC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;gBAClC,MAAM,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBACvB,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC7B,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAEhC,sBAAsB;gBACtB,IAAI,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,KAAK,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,MAAM,GAAG,GAAG,CAAC;gBAC9E,IAAI,OAAO,GAAG,IAAI;oBAAE,OAAO,GAAG,IAAI,CAAC,CAAC,QAAQ;gBAC5C,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,sBAAsB;gBAElD,kCAAkC;gBAClC,MAAM,MAAM,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC;gBAC3C,MAAM,MAAM,GAAG,MAAM,GAAG,GAAG,GAAG,IAAI,CAAC,OAAO,GAAG,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,4BAA4B;gBAEvD,QAAQ;gBACR,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC;gBAEvB,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,8CAA8C;YAC1E,CAAC;QACH,CAAC;QAED,8BAA8B;QAC9B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE;gBAC/B,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;QACjC,CAAC;QAED,6EAA6E;QAC7E,OAAO,IAAI,CAAC,CAAC,sBAAsB;IACrC,CAAC;IAED,gCAAgC;IACzB,SAAS;QACd,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QAEjB,MAAM,EAAE,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,oBAAoB;QACtD,uBAAuB;QACvB,MAAM,IAAI,GAAG,EAAE,CAAC,IAAI,CAAC;QAErB,MAAM,CAAC,GAAG,IAAI,CAAC;QACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;gBAClC,MAAM,IAAI,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAE1B,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;gBACxB,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAElC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,CAAC;gBACxB,MAAM,GAAG,GAAG,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;gBAElC,MAAM,QAAQ,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC5B,MAAM,SAAS,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;gBAClD,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,GAAG,GAAG,CAAC,GAAG,wBAAwB,GAAG,QAAQ,GAAG,kBAAkB,GAAG,SAAS,CAAC,CAAC;gBAEhG,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;YACtB,CAAC;QACH,CAAC;IACH,CAAC;IAGD,iDAAiD;IAC1C,QAAQ,CAAC,CAAa;QAC3B,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QACjB,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,sBAAsB;QAC5C,MAAM,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC;QAEjB,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,qCAAqC;QAE3E,qDAAqD;QACrD,IAAI,CAAC,KAAK,KAAV,IAAI,CAAC,KAAK,GAAK,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,EAAC;QACjC,IAAI,IAAI,GAAG,GAAG,CAAC;QACf,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC/B,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC7F,MAAM,EAAE,GAAG,GAAG,GAAG,CAAC,GAAG,GAAG,IAAI,CAAC,CAAC,CAAC,yBAAyB;gBACxD,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;gBAC3B,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,CAAC;gBAC3B,IAAI,IAAI,CAAC,GAAG,EAAE,CAAC;YACjB,CAAC;QACH,CAAC;QACD,uCAAuC;QACvC,mBAAmB;QACnB,2BAA2B;QAC3B,IAAI,IAAI,GAAG,GAAG,CAAC;QACf,MAAM,IAAI,GAAG,IAAI,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,YAAY,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;QAClF,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YAC3B,yEAAyE;YACzE,KAAK,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;gBAC/B,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,MAAM,CAAC,CAAC;gBACzD,IAAI,IAAI,CAAC,CAAE,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,yDAAyD;gBACrG,MAAM,OAAO,GAAG,CAAC,GAAG,CAAC,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,CAAC;gBACtE,gCAAgC;gBAChC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,EAAE,CAAC,EAAE,EAAE,CAAC;oBAC7B,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;oBAC5C,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAC9C,CAAC;YACH,CAAC;YACD,iBAAiB;QACnB,CAAC;QAED,OAAO,EAAC,IAAI,EAAE,IAAI,EAAC,CAAC;IACtB,CAAC;CACJ","sourcesContent":["import {dmLinearIndex} from '../distance-matrix';\n\n\nexport class TSNE {\n  private perplexity: number;\n  private dim: number;\n  private epsilon: number;\n  private iter = 0;\n  private N!: number;\n  private P!: Float32Array;\n  private Y!: any[];\n  private gains!: any[];\n  private ystep!: any[];\n  private random: () => number = Math.random;\n  private assert(condition: any, message: any) {\n    if (!condition) throw message || 'Assertion failed';\n  }\n\n  // syntax sugar\n  private getopt(opt: {[_: string]: any}, field: string, defaultval: any) {\n    if (opt.hasOwnProperty(field))\n      return opt[field];\n    else\n      return defaultval;\n  }\n\n    // return 0 mean unit standard deviation random number\n    private returnV = false;\n    private vValue = 0.0;\n    gaussRandom(): number {\n      if (this.returnV) {\n        this.returnV = false;\n        return this.vValue;\n      }\n      const u = 2 * this.random() - 1;\n      const v = 2 * this.random() - 1;\n      const r = u * u + v * v;\n      if (r === 0 || r > 1) return this.gaussRandom();\n      const c = Math.sqrt(-2 * Math.log(r) / r);\n      this.vValue = v * c; // cache this for next function call for efficiency\n      this.returnV = true;\n      return u * c;\n    }\n\n    // return random normal number\n    private randn(mu: number, std: number) {\n      return mu + this.gaussRandom() * std;\n    }\n\n    // utilitity that creates contiguous vector of zeros of size n\n    private zeros(n: number) {\n      if (typeof (n) === 'undefined' || isNaN(n)) return new Float32Array();\n      if (typeof ArrayBuffer === 'undefined') {\n        // lacking browser support\n        const arr = new Float32Array(n);\n        for (let i = 0; i < n; i++) arr[i] = 0;\n        return arr;\n      } else {\n        return new Float32Array(n); // typed arrays are faster\n      }\n    }\n\n    // utility that returns 2d array filled with random numbers\n    // or with value s, if provided\n    private randn2d(n: number, d: number, s?: number) {\n      const uses = typeof s !== 'undefined';\n      const x = (new Array(n)).fill(null).map(() => new Float32Array(d));\n      if (uses) {\n        for (let i = 0; i < n; i++)\n          x[i] = new Float32Array(d).fill(s);\n      } else {\n        for (let i = 0; i < n; i++) {\n          for (let j = 0; j < d; j++)\n            x[i][j] = this.randn(0.0, 1e-4);\n        }\n      }\n      return x;\n    }\n\n    // compute L2 distance between two vectors\n    private l2(x1: number[], x2: number[]) {\n      const D = x1.length;\n      let d = 0;\n      for (let i = 0; i < D; i++) {\n        const x1i = x1[i];\n        const x2i = x2[i];\n        d += (x1i - x2i) * (x1i - x2i);\n      }\n      return d;\n    }\n\n    // compute pairwise distance in all vectors in X\n    private xtod(X: Array< Array<number> >) {\n      const N = X.length;\n      const dist = this.zeros(N * N); // allocate contiguous array\n      for (let i = 0; i < N; i++) {\n        for (let j = i + 1; j < N; j++) {\n          const d = this.l2(X[i], X[j]);\n          dist[i * N + j] = d;\n          dist[j * N + i] = d;\n        }\n      }\n      return dist;\n    }\n\n    public getIterSize(rowSize: number) {\n      if (rowSize <= 2000)\n        return 100;\n      else if (rowSize <= 3000)\n        return 90;\n      else if (rowSize <= 5000)\n        return 80;\n      else\n        return 70;\n    }\n\n    // compute (p_{i|j} + p_{j|i})/(2n)\n    private d2p(D: Float32Array, perplexity: number, tol: number, rowSize: number) {\n      // const nf = Math.sqrt(D.length); // this better be an integer\n      // const n = Math.floor(nf);\n      // this.assert(n === nf, 'D should have square number of elements.');\n      const indexer = dmLinearIndex(rowSize);\n      const distances = new Float32Array(rowSize * rowSize);\n      for (let i = 0; i < rowSize; i++) {\n        for (let j = i + 1; j < rowSize; j++)\n          distances[i * rowSize + j] = distances[j * rowSize + i] = D[indexer(i, j)];\n      }\n      const n = rowSize;\n      const hTarget = Math.log(perplexity); // target entropy of distribution\n      const P = this.zeros(n * n); // temporary probability matrix\n      const prow = this.zeros(n); // a temporary storage compartment\n      for (let i = 0; i < n; i++) {\n        let betamin = -Infinity;\n        let betamax = Infinity;\n        let beta = 1; // initial value of precision\n        let done = false;\n        const maxtries = Math.floor(this.getIterSize(rowSize) / 5);\n\n        // perform binary search to find a suitable precision beta\n        // so that the entropy of the distribution is appropriate\n        let num = 0;\n        while (!done) {\n          //debugger;\n\n          // compute entropy and kernel row with beta precision\n          let psum = 0.0;\n          for (let j = 0; j < n; j++) {\n            const pj = i === j ? 0 : Math.exp(- distances[i * n + j] * beta);\n            prow[j] = pj;\n            psum += pj;\n          }\n          // normalize p and compute entropy\n          let nHere = 0.0;\n          for (let j = 0; j < n; j++) {\n            let pj;\n            if (psum === 0)\n              pj = 0;\n            else\n              pj = prow[j] / psum;\n\n            prow[j] = pj;\n            if (pj > 1e-7) nHere -= pj * Math.log(pj);\n          }\n\n          // adjust beta based on result\n          if (nHere > hTarget) {\n            // entropy was too high (distribution too diffuse)\n            // so we need to increase the precision for more peaky distribution\n            betamin = beta; // move up the bounds\n            if (betamax === Infinity) beta = beta * 2; else beta = (beta + betamax) / 2;\n          } else {\n            // converse case. make distrubtion less peaky\n            betamax = beta;\n            if (betamin === -Infinity) beta = beta / 2; else beta = (beta + betamin) / 2;\n          }\n\n          // stopping conditions: too many tries or got a good precision\n          num++;\n          if (Math.abs(nHere - hTarget) < tol) done = true;\n          if (num >= maxtries) done = true;\n        }\n\n        // console.log('data point ' + i + ' gets precision ' + beta + ' after ' + num + ' binary search steps.');\n        // copy over the final prow to P at row i\n        for (let j = 0; j < n; j++) P[i * n + j] = prow[j];\n      } // end loop over examples i\n\n      // symmetrize P and normalize it to sum to 1 over all ij\n      const pOut = this.zeros(n * n);\n      const N2 = n * 2;\n      for (let i = 0; i < n; i++) {\n        for (let j = 0; j < n; j++)\n          pOut[i * n + j] = Math.max((P[i * n + j] + P[j * n + i]) / N2, 1e-100);\n      }\n\n      return pOut;\n    }\n\n    // helper function\n    private sign(x: number) { return x > 0 ? 1 : x < 0 ? -1 : 0; }\n\n    constructor(opt: {[_: string]: any}) {\n      opt = opt || {};\n      this.perplexity = this.getopt(opt, 'perplexity', 30); // effective number of nearest neighbors\n      this.dim = this.getopt(opt, 'dim', 2); // by default 2-D tSNE\n      this.epsilon = this.getopt(opt, 'epsilon', 10); // learning rate\n      this.random = this.getopt(opt, 'random', Math.random); // random number generator\n    }\n\n    // this function takes a set of high-dimensional points\n    // and creates matrix P from them using gaussian kernel\n    public initDataRaw(X: Array<Array<any>>) {\n      const N = X.length;\n      const D = X[0].length;\n      this.assert(N > 0, ' X is empty? You must have some data!');\n      this.assert(D > 0, ' X[0] is empty? Where is the data?');\n      const dists = this.xtod(X); // convert X to distances using gaussian kernel\n      this.P = this.d2p(dists, this.perplexity, 1e-4, D); // attach to object\n      this.N = N; // back up the size of the dataset\n      this.initSolution(); // refresh this\n    }\n\n    // this function takes a given distance matrix and creates\n    // matrix P from them.\n    // D is assumed to be provided as a list of lists, and should be symmetric\n    public initDataDist(D: Float32Array, rowSize: number) {\n      const N = D.length;\n      this.assert(N > 0, ' X is empty? You must have some data!');\n      // convert D to a (fast) typed array version\n      // dists.forEach((d) => console.log(d));\n      console.time('distances to matrix');\n      this.P = this.d2p(D, this.perplexity, 1e-4, rowSize);\n      console.timeEnd('distances to matrix');\n      this.N = rowSize;\n      this.initSolution(); // refresh this\n    }\n\n    // (re)initializes the solution to random\n    public initSolution() {\n      // generate random solution to t-SNE\n      this.Y = this.randn2d(this.N, this.dim); // the solution\n      this.gains = this.randn2d(this.N, this.dim, 1.0); // step gains to accelerate progress in unchanging directions\n      this.ystep = this.randn2d(this.N, this.dim, 0.0); // momentum accumulator\n      this.iter = 0;\n    }\n\n    // return pointer to current solution\n    public getSolution() {\n      return this.Y;\n    }\n\n    // perform a single step of optimization to improve the embedding\n    public step() {\n      this.iter += 1;\n      const N = this.N;\n      const cg = this.costGrad(this.Y); // evaluate gradient\n      const cost = cg.cost;\n      const grad = cg.grad;\n\n      // perform gradient step\n      const ymean = this.zeros(this.dim);\n      for (let i = 0; i < N; i++) {\n        for (let d = 0; d < this.dim; d++) {\n          const gid = grad[i][d];\n          const sid = this.ystep[i][d];\n          const gainid = this.gains[i][d];\n\n          // compute gain update\n          let newgain = this.sign(gid) === this.sign(sid) ? gainid * 0.8 : gainid + 0.2;\n          if (newgain < 0.01) newgain = 0.01; // clamp\n          this.gains[i][d] = newgain; // store for next turn\n\n          // compute momentum step direction\n          const momval = this.iter < 250 ? 0.5 : 0.8;\n          const newsid = momval * sid - this.epsilon * newgain * grad[i][d];\n          this.ystep[i][d] = newsid; // remember the step we took\n\n          // step!\n          this.Y[i][d] += newsid;\n\n          ymean[d] += this.Y[i][d]; // accumulate mean so that we can center later\n        }\n      }\n\n      // reproject Y to be zero mean\n      for (let i = 0; i < N; i++) {\n        for (let d = 0; d < this.dim; d++)\n          this.Y[i][d] -= ymean[d] / N;\n      }\n\n      //if(this.iter%100===0) console.log('iter ' + this.iter + ', cost: ' + cost);\n      return cost; // return current cost\n    }\n\n    // for debugging: gradient check\n    public debugGrad() {\n      const N = this.N;\n\n      const cg = this.costGrad(this.Y); // evaluate gradient\n      //const cost = cg.cost;\n      const grad = cg.grad;\n\n      const e = 1e-5;\n      for (let i = 0; i < N; i++) {\n        for (let d = 0; d < this.dim; d++) {\n          const yold = this.Y[i][d];\n\n          this.Y[i][d] = yold + e;\n          const cg0 = this.costGrad(this.Y);\n\n          this.Y[i][d] = yold - e;\n          const cg1 = this.costGrad(this.Y);\n\n          const analytic = grad[i][d];\n          const numerical = (cg0.cost - cg1.cost) / (2 * e);\n          console.log(i + ',' + d + ': gradcheck analytic: ' + analytic + ' vs. numerical: ' + numerical);\n\n          this.Y[i][d] = yold;\n        }\n      }\n    }\n\n    private quArr?: Float32Array;\n    // return cost and gradient, given an arrangement\n    public costGrad(Y: number[][]) {\n      const N = this.N;\n      const dim = this.dim; // dim of output space\n      const P = this.P;\n\n      const pmul = this.iter < 100 ? 4 : 1; // trick that helps with local optima\n\n      // compute current Q distribution, unnormalized first\n      this.quArr ??= this.zeros(N * N);\n      let qsum = 0.0;\n      for (let i = 0; i < N; i++) {\n        for (let j = i + 1; j < N; j++) {\n          const dsum = new Array(dim).reduce((prev, _, d) => prev + Math.pow(Y[i][d] - Y[j][d], 2), 0);\n          const qu = 1.0 / (1.0 + dsum); // Student t-distribution\n          this.quArr[i * N + j] = qu;\n          this.quArr[j * N + i] = qu;\n          qsum += 2 * qu;\n        }\n      }\n      // normalize Q distribution to sum to 1\n      //const NN = N * N;\n      //const Q = this.zeros(NN);\n      let cost = 0.0;\n      const grad = new Array(N).fill(null).map(() => (new Float32Array(dim)).fill(0.0));\n      for (let i = 0; i < N; i++) {\n        // const gsum = new Float32Array(dim).fill(0.0); // init grad for point i\n        for (let j = i + 1; j < N; j++) {\n          const Q = Math.max(this.quArr[i * N + j] / qsum, 1e-100);\n          cost += (- P[i * N + j] * Math.log(Q)) * 2; // accumulate cost (the non-constant portion at least...)\n          const premult = 4 * (pmul * P[i * N + j] - Q) * this.quArr[i * N + j];\n          //console.log(premult, Q, i, j);\n          for (let d = 0; d < dim; d++) {\n            grad[i][d] += premult * (Y[i][d] - Y[j][d]);\n            grad[j][d] += premult * (Y[j][d] - Y[i][d]);\n          }\n        }\n        //grad[i] = gsum;\n      }\n\n      return {cost, grad};\n    }\n}\n"]}","/** Proxy for DistanceMatrix class. Allows to index matrix as matrix[i][j]\n * Note: much slower than direct indexing, but still much faster than recalculating distances.\n * will be used for T-SNE mainly.\n * @param {Float32Array}condensedArray - array of distances between all pairs of objects\n * @param {number}size - number of comparebles in matrix\n * @return {Float32Array} - proxy for condensedArray\n*/\nexport function distanceMatrixProxy(condensedArray, size) {\n const linearFunc = dmLinearIndex(size);\n function linearIndex(i, j) {\n const iNum = Number(i);\n const jNum = Number(j);\n return linearFunc(iNum, jNum);\n }\n function idx2Handler(idx1) {\n return ({\n get(target, idx2, _receiver) {\n if (idx1 === idx2)\n return 0;\n const linearIdx = Number(idx1) > Number(idx2) ? linearIndex(idx2, idx1) : linearIndex(idx1, idx2);\n return target[linearIdx];\n },\n });\n }\n const idx1Handler = {\n get(target, idx1, _receiver) {\n if (idx1 === 'length')\n return size;\n return new Proxy(target, idx2Handler(idx1));\n },\n };\n return new Proxy(condensedArray, idx1Handler);\n}\nexport function dmLinearIndex(size) {\n return (i, j) => size * i + j - Math.floor(((i + 2) * (i + 1)) / 2);\n}\n//# sourceMappingURL=data:application/json;base64,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","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nlet gpuAdapter = null;\nlet gpuDevice = null;\nexport function getGPUDevice() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!navigator.gpu) {\n console.error('WebGPU is not supported in this browser');\n return null;\n }\n if (!gpuAdapter) {\n //reason: only here we get the gpuAdapter\n // eslint-disable-next-line no-restricted-syntax\n gpuAdapter = yield navigator.gpu.requestAdapter({ powerPreference: 'high-performance' });\n if (gpuAdapter == null)\n return null;\n }\n let isLost = false;\n if (gpuDevice) {\n gpuDevice.lost.then(() => {\n isLost = true;\n });\n yield new Promise((r) => setTimeout(r, 10)); // wait to see if the device is lost\n }\n if (!gpuDevice || isLost) {\n const requiredBufferSize = 1000000000; // ~1000MB\n const adapterLimits = gpuAdapter.limits;\n const buffferSizeLimit = adapterLimits.maxBufferSize;\n const storageBufferSizeLimit = adapterLimits.maxStorageBufferBindingSize;\n try {\n gpuDevice = yield gpuAdapter.requestDevice({ requiredLimits: {\n maxBufferSize: Math.min(buffferSizeLimit, requiredBufferSize),\n maxStorageBufferBindingSize: Math.min(storageBufferSizeLimit, requiredBufferSize)\n } });\n return gpuDevice;\n }\n catch (e) {\n console.error('Failed to create device with required limits', e);\n gpuDevice = yield gpuAdapter.requestDevice();\n return gpuDevice;\n }\n }\n return gpuDevice;\n });\n}\nexport function getGPUAdapterDescription() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!navigator.gpu) {\n console.error('WebGPU is not supported in this browser');\n return null;\n }\n if (!gpuAdapter) {\n // reason: only here we get the gpuAdapter\n // eslint-disable-next-line no-restricted-syntax\n gpuAdapter = yield navigator.gpu.requestAdapter();\n if (gpuAdapter == null)\n return null;\n }\n let info = null;\n if ('info' in gpuAdapter)\n info = gpuAdapter.info;\n // this option is sort of deprecated but still available in every initial release\n // else if ('requestAdapterInfo' in gpuAdapter && typeof gpuAdapter.requestAdapterInfo === 'function')\n // info = (await gpuAdapter.requestAdapterInfo()) as GPUAdapterInfo;\n if (!info)\n return 'No GPU description available';\n const outString = replaceEmptyString(info.description, replaceEmptyString(info.vendor, 'No GPU description available'));\n return outString;\n });\n}\nfunction replaceEmptyString(str, replacement) {\n return !str || str == '' ? replacement : str;\n}\n//# sourceMappingURL=getGPUDevice.js.map","function euclideanAggregationWgsl(arraySize) {\n return `\n var sum = 0.0;\n for (var i = 0u; i < ${arraySize}; i = i + 1u) {\n sum = sum + distances[i] * distances[i] * computeInfo.weights[i] * computeInfo.weights[i];\n }\n return sqrt(sum);\n `;\n}\n;\nfunction manhattanAggregationWgsl(arraySize) {\n return `\n var sum = 0.0;\n for (var i = 0u; i < ${arraySize}; i = i + 1u) {\n sum = sum + abs(distances[i]) * computeInfo.weights[i];\n }\n return sum;\n `;\n}\nexport var WEBGSLAGGREGATION;\n(function (WEBGSLAGGREGATION) {\n WEBGSLAGGREGATION[\"EUCLIDEAN\"] = \"EUCLIDEAN\";\n WEBGSLAGGREGATION[\"MANHATTAN\"] = \"MANHATTAN\";\n})(WEBGSLAGGREGATION || (WEBGSLAGGREGATION = {}));\nexport const WEBGSLAGGREGATIONFUNCTIONS = {\n [WEBGSLAGGREGATION.EUCLIDEAN]: euclideanAggregationWgsl,\n [WEBGSLAGGREGATION.MANHATTAN]: manhattanAggregationWgsl\n};\n//# sourceMappingURL=webGPU-aggregation.js.map","/* eslint-disable max-len */\n// in all the functions below, the variables a and b are assumed to be arrays of uint32/f32\n//values which are infered from the code this chunk is injected into\n// also, we have access to computeInfo struct, which contains the following fields:\n// computeInfo.entrySizes: array of arrays of u32 containing the sizes of the entries\n// other fields are specific to the distance function should be injected from the main script that calls this function,\n// and should be available in the supplementaryInfo struct\n// like the similarity matrix for monomer chemical distance.\n// the getProcessInfo function should return correct buffer allocation mechanism for the supplementaryInfo,\n// for every entry list\n// the maxDistance variable is also assumed to be available in the\n// scope of the function, in case of knn it is the distance in the last postion of knn on this index,\n// in case of sparse matrix, it can be just the threshold for the distance.\n// hamming distance for sequnences of uint32 arrays of max length ${maxArraySize}\nexport function webGPUHamming(_maxArraySize, entryIndex) {\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n let maxLength: u32 = max(aLength, bLength);\n let minLength: u32 = min(aLength, bLength);\n let sizeDiff: u32 = maxLength - minLength;\n \n let maxIntDistance = ceil(maxDistance * f32(maxLength)) - f32(sizeDiff);\n\n var diff: f32 = 0.0;\n for (var i = 0u; i < ${_maxArraySize}; i = i + 1u) {\n diff = diff + f32(a[i] != b[i]);\n if (diff > maxIntDistance) {\n return 1.0;\n }\n }\n diff += f32(sizeDiff);\n return diff / ${_maxArraySize};\n `;\n}\nexport function webGPUMonomerChemicalDistance(_maxArraySize, entryIndex) {\n // it is assumet that suppInfo struct contains correct matrix called similarityMatrix${entryIndex}, (similarityMatrix0, similarityMatrix1, etc)\n // this should be guaranteed by the getProcessInfo function.\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n let maxLength: u32 = max(aLength, bLength);\n let minLength: u32 = min(aLength, bLength);\n let sizeDiff: u32 = maxLength - minLength;\n \n let maxIntDistance = ceil(maxDistance * f32(maxLength)) - f32(sizeDiff);\n\n let simMatrix = &(suppInfo.similarityMatrix${entryIndex}); // using pointers make things faster\n var diff: f32 = 0.0;\n for (var i = 0u; i < ${_maxArraySize}; i = i + 1u) {\n diff = diff + 1.0 - (*simMatrix)[u32(a[i])][u32(b[i])];\n if (diff > maxIntDistance) {\n return 1.0;\n }\n }\n diff += f32(sizeDiff);\n return diff / ${_maxArraySize};\n `;\n}\nexport function webGPULevenstein(maxArraySize, entryIndex) {\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n let maxLength: u32 = max(aLength, bLength);\n let minLength: u32 = min(aLength, bLength);\n\n let maxIntDistance = ceil(maxDistance * f32(maxLength));\n\n // we will store two arrays as matrix and swap the working indices per pass.\n // this way we can reduce memory usage per computation to just O(aLength)\n // the grid will have aLength + 1 columns and bLength + 1 rows\n // this will be guaranteed by iteration, but the array sizes must be known at compile time, so we will use a fixed size of maxArraySize\n var dynamicPassMat: array<array<f32, ${maxArraySize + 1}u>, 2>; // initialize to 0\n \n var prevIndex: u32 = 0;\n var curIndex: u32 = 1; // we will swap these indices per pass\n\n // initialize the first row\n for (var i = 0u; i <= aLength; i = i + 1u) {\n dynamicPassMat[prevIndex][i] = f32(i);\n }\n\n // iterate over the rows\n for (var i = 1u; i <= bLength; i = i + 1u) {\n dynamicPassMat[curIndex][0] = f32(i);\n var minEntry: f32 = f32(maxLength);\n let prevRow = &dynamicPassMat[prevIndex];\n let curRow = &dynamicPassMat[curIndex];\n let bMon = u32(b[i - 1]);\n for (var j = 1u; j <= aLength; j = j + 1u) {\n var cost: f32 = f32(a[j - 1] != bMon);\n var res: f32 = min(\n min(\n (*prevRow)[j] + 1.0, // deletion\n (*curRow)[j - 1] + 1.0, // insertion\n ),\n (*prevRow)[j - 1] + cost // substitution\n );\n (*curRow)[j] = res;\n if (res < minEntry) {\n minEntry = res;\n }\n }\n // swap the indices\n let temp: u32 = prevIndex;\n prevIndex = curIndex;\n curIndex = temp;\n if (minEntry > maxIntDistance) {\n return 1.0;\n }\n }\n\n return dynamicPassMat[prevIndex][aLength] / f32(maxLength);\n `;\n}\nexport function webGPUNeedlemanWunsch(maxArraySize, entryIndex) {\n // version of the levenshtain where the cost of substitution is customizable\n // it is assumet that suppInfo struct contains correct matrix called similarityMatrix${entryIndex}, (similarityMatrix0, similarityMatrix1, etc)\n // and gapOpenPenalty, gapExtensionPenalty\n // this should be guaranteed by the getProcessInfo function.\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n let maxLength: u32 = max(aLength, bLength);\n let minLength: u32 = min(aLength, bLength);\n \n let maxIntDistance = ceil(maxDistance * f32(maxLength));\n // we will store two arrays as matrix and swap the working indices per pass.\n // this way we can reduce memory usage per computation to just O(aLength)\n // the grid will have aLength + 1 columns and bLength + 1 rows\n // this will be guaranteed by iteration, but the array sizes must be known at compile time, so we will use a fixed size of maxArraySize\n var dynamicPassMat: array<array<f32, ${maxArraySize + 1}u>, 2>; // initialize to 0\n \n // we need to keep track of which operation led to the current cell\n // i.e. whether we came from the left, top or diagonal to assign gap open/gap extend penalty\n var verticalGaps: array<u32, ${maxArraySize + 1}u>;\n var horizontalGaps: array<u32, ${maxArraySize + 1}u>;\n\n let gapOpenPenalty: f32 = suppInfo.gapOpenPenalty${entryIndex};\n let gapExtensionPenalty: f32 = suppInfo.gapExtensionPenalty${entryIndex};\n var prevIndex: u32 = 0;\n var curIndex: u32 = 1; // we will swap these indices per pass\n // initialize the first row\n for (var i = 0u; i <= aLength; i = i + 1u) {\n dynamicPassMat[prevIndex][i] = gapExtensionPenalty + f32(i - 1) * gapExtensionPenalty; // accounting for the fact that left and right gaps are less costly\n dynamicPassMat[curIndex][i] = 0.0;\n }\n dynamicPassMat[0][0] = 0.0;\n\n let simMatrix = &suppInfo.similarityMatrix${entryIndex}; // using pointers make things faster\n // iterate over the rows\n for (var i = 1u; i <= bLength; i = i + 1u) {\n let prevRow = &dynamicPassMat[prevIndex];\n let curRow = &dynamicPassMat[curIndex];\n (*curRow)[0] = gapExtensionPenalty + f32(i - 1) * gapExtensionPenalty;\n var minEntry: f32 = f32(maxLength);\n let monB = u32(b[i - 1]);\n for (var j = 1u; j <= aLength; j = j + 1u) {\n let monA = u32(a[j - 1]);\n \n let cost: f32 = (*prevRow)[j - 1] + 1f - (*simMatrix)[monA][monB];\n var top = (*prevRow)[j]; // deletion\n if (verticalGaps[j] > 0 || i == 1 || i == bLength) {\n top = top + gapExtensionPenalty;\n } else {\n top = top + gapOpenPenalty;\n }\n var left = (*curRow)[j - 1]; // insertion\n if (horizontalGaps[j - 1] > 0 || j == 1 || j == aLength) {\n left = left + gapExtensionPenalty;\n } else {\n left = left + gapOpenPenalty;\n }\n var res: f32 = min(\n min(\n top, // deletion\n left, // insertion\n ),\n cost // substitution\n );\n (*curRow)[j] = res;\n if (res < minEntry) {\n minEntry = res;\n }\n // update the horizontal and vertical gaps\n if (res == cost) {\n verticalGaps[j] = 0;\n horizontalGaps[j] = 0;\n } else if (res == left) {\n verticalGaps[j] = 0;\n horizontalGaps[j] = 1;\n } else {\n verticalGaps[j] = 1;\n horizontalGaps[j] = 0;\n }\n }\n // swap the indices\n let temp: u32 = prevIndex;\n prevIndex = curIndex;\n curIndex = temp;\n if (minEntry > maxIntDistance) {\n return 1.0;\n }\n }\n return dynamicPassMat[prevIndex][aLength] / f32(minLength);\n\n `;\n}\nexport function webGPUEuclidean(maxArraySize, _entryIndex) {\n return `\n var dist: f32 = 0.0;\n for (var i = 0u; i < ${maxArraySize}; i = i + 1u) {\n dist = dist + f32(a[i] - b[i]) * f32(a[i] - b[i]);\n }\n return sqrt(dist);\n `;\n}\nexport function webGPUManhattan(maxArraySize, _entryIndex) {\n return `\n var dist: f32 = 0.0;\n for (var i = 0u; i < ${maxArraySize}; i = i + 1u) {\n dist = dist + abs(f32(a[i] - b[i]));\n }\n return dist;\n `;\n}\nexport function webGPUOneHotDistance(_maxArraySize, entryIndex) {\n return `\n let aLength: u32 = computeInfo.entrySizes[${entryIndex}][aIndex];\n let bLength: u32 = computeInfo.entrySizes[${entryIndex}][bIndex];\n if (aLength != bLength) {\n return 1.0;\n }\n for (var i = 0u; i < aLength; i = i + 1u) {\n if(a[i] != b[i]) {\n return 1.0;\n }\n }\n return 0.0;\n `;\n}\nexport function webGPUNumericDistance(_maxArraySize, entryIndex) {\n // we assume that range${entryIndex} is available in the supplementaryInfo struct\n return `\n let range = suppInfo.range${entryIndex};\n return f32(abs(f32(a[0]) - f32(b[0])) / range);\n `;\n}\n// tanimoto distance for uint32 arrays of length ${maxArraySize}\nexport function webGPUTanimotoBitArray(maxArraySize, _entryIndex) {\n return `\n var onBitsa: u32 = 0u;\n var onBitsb: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n onBitsa = onBitsa + countOneBits(a[i]);\n onBitsb = onBitsb + countOneBits(b[i]);\n }\n\n if (onBitsa == 0u && onBitsb == 0u) {\n return 0.0;\n }\n\n let totalOnBits = onBitsa + onBitsb;\n var commonBits: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n commonBits = commonBits + countOneBits(a[i] & b[i]);\n }\n\n return 1.0 - f32(commonBits) / f32(totalOnBits - commonBits);\n `;\n}\nexport function webGPUAsymmetricBitArray(maxArraySize, _entryIndex) {\n return `\n var onBitsa: u32 = 0u;\n var onBitsb: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n onBitsa = onBitsa + countOneBits(a[i]);\n onBitsb = onBitsb + countOneBits(b[i]);\n }\n let min = min(onBitsa, onBitsb);\n if (min == 0u) {\n return 1.0;\n }\n var commonBits: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n commonBits = commonBits + countOneBits(a[i] & b[i]);\n }\n return 1.0 - f32(commonBits) / f32(min);\n `;\n}\nexport function webGPUCosineBitArray(maxArraySize, _entryIndex) {\n return `\n var onBitsa: u32 = 0u;\n var onBitsb: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n onBitsa = onBitsa + countOneBits(a[i]);\n onBitsb = onBitsb + countOneBits(b[i]);\n }\n let total = onBitsa * onBitsb; // p.s. here total is taken by multiplying\n if (total == 0u) {\n return 1.0;\n }\n var commonBits: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n commonBits = commonBits + countOneBits(a[i] & b[i]);\n }\n return 1.0 - f32(commonBits) / sqrt(f32(total));\n `;\n}\nexport function webGPUSokalBitArray(maxArraySize, _entryIndex) {\n return `\n var onBitsa: u32 = 0u;\n var onBitsb: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n onBitsa = onBitsa + countOneBits(a[i]);\n onBitsb = onBitsb + countOneBits(b[i]);\n }\n let total = onBitsa + onBitsb;\n if (total == 0u) {\n return 1.0;\n }\n var commonBits: u32 = 0u;\n for (var i = 0u; i < ${maxArraySize}u; i = i + 1u) {\n commonBits = commonBits + countOneBits(a[i] & b[i]);\n }\n return 1.0 - f32(commonBits) / f32(total * 2 - commonBits * 3);\n `;\n}\nexport var WEBGPUDISTANCE;\n(function (WEBGPUDISTANCE) {\n WEBGPUDISTANCE[\"HAMMING\"] = \"Hamming\";\n WEBGPUDISTANCE[\"EUCLIDEAN\"] = \"Euclidean\";\n WEBGPUDISTANCE[\"MANHATTAN\"] = \"Manhattan\";\n WEBGPUDISTANCE[\"TANIMOTO\"] = \"Tanimoto\";\n WEBGPUDISTANCE[\"LEVENSTEIN\"] = \"Levenshtein\";\n WEBGPUDISTANCE[\"NEEDLEMAN_WUNSCH\"] = \"Needlemann-Wunsch\";\n WEBGPUDISTANCE[\"MONOMER_CHEMICAL_DISTANCE\"] = \"Monomer chemical distance\";\n WEBGPUDISTANCE[\"SOKAL\"] = \"Sokal\";\n WEBGPUDISTANCE[\"COSINE\"] = \"Cosine\";\n WEBGPUDISTANCE[\"ASYMMETRIC\"] = \"Asymmetric\";\n WEBGPUDISTANCE[\"Difference\"] = \"Difference\";\n WEBGPUDISTANCE[\"OneHot\"] = \"One-Hot\";\n})(WEBGPUDISTANCE || (WEBGPUDISTANCE = {}));\nexport const webGPUFunctions = {\n [WEBGPUDISTANCE.HAMMING]: webGPUHamming,\n [WEBGPUDISTANCE.EUCLIDEAN]: webGPUEuclidean,\n [WEBGPUDISTANCE.MANHATTAN]: webGPUManhattan,\n [WEBGPUDISTANCE.TANIMOTO]: webGPUTanimotoBitArray,\n [WEBGPUDISTANCE.LEVENSTEIN]: webGPULevenstein,\n [WEBGPUDISTANCE.NEEDLEMAN_WUNSCH]: webGPUNeedlemanWunsch,\n [WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE]: webGPUMonomerChemicalDistance,\n [WEBGPUDISTANCE.SOKAL]: webGPUSokalBitArray,\n [WEBGPUDISTANCE.COSINE]: webGPUCosineBitArray,\n [WEBGPUDISTANCE.ASYMMETRIC]: webGPUAsymmetricBitArray,\n [WEBGPUDISTANCE.Difference]: webGPUNumericDistance,\n [WEBGPUDISTANCE.OneHot]: webGPUOneHotDistance\n};\nexport const distanceFunctionComplexity = {\n [WEBGPUDISTANCE.HAMMING]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.EUCLIDEAN]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.MANHATTAN]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.TANIMOTO]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.SOKAL]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.COSINE]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.ASYMMETRIC]: (maxEntrySize) => Math.ceil(maxEntrySize / 30),\n [WEBGPUDISTANCE.LEVENSTEIN]: (maxEntrySize) => Math.ceil(maxEntrySize * maxEntrySize / 60),\n [WEBGPUDISTANCE.NEEDLEMAN_WUNSCH]: (maxEntrySize) => Math.ceil(maxEntrySize * maxEntrySize / 60),\n [WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE]: (maxEntrySize) => Math.ceil(maxEntrySize / 25),\n [WEBGPUDISTANCE.Difference]: (_maxEntrySize) => 1,\n [WEBGPUDISTANCE.OneHot]: (_maxEntrySize) => Math.ceil(_maxEntrySize / 40),\n};\nexport const TypeSupportedDistances = {\n [\"STRING\" /* WGPUENTRYTYPE.STRING */]: new Set([WEBGPUDISTANCE.HAMMING, WEBGPUDISTANCE.LEVENSTEIN, WEBGPUDISTANCE.NEEDLEMAN_WUNSCH, WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE, WEBGPUDISTANCE.OneHot]),\n [\"UINT32ARRAY\" /* WGPUENTRYTYPE.UINT32ARRAY */]: new Set([WEBGPUDISTANCE.HAMMING, WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE, WEBGPUDISTANCE.LEVENSTEIN, WEBGPUDISTANCE.NEEDLEMAN_WUNSCH, WEBGPUDISTANCE.TANIMOTO, WEBGPUDISTANCE.COSINE, WEBGPUDISTANCE.SOKAL, WEBGPUDISTANCE.ASYMMETRIC, WEBGPUDISTANCE.OneHot, WEBGPUDISTANCE.Difference]),\n [\"INT32ARRAY\" /* WGPUENTRYTYPE.INT32ARRAY */]: new Set([WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.OneHot, WEBGPUDISTANCE.Difference]),\n [\"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */]: new Set([WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.Difference]),\n [\"NUMBER\" /* WGPUENTRYTYPE.NUMBER */]: new Set([WEBGPUDISTANCE.EUCLIDEAN, WEBGPUDISTANCE.MANHATTAN, WEBGPUDISTANCE.Difference]),\n [\"BITARRAY\" /* WGPUENTRYTYPE.BITARRAY */]: new Set([WEBGPUDISTANCE.TANIMOTO, WEBGPUDISTANCE.COSINE, WEBGPUDISTANCE.SOKAL, WEBGPUDISTANCE.ASYMMETRIC])\n};\n//# sourceMappingURL=webGPU-multicol-distances.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\n/* eslint-disable max-len */\nimport { getGPUDevice } from '../getGPUDevice';\nimport { WEBGSLAGGREGATION, WEBGSLAGGREGATIONFUNCTIONS } from '../multi-col-distances/webGPU-aggregation';\nimport { WEBGPUDISTANCE, webGPUFunctions } from '../multi-col-distances/webGPU-multicol-distances';\nimport { webGPUProcessInfo } from '../preprocessing/webGPU-process-info';\n/** generate KNN based on list of lists of entries.\n * these entries are each encoded as Uint32Array or FLOAT32Array (depending on their type).\n * for example, sequences would be encoded as Uint32Array based on char code of the letter at each position.\n * [65, 66, 67, 68, 69] would be a sequence of 5 letters.\n * for chemical fingerprints, it would be a binary array of 0s and 1s,\n * represented as Uint32Array(_data property of DG bitarray).\n *\n * Be ware that size of entryList, distanceMetrics, weights and options must be the same.\n * if there are no options for entries i, pass an empty object.\n * for now options are needed for:\n * needleman-wunsch and monomer chemical distances: see {@link BioDistanceFnOptions} as for how it should be passed\n * numeric distances (Difference): {range: number} where range is the range of the values in the column (max - min).\n * in both cases, if options are not provided, they will be calculated automatically.\n */\nexport function multiColWebGPUKNN(entryList, // list of lists of entries, for multiple columns\nknnSize = 15, // size of the k-nearest neighbors\ndistanceMetrics, // distance metrics for each column\naggregationFunction, // aggregation function for the distances\nweights, // weights for each column\noptions // supplementary options for each column\n) {\n return __awaiter(this, void 0, void 0, function* () {\n // first, check that all the supplementary options are provided and are the same length:\n if (options.length !== entryList.length ||\n options.length !== distanceMetrics.length || options.length !== weights.length)\n throw new Error('Options, weigths and distance functions must be provided for each column');\n // check that all the entry lists are the same length\n if (entryList.some((list) => list.length !== entryList[0].length))\n throw new Error('All entry lists must be the same length');\n const availableDistanceMetrics = Object.values(WEBGPUDISTANCE);\n if (distanceMetrics.some((metric) => !availableDistanceMetrics.includes(metric)))\n throw new Error('Invalid distance metrics provided: ' + distanceMetrics.join(', '));\n const availableAggregationFunctions = Object.values(WEBGSLAGGREGATION);\n if (!availableAggregationFunctions.includes(aggregationFunction))\n throw new Error('Invalid aggregation function provided: ' + aggregationFunction);\n const numOfColumns = entryList.length; // number of columns\n if (numOfColumns === 0)\n throw new Error('No columns provided. Please provide at least one column of data.');\n const device = yield getGPUDevice();\n if (!device)\n return null;\n // device may be lost\n let deviceLost = false;\n device.lost.then(() => {\n deviceLost = true;\n });\n const listSize = entryList[0].length; // size of each list (or column)\n const processInfo = entryList.map((entry, i) => {\n return webGPUProcessInfo(entry, distanceMetrics[i], i, options[i]);\n });\n if (numOfColumns === 1)\n aggregationFunction = WEBGSLAGGREGATION.MANHATTAN; // save a bit of time\n // combine all struct types into one to put into the suppInfo struct.\n let suppInfoWgsl = processInfo.map((info) => info.suppInfoStructWgsl)\n .filter((wgsl) => !!wgsl && wgsl != '').join(',\\n');\n // structures in wgsl must have at least one member, so if we have no structures, we need to add a dummy one\n let needsDummy = false;\n if (!suppInfoWgsl || suppInfoWgsl.trim() == '') {\n needsDummy = true;\n suppInfoWgsl = '\\ndummy: f32\\n';\n }\n // combine all complexities into one\n const combinedComplexity = processInfo.reduce((a, b) => a + b.complexity, 0);\n // combine all data wgsl struct code into one\n const dataWgsl = processInfo.map((info) => info.dataStructWgsl).filter((wgsl) => !!wgsl && wgsl != '').join(',\\n');\n // combine all array sizes into one array (easier for setting)\n const arraySizes = new Uint32Array(numOfColumns * listSize);\n processInfo.forEach((info, i) => {\n arraySizes.set(info.arraySizes, i * listSize);\n }); // array.flat is not as optimized as this\n // if we try to map large knn directly from GPU, sometimes, device disconnects. so we need to do it in chunks, a good number\n // we found is 10000. So we will perform computations in chunks of 10000.\n const computationsPerPass = 10000;\n // also, as the computation per thread takes some time, we also need to divide the work into smaller chunks. meaning\n // that we will divide nummper of pair computations per pass. start and end of the pair comparisons will be stored in startAtEndAt buffer (vec4<u32>) as z and w coordinates.\n const pairComparisonsPerPass = Math.ceil(10000 / combinedComplexity);\n const workGroupDivision = 10; // how many threads inside of one workgroup dimension (in this case 10 * 10 threads per workgroup)\n const threadsPerWorkgroup = workGroupDivision * workGroupDivision;\n const workgroupsDim = Math.ceil(Math.sqrt(Math.ceil(computationsPerPass / threadsPerWorkgroup))); // how many workgroups per 2d dimension\n const globalThreadDimSize = workgroupsDim * workGroupDivision; // how many threads per 2d dimension\n // console.log(getCombinedDistanceScript(distanceMetrics, processInfo.map((info) => info.maxEntryLen), knnSize, aggregationFunction));\n // return;\n const resultIndexes = new Array(listSize)\n .fill(null)\n .map(() => new Uint32Array(knnSize));\n const resultDistances = new Array(listSize)\n .fill(null)\n .map(() => new Float32Array(knnSize));\n const module = device.createShaderModule({\n label: 'KNN compute shader',\n code: `\n // this struct will contain all the info about the computation, startAtEndAt will contain the start and end of the knnDistances and knnIndexes.\n // array of sizes for each entries, and the main data as arrays of arrays called data0, data1 and so on. good thing is that because the first entry is vec4<u32>,\n // there will be no paddings, so no need to worry about padding data. also, arrays and matrices get stucked together, so no padding there as well.\n // what we need to worry about is the padding of overall struct. the size of overall struct will be factor of 16 bytes, so keep that in mind.\n struct ComputeInfo {\n // the x coordinate will contain the start index of the knnDistances and knnIndexes, while y will contain the end index \n // the z coordinate will contain the start of the pair comparisons, while w will contain the end of the pair comparisons\n // just keep in mind that this vec4 will be in first 16 bytes of corresponding buffer.\n startAtEndAt: vec4<u32>,\n // the ACTUALLY sizes of each entry\n entrySizes: array<array<u32, ${listSize}>, ${numOfColumns}>,\n // the weights for each entry\n weights: array<f32, ${numOfColumns}>,\n // the data for each entry\n ${dataWgsl} // an example of the dataWgsl would be:\n //data0: array<array<u32,20>,100>,\n //data1: array<array<u32,20>,100>\n };\n\n struct SuppInfo {\n // struct containing all the supplementary info, like scoring matrix, alphabet indexes, range, etc.\n ${suppInfoWgsl}\n };\n \n @group(0) @binding(0) var<storage, read_write> knnIndexes: array<array<u32, ${knnSize}>, ${computationsPerPass}>;\n @group(0) @binding(1) var<storage, read_write> knnDistances: array<array<f32, ${knnSize}>, ${computationsPerPass}>; // each time just compute for a subset of the list\n @group(0) @binding(2) var<storage, read_write> computeInfo: ComputeInfo;\n @group(0) @binding(3) var<storage, read_write> suppInfo: SuppInfo;\n \n @compute @workgroup_size(${workGroupDivision}, ${workGroupDivision}) fn calcKNN(\n @builtin(global_invocation_id) id: vec3<u32>\n ) {\n ${needsDummy ? `let otherDummy = suppInfo.dummy * 2;` : ''} // just to make sure that the suppInfo is not optimized out\n let col = id.x; //* ${workGroupDivision} + localId.x;\n let row = id.y; //* ${workGroupDivision} + localId.y;\n let graphIndex = row * ${globalThreadDimSize} + col;\n let index = graphIndex + computeInfo.startAtEndAt.x; // add the starting index of the knnDistances and knnIndexes\n \n if (index >= min(${listSize}u, computeInfo.startAtEndAt.y)) {return;}\n \n let pairComparisonStartAt = computeInfo.startAtEndAt.z;\n let pairComparisonEndAt = min(computeInfo.startAtEndAt.w, ${listSize}u);\n \n \n // only clear the knnDistances and knnIndexes if we are at the start of the pair comparison\n if (pairComparisonStartAt == 0u) {\n for (var i = 0u; i < ${knnSize}; i = i + 1u) {\n knnDistances[graphIndex][i] = 99999.0;\n knnIndexes[graphIndex][i] = 0u;\n }\n }\n \n for (var i: u32 = pairComparisonStartAt; i < pairComparisonEndAt; i = i + 1u) {\n if (i == index) {continue;}\n let dist = combinedDistance(index, i);\n insertKnn(graphIndex, dist, i);\n }\n \n }\n // this will generate the distance script for each distance metric and then combine them into one\n ${getCombinedDistanceScript(distanceMetrics, processInfo.map((info) => info.maxEntryLen), knnSize, aggregationFunction)}\n \n fn insertKnn(knnIndex: u32, dist: f32, index: u32) {\n // small optimization, if the distance is larger than the last element in the knnDistances, we can skip\n if (dist >= knnDistances[knnIndex][${knnSize} - 1u]) {return;}\n for (var i = 0u; i < ${knnSize}; i = i + 1u) {\n if (dist < knnDistances[knnIndex][i]) {\n for (var j = ${knnSize} - 1u; j > i; j = j - 1u) {\n knnDistances[knnIndex][j] = knnDistances[knnIndex][j - 1u];\n knnIndexes[knnIndex][j] = knnIndexes[knnIndex][j - 1u];\n }\n knnDistances[knnIndex][i] = dist;\n knnIndexes[knnIndex][i] = index;\n return;\n }\n }\n }\n `,\n });\n const pipeline = device.createComputePipeline({\n label: 'hamming compute pipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'calcKNN',\n },\n });\n // calculate the size of computeInfo struct buffer in terms of 32bit values\n // startAtEndAt=4, entrySizes, weights, data0 + data1 + ...\n const computeInfo32Size = 4 + numOfColumns * listSize + numOfColumns + processInfo.reduce((a, b) => a + b.sourceArraySize, 0);\n // calculate the size of suppInfo struct buffer in terms of 32bit values\n const suppInfo32Size = processInfo.reduce((a, b) => a + b.suppInfoSize, 0);\n // create a buffer on the GPU to hold computeInfo\n // beware that struct must be padded to 16 bytes, so we need to calculate the size of the struct in 32bit values\n const computeInfoBufferSize = computeInfo32Size * Uint32Array.BYTES_PER_ELEMENT;\n let paddedComputeInfoBufferSize = computeInfoBufferSize;\n const remainder = computeInfoBufferSize & 15; // check if the size is a multiple of 16\n if (remainder !== 0)\n paddedComputeInfoBufferSize += 16 - remainder; // pad the size accordingly\n const computeInfoBuffer = device.createBuffer({\n label: 'compute info buffer',\n size: paddedComputeInfoBufferSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedComputeInfoArrayBuffer = computeInfoBuffer.getMappedRange(); // get full buffer\n // create vars to hold startAtEndAt\n let startAt = 0;\n let endAt = computationsPerPass;\n let pairComparisonStartAt = 0;\n let pairComparisonEndAt = pairComparisonsPerPass;\n const startAtEndAtSize = 4;\n // copy the data into the buffer at correct places\n let computeInfoOffSet = 0;\n const startAtEndAtView = new Uint32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, startAtEndAtSize); //new Uint32Array(computeInfoBuffer.getMappedRange(computeInfoOffSet, 4 * Uint32Array.BYTES_PER_ELEMENT));\n startAtEndAtView.set([startAt, endAt, pairComparisonStartAt, pairComparisonEndAt]);\n // write entry sizes\n computeInfoOffSet += startAtEndAtSize * Uint32Array.BYTES_PER_ELEMENT;\n const entrySizesView = new Uint32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, arraySizes.length); //new Uint32Array(computeInfoBuffer.getMappedRange(computeInfoOffSet, arraySizes.byteLength));\n entrySizesView.set(arraySizes);\n // write weights\n computeInfoOffSet += arraySizes.byteLength; // arraySizes.length * Uint32Array.BYTES_PER_ELEMENT;\n const weightsView = new Float32Array(mappedComputeInfoArrayBuffer, computeInfoOffSet, numOfColumns); //new Float32Array(computeInfoBuffer.getMappedRange(computeInfoOffSet, numOfColumns * Float32Array.BYTES_PER_ELEMENT));\n weightsView.set(weights);\n // write data\n computeInfoOffSet += numOfColumns * Float32Array.BYTES_PER_ELEMENT;\n for (const info of processInfo) {\n //device.queue.writeBuffer(computeInfoBuffer, computeInfoOffSet, info.flatSourceArray, 0, chunkByteSize);\n const ArrayConstructor = info.EncodedArrayConstructor;\n const chunkSize = info.sourceArraySize;\n const dataView = new ArrayConstructor(mappedComputeInfoArrayBuffer, computeInfoOffSet, chunkSize); //new ArrayConstructor(computeInfoBuffer.getMappedRange(computeInfoOffSet, chunkByteSize));\n dataView.set(info.flatSourceArray);\n computeInfoOffSet += chunkSize * ArrayConstructor.BYTES_PER_ELEMENT;\n }\n // we are done at this point.\n computeInfoBuffer.unmap();\n // create a buffer on the GPU to hold suppInfo\n // same here, we need to pad the size of the struct to 16 bytes\n const suppInfoBufferSize = suppInfo32Size * Uint32Array.BYTES_PER_ELEMENT;\n let paddedSuppInfoBufferSize = suppInfoBufferSize;\n const suppInfoRemainder = suppInfoBufferSize & 15; // check if the size is a multiple of 16\n if (suppInfoRemainder !== 0)\n paddedSuppInfoBufferSize += 16 - suppInfoRemainder; // pad the size accordingly\n paddedSuppInfoBufferSize = Math.max(paddedSuppInfoBufferSize, 16);\n const suppInfoBuffer = device.createBuffer({\n label: 'supp info buffer',\n size: paddedSuppInfoBufferSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedSuppInfoArrayBuffer = suppInfoBuffer.getMappedRange(); // get full buffer\n let suppInfoOffSet = 0;\n for (const info of processInfo) {\n if (info.suppInfoBuffer && info.suppInfoBuffer.byteLength > 0 && info.suppInfoSize > 0) {\n const ArrayConstructor = info.suppInfoType === \"UINT32ARRAY\" /* WGPUENTRYTYPE.UINT32ARRAY */ ? Uint32Array : Float32Array;\n const suppInfoView = new ArrayConstructor(mappedSuppInfoArrayBuffer, suppInfoOffSet, info.suppInfoBuffer.length); //new ArrayConstructor(suppInfoBuffer.getMappedRange(suppInfoOffSet, info.suppInfoBuffer.byteLength));\n suppInfoView.set(info.suppInfoBuffer);\n suppInfoOffSet += info.suppInfoBuffer.byteLength; // info.suppInfoBuffer.length * ArrayConstructor.BYTES_PER_ELEMENT;\n }\n }\n if (suppInfoOffSet === 0) {\n const dummyView = new Uint32Array(mappedSuppInfoArrayBuffer, 0, 4); //new Uint32Array(suppInfoBuffer.getMappedRange(0, 16));\n dummyView.set([1, 1, 1, 1]);\n }\n suppInfoBuffer.unmap();\n const outKnnArraySize = knnSize * Uint32Array.BYTES_PER_ELEMENT * computationsPerPass; // size of the slice of the knnIndexes and knnDistances\n // create a buffer on the GPU to hold knnIndexes and knnDistances\n const bufferDistances = device.createBuffer({\n label: 'buffer distances',\n size: outKnnArraySize,\n usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,\n });\n const bufferIndexes = device.createBuffer({\n label: 'buffer indexes',\n size: outKnnArraySize,\n usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,\n });\n // no need to copy anything to the knn buffers.\n const bytesPerOutArrayRow = knnSize * Uint32Array.BYTES_PER_ELEMENT; // how many bytes one row of the knnDistances and knnIndexes will take\n // Setup a bindGroup to tell the shader which\n // buffer to use for the computation\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for knn buffer',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: bufferIndexes } },\n { binding: 1, resource: { buffer: bufferDistances } },\n { binding: 2, resource: { buffer: computeInfoBuffer } },\n { binding: 3, resource: { buffer: suppInfoBuffer } },\n // { binding: 4, resource: { buffer: arraySizesBuffer } },\n ],\n });\n //create a buffer on the GPU to get a copy of the results\n const resultBufferDistances = device.createBuffer({\n label: 'result buffer distances',\n size: bufferDistances.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n const resultBufferIndexes = device.createBuffer({\n label: 'result buffer indexes',\n size: bufferIndexes.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n for (let iter = 0; iter < Math.ceil(listSize / computationsPerPass); iter++) {\n startAt = iter * computationsPerPass;\n endAt = Math.min((iter + 1) * computationsPerPass, listSize);\n const pairComparisonPasses = Math.ceil(listSize / pairComparisonsPerPass);\n for (let pairIter = 0; pairIter < pairComparisonPasses; pairIter++) {\n pairComparisonStartAt = pairIter * pairComparisonsPerPass;\n pairComparisonEndAt = Math.min((pairIter + 1) * pairComparisonsPerPass, listSize);\n // write only four values to the buffer, startAt, endAt, pairComparisonStartAt, pairComparisonEndAt, corresponding to vec4<u32> at the start of info struct\n device.queue.writeBuffer(computeInfoBuffer, 0, new Uint32Array([\n startAt,\n endAt,\n pairComparisonStartAt,\n pairComparisonEndAt,\n ]));\n // Encode commands to do the computation\n const encoder = device.createCommandEncoder({\n label: 'distance encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'distance compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(workgroupsDim, \n //workgroupsDim,\n Math.ceil(computationsPerPass / workgroupsDim / threadsPerWorkgroup));\n pass.end();\n // if we are at the last pair comparison pass, we need to read the results\n if (pairIter === pairComparisonPasses - 1) {\n // Encode a command to copy the results to a mappable buffer.\n encoder.copyBufferToBuffer(bufferDistances, 0, resultBufferDistances, 0, resultBufferDistances.size);\n encoder.copyBufferToBuffer(bufferIndexes, 0, resultBufferIndexes, 0, resultBufferIndexes.size);\n // Finish encoding and submit the commands\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n // Read the results\n //console.time('pass end');\n yield device.queue.onSubmittedWorkDone();\n // console.timeEnd('pass end');\n // console.time(\"read\");\n //const offsetBytes = startAt * bytesPerOutArrayRow;\n //const sizeBytes = (endAt - startAt) * bytesPerOutArrayRow;\n yield resultBufferDistances.mapAsync(GPUMapMode.READ);\n yield resultBufferIndexes.mapAsync(GPUMapMode.READ);\n // console.timeEnd(\"read\");\n const indexes = resultBufferIndexes.getMappedRange();\n const distances = resultBufferDistances.getMappedRange();\n // console.time(\"decode\");\n for (let i = 0; i < endAt - startAt; i++) {\n const index = new Uint32Array(indexes, i * bytesPerOutArrayRow, knnSize);\n const distance = new Float32Array(distances, i * bytesPerOutArrayRow, knnSize);\n resultIndexes[startAt + i].set(index);\n resultDistances[startAt + i].set(distance);\n }\n resultBufferIndexes.unmap();\n resultBufferDistances.unmap();\n }\n else {\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n // Read the results\n // console.time('pass between');\n yield device.queue.onSubmittedWorkDone();\n // console.timeEnd('pass between');\n }\n // device may get lost during opperation, so in this case, we need to return null\n if (deviceLost)\n return null;\n }\n }\n bufferDistances.destroy();\n bufferIndexes.destroy();\n computeInfoBuffer.destroy();\n suppInfoBuffer.destroy();\n resultBufferDistances.destroy();\n resultBufferIndexes.destroy();\n if (deviceLost)\n return null;\n return { knnIndexes: resultIndexes, knnDistances: resultDistances };\n });\n}\nfunction getCombinedDistanceScript(distanceMetrics, maxEntryLens, knnSize, aggregation) {\n const distanceWgsls = distanceMetrics.map((metric, i) => {\n return `\n fn distanceScript${i}(aIndex: u32, bIndex: u32) -> f32 {\n let a = computeInfo.data${i}[aIndex];\n let b = computeInfo.data${i}[bIndex];\n let maxDistance: f32 = knnDistances[aIndex - computeInfo.startAtEndAt.x][${knnSize} - 1u];\n ${webGPUFunctions[metric](maxEntryLens[i], i)}\n }\n `;\n });\n const allDistanceScripts = distanceWgsls.join('\\n');\n const combineDistancesScript = `\n fn combinedDistance(aIndex: u32, bIndex: u32) -> f32 {\n var distances: array<f32, ${distanceMetrics.length}>;\n ${distanceMetrics.map((_, i) => `distances[${i}] = distanceScript${i}(aIndex, bIndex);`).join('\\n')}\n ${WEBGSLAGGREGATIONFUNCTIONS[aggregation](distanceMetrics.length)}\n }\n \n `;\n return allDistanceScripts + '\\n' + combineDistancesScript;\n}\n//# sourceMappingURL=multiCol-KNN.js.map","export var MatrixMatrixOpType;\n(function (MatrixMatrixOpType) {\n MatrixMatrixOpType[\"ADD\"] = \"ADD\";\n MatrixMatrixOpType[\"SUB\"] = \"SUB\";\n MatrixMatrixOpType[\"MULT\"] = \"MULT\";\n})(MatrixMatrixOpType || (MatrixMatrixOpType = {}));\nexport var MatrixOpType;\n(function (MatrixOpType) {\n MatrixOpType[\"SQUARE\"] = \"SQUARE\";\n MatrixOpType[\"INVERSE\"] = \"INVERSE\";\n MatrixOpType[\"TRANSPOSE\"] = \"TRANSPOSE\";\n MatrixOpType[\"NORM\"] = \"NORM\";\n MatrixOpType[\"COLUMN_NORM\"] = \"COLUMN_NORM\";\n})(MatrixOpType || (MatrixOpType = {}));\nexport var MatrixScalarOpType;\n(function (MatrixScalarOpType) {\n MatrixScalarOpType[\"SCALARMULT\"] = \"SCALARMULT\";\n MatrixScalarOpType[\"SCALARADD\"] = \"SCALARADD\";\n MatrixScalarOpType[\"SCALARPOW\"] = \"SCALARPOW\";\n})(MatrixScalarOpType || (MatrixScalarOpType = {}));\n//# sourceMappingURL=types.js.map","/* eslint-disable max-len */\nimport { distanceFunctionComplexity, TypeSupportedDistances, WEBGPUDISTANCE } from '../multi-col-distances/webGPU-multicol-distances';\nexport function webGPUProcessInfo(entryList, distanceMetric = WEBGPUDISTANCE.HAMMING, entryIndex, // index of the entries in the list of lists that we want to process\noptions = { gapOpenPenalty: 1.0, gapExtensionPenalty: 0.6 }) {\n var _a, _b;\n let entryType = null;\n const encodedList = (() => {\n if (entryList.some((e) => typeof e === 'string')) {\n entryType = \"STRING\" /* WGPUENTRYTYPE.STRING */;\n return entryList.map((entry) => new Uint32Array(entry.split('').map((c) => c.charCodeAt(0))));\n }\n if (entryList.some((e) => typeof e === 'number')) {\n entryType = \"NUMBER\" /* WGPUENTRYTYPE.NUMBER */;\n return entryList.map((entry) => new Float32Array([entry]));\n }\n if (typeof entryList[0] == 'object' && entryList.some((e) => '_data' in e && '_length' in e)) {\n entryType = \"BITARRAY\" /* WGPUENTRYTYPE.BITARRAY */;\n return entryList.map((entry) => entry._data);\n }\n if (entryList.some((e) => e instanceof Float32Array)) {\n entryType = \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */;\n return entryList;\n }\n if (entryList.some((e) => e instanceof Uint32Array)) {\n entryType = \"UINT32ARRAY\" /* WGPUENTRYTYPE.UINT32ARRAY */;\n return entryList;\n }\n if (entryList.some((e) => e instanceof Int32Array)) {\n entryType = \"INT32ARRAY\" /* WGPUENTRYTYPE.INT32ARRAY */;\n return entryList;\n }\n //return entryList as Uint32Array[];\n })();\n if (!encodedList || !entryType)\n throw new Error('Invalid entry type, could not determine entry type from input list');\n const encodedListType = encodedList[0] instanceof Int32Array ? \"INT32ARRAY\" /* WGPUENTRYTYPE.INT32ARRAY */ :\n encodedList[0] instanceof Float32Array ? \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */ : \"UINT32ARRAY\" /* WGPUENTRYTYPE.UINT32ARRAY */;\n // sizes of each entries might differ, so we need to keep track of that for some distance metrics, like hamming for example\n const arraySizes = new Uint32Array(encodedList.map((arr) => arr.length));\n if (!TypeSupportedDistances[entryType] || !TypeSupportedDistances[entryType].has(distanceMetric))\n throw new Error(`Distance metric '${distanceMetric}' not supported for entry type '${entryType}'`);\n const maxEntryLen = arraySizes.reduce((a, b) => Math.max(a, b), 0);\n // get the complexity of used algorithm\n const complexity = distanceFunctionComplexity[distanceMetric](maxEntryLen);\n const EncodedArrayConstructor = encodedListType === \"INT32ARRAY\" /* WGPUENTRYTYPE.INT32ARRAY */ ? Int32Array :\n (encodedListType === \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */ ? Float32Array : Uint32Array);\n const flatSourceArray = new EncodedArrayConstructor(encodedList.length * maxEntryLen);\n // when setting, we need to set each array at a specific offset, which is controlled by maxArrayLen because each array might have different sizes.\n // this way we will get correct matrix representation in the compute shader\n encodedList.forEach((seq, i) => {\n flatSourceArray.set(seq, i * maxEntryLen);\n });\n // NB! all this before the line was generic, now we need to calculate some specific things for some specific distance metrics\n // initialize supp info line that will be included in the final shader;\n let suppInfoStructWgsl = ''; // the code that will be included in the struct of suppInfo\n let suppInfoSize = 0;\n let suppInfoType = \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */;\n let suppInfoBuffer = null;\n if (distanceMetric === WEBGPUDISTANCE.NEEDLEMAN_WUNSCH || distanceMetric === WEBGPUDISTANCE.MONOMER_CHEMICAL_DISTANCE) {\n let maxMonomerIndex = options.scoringMatrix && options.alphabetIndexes ?\n Object.keys(options.alphabetIndexes).reduce((prev, n) => Math.max(prev, n.charCodeAt(0)), 0) : -1;\n // generate default similarity matrix if it is not provided\n if (!options.alphabetIndexes || !options.scoringMatrix) {\n for (let i = 0; i < flatSourceArray.length; i++) {\n if (flatSourceArray[i] > maxMonomerIndex)\n maxMonomerIndex = flatSourceArray[i];\n }\n options.scoringMatrix =\n new Array(maxMonomerIndex + 1).fill(null).map(() => new Array(maxMonomerIndex + 1).fill(0));\n options.alphabetIndexes = {};\n for (let i = 0; i < options.scoringMatrix.length; i++) {\n options.scoringMatrix[i][i] = 1;\n options.alphabetIndexes[String.fromCharCode(i)] = i;\n }\n }\n const similarityMatrixSize = (maxMonomerIndex + 1) * (maxMonomerIndex + 1);\n const transferedSimilarityMatrix = new Array(maxMonomerIndex + 1).fill(null).map(() => new Float32Array(maxMonomerIndex + 1));\n // set diagonal to 1\n for (let i = 0; i < maxMonomerIndex + 1; i++)\n transferedSimilarityMatrix[i][i] = 1;\n const alphabetIndexes = options.alphabetIndexes;\n for (const key of Object.keys(alphabetIndexes)) {\n for (const key2 of Object.keys(alphabetIndexes)) {\n if (key === key2)\n continue;\n transferedSimilarityMatrix[key.charCodeAt(0)][key2.charCodeAt(0)] =\n options.scoringMatrix[alphabetIndexes[key]][alphabetIndexes[key2]];\n }\n }\n // in memory layout, we will have 2 float32 s for gapOpen and gapExtension penalties, and then f32 array<array<f32>> for similarity matrix.\n // because of primitives, there will be no padding, so we can calculate the size directly\n suppInfoSize = 2 + similarityMatrixSize;\n suppInfoType = \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */;\n suppInfoBuffer = new Float32Array(suppInfoSize);\n suppInfoBuffer[0] = (_a = options.gapOpenPenalty) !== null && _a !== void 0 ? _a : 1.0;\n suppInfoBuffer[1] = (_b = options.gapExtensionPenalty) !== null && _b !== void 0 ? _b : 0.6;\n let offset = 2;\n for (let i = 0; i < transferedSimilarityMatrix.length; i++) {\n suppInfoBuffer.set(transferedSimilarityMatrix[i], offset);\n offset += transferedSimilarityMatrix[i].length;\n }\n suppInfoStructWgsl = `\n gapOpenPenalty${entryIndex}: f32,\n gapExtensionPenalty${entryIndex}: f32,\n similarityMatrix${entryIndex}: array<array<f32, ${maxMonomerIndex + 1}>, ${maxMonomerIndex + 1}>`;\n }\n else if (distanceMetric === WEBGPUDISTANCE.Difference) {\n // for difference, we need range of values for normalization of the difference\n if (!options.range || typeof options.range !== 'number' || options.range <= 0) {\n const min = flatSourceArray.reduce((a, b) => Math.min(a, b), flatSourceArray[0]);\n const max = flatSourceArray.reduce((a, b) => Math.max(a, b), flatSourceArray[0]);\n options.range = max - min;\n }\n if (options.range <= 0)\n options.range = 1.0; // this means that all values are the same, and all distances will produce 0.\n suppInfoSize = 1;\n suppInfoType = \"FLOAT32ARRAY\" /* WGPUENTRYTYPE.FLOAT32ARRAY */;\n suppInfoBuffer = new Float32Array([options.range]);\n suppInfoStructWgsl = `\n range${entryIndex}: f32`;\n }\n const dataTypeWGSL = flatSourceArray instanceof Int32Array ? 'i32' : (flatSourceArray instanceof Float32Array ? 'f32' : 'u32');\n const dataStructWgsl = `data${entryIndex}: array<array<${dataTypeWGSL}, ${maxEntryLen}>, ${encodedList.length}>`;\n // for now, other distances do not require any additional information, so we can skip that\n return {\n flatSourceArray,\n sourceArraySize: flatSourceArray.length,\n maxEntryLen,\n arraySizes,\n complexity,\n suppInfoBuffer,\n suppInfoSize,\n suppInfoType: suppInfoType,\n suppInfoStructWgsl,\n entryType,\n dataTypeWGSL,\n dataStructWgsl,\n EncodedArrayConstructor\n };\n}\n//# sourceMappingURL=webGPU-process-info.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\nimport { knnMatrixOpInfoWGSL } from './wgsl/knn-sparse-info.wgsl';\n/**\n * this will get all the info needed for subsequent operation in umap\n * like sizes of each array of transposed knn and sizes of union of knn and its transpose rows.\n * after this point, all knn structures will be in single array form, with corresponding offsets.\n * @param knnIndexes\n * @returns\n */\nexport function getKnnSparseOpInfo(knnIndexes) {\n return __awaiter(this, void 0, void 0, function* () {\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const numOfEntries = knnIndexes.length;\n const requiredWorkgroups = Math.ceil(numOfEntries / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const knnSize = knnIndexes[0].length;\n const processWgsl = knnMatrixOpInfoWGSL(threadsPerWorkgroupDim, threadsPerWorkgroupDim * numOfWorkgroupsPerDim, numOfEntries, knnSize);\n const indexesBuffer32Size = numOfEntries * knnIndexes[0].length;\n const device = yield getGPUDevice();\n if (device == null)\n return;\n const module = device.createShaderModule({\n label: 'transposedSizesCalulation',\n code: processWgsl\n });\n const pipeline = device.createComputePipeline({\n label: 'transposedSizesPipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'countTransposedCols',\n },\n });\n const indexBuffer = device.createBuffer({\n label: 'indexes buffer',\n size: indexesBuffer32Size * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedIndexesBuffer = indexBuffer.getMappedRange();\n const mappedIndexesArray = new Int32Array(mappedIndexesBuffer);\n for (let i = 0; i < knnIndexes.length; i++)\n mappedIndexesArray.set(knnIndexes[i], i * knnIndexes[i].length);\n indexBuffer.unmap();\n const sizesBuffer = device.createBuffer({\n label: 'transpose sizes buffer',\n size: knnIndexes.length * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n });\n const unionSizesBuffer = device.createBuffer({\n label: 'union sizes buffer',\n size: knnIndexes.length * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedUnionSizesBuffer = unionSizesBuffer.getMappedRange();\n const mappedUnionSizesArray = new Uint32Array(mappedUnionSizesBuffer);\n mappedUnionSizesArray.fill(knnSize);\n unionSizesBuffer.unmap();\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for count ops',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: indexBuffer } },\n { binding: 1, resource: { buffer: sizesBuffer } },\n { binding: 2, resource: { buffer: unionSizesBuffer } }\n // { binding: 4, resource: { buffer: arraySizesBuffer } },\n ],\n });\n const encoder = device.createCommandEncoder({\n label: 'matrix ops encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'matrix ops compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n const resultTransposeSizesBuffer = device.createBuffer({\n label: 'result transpose sizes',\n size: sizesBuffer.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n const resultUnionSizesBuffer = device.createBuffer({\n label: 'result union sizes',\n size: unionSizesBuffer.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n encoder.copyBufferToBuffer(sizesBuffer, 0, resultTransposeSizesBuffer, 0, resultTransposeSizesBuffer.size);\n encoder.copyBufferToBuffer(unionSizesBuffer, 0, resultUnionSizesBuffer, 0, resultUnionSizesBuffer.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n yield resultTransposeSizesBuffer.mapAsync(GPUMapMode.READ);\n yield resultUnionSizesBuffer.mapAsync(GPUMapMode.READ);\n const resultTransposeSizesArrayBuffer = resultTransposeSizesBuffer.getMappedRange();\n const resultUnionSizesArrayBuffer = resultUnionSizesBuffer.getMappedRange();\n const resultTransposeSizesArray = new Uint32Array(knnIndexes.length);\n resultTransposeSizesArray.set(new Uint32Array(resultTransposeSizesArrayBuffer, 0, knnIndexes.length));\n resultTransposeSizesBuffer.unmap();\n const resultUnionSizesArray = new Uint32Array(knnIndexes.length);\n resultUnionSizesArray.set(new Uint32Array(resultUnionSizesArrayBuffer, 0, knnIndexes.length));\n resultUnionSizesBuffer.unmap();\n const unionMatrixSize = resultUnionSizesArray.reduce((old, val) => old + val, 0);\n resultUnionSizesBuffer.destroy();\n resultTransposeSizesBuffer.destroy();\n sizesBuffer.destroy();\n indexBuffer.destroy();\n unionSizesBuffer.destroy();\n // sizes of each transposed knn row, sizes of each union of knn and its transpose row, total size of union matrix\n return { resultTransposeSizesArray, resultUnionSizesArray, unionMatrixSize };\n //counteTransposedCols\n });\n}\n//# sourceMappingURL=knn-sparse-info.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\n/* eslint-disable max-len */\n/**\n * wgsl code for pairwise operation on two sparse matrices.\n * @param indexes1 - indexes of first sparse matrix\n * @param distances1 - values1 of first sparse matrix\n * @param offsets1 - 32 bit offsets of first sparse matrix\n * @param indexes2 - indexes of second sparse matrix\n * @param distances2 - values of second sparse matrix\n * @param offsets2 - 32 bit offsets of second sparse matrix\n * @param numOfEntries - number of entries in original data\n * @param unionMatrixOffsets - offsets of union matrix, used to store result\n * @param op - operation to perform\n * @returns\n */\nexport function pairwiseOpSparse(indexes1, distances1, offsets1, indexes2, distances2, offsets2, numOfEntries, unionMatrixOffsets, // array of size numOfEntries + 1\nop) {\n return __awaiter(this, void 0, void 0, function* () {\n // this function is only meant for regular knn matrix, not for sparse matrix for of knn.\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const requiredWorkgroups = Math.ceil(numOfEntries / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const threadsPerYDimension = threadsPerWorkgroupDim * numOfWorkgroupsPerDim;\n const sparseSize1 = offsets1[offsets1.length - 1];\n const sparseSize2 = offsets2[offsets2.length - 1];\n // this array will have offsets of each row in union matrix with length of numOfEntries + 1\n const unionMatrixSize = unionMatrixOffsets[unionMatrixOffsets.length - 1]; // last index will be last offset i.e. full size\n const processWgsl = `\n struct SparseKNNStorage1 {\n indexes:array<i32, ${sparseSize1}>,\n knnDistances: array<f32, ${sparseSize1}>,\n offsets: array<u32, ${numOfEntries + 1}>\n }\n\n struct SparseKNNStorage2 {\n indexes:array<i32, ${sparseSize2}>,\n knnDistances: array<f32, ${sparseSize2}>,\n offsets: array<u32, ${numOfEntries + 1}>\n }\n\n struct ResKnn {\n knnIndexes: array<i32, ${unionMatrixSize}>,\n knnDistances: array<f32, ${unionMatrixSize}>\n }\n\n @group(0) @binding(0) var<storage, read_write> source1: SparseKNNStorage1;\n @group(0) @binding(1) var<storage, read_write> source2: SparseKNNStorage2;\n @group(0) @binding(2) var<storage, read_write> result: ResKnn;\n @group(0) @binding(3) var<storage, read_write> unionMatrixOffsets: array<u32, ${numOfEntries + 1}>;\n @compute @workgroup_size(${threadsPerWorkgroupDim}, ${threadsPerWorkgroupDim}) fn pairwiseOp(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n\n let col: u32 = id.x;\n let row: u32 = id.y;\n let workingIndex: u32 = row * ${threadsPerYDimension} + col;\n\n if (workingIndex >= ${numOfEntries}) {\n return;\n }\n var curUnionOffset: u32 = unionMatrixOffsets[workingIndex]; // offset at which to start writing in union matrix\n\n let start1 = source1.offsets[workingIndex];\n let end1 = source1.offsets[workingIndex + 1];\n let start2 = source2.offsets[workingIndex];\n let end2 = source2.offsets[workingIndex + 1];\n // TODO: sort a copy of these arrays, will make operation faster\n for (var i: u32 = start1; i < end1; i++) {\n let val1: f32 = source1.knnDistances[i];\n var val2: f32 = 0.0;\n let curIndex: i32 = source1.indexes[i];\n for (var j: u32 = start2; j < end2; j++) {\n if (source2.indexes[j] == curIndex) {\n val2 = source2.knnDistances[j];\n break;\n }\n }\n \n result.knnIndexes[curUnionOffset] = curIndex;\n result.knnDistances[curUnionOffset] = val1 ${op} val2;\n curUnionOffset += 1;\n }\n\n if (curUnionOffset >= unionMatrixOffsets[workingIndex + 1]) {\n // small optimization applicable only to our case, but saves a good amount of time\n return;\n }\n\n // do the same for source2 but skip the indexes where they are already present in source1\n for (var i: u32 = start2; i < end2; i++) {\n let val1: f32 = source2.knnDistances[i];\n let curIndex: i32 = source2.indexes[i];\n var found = false;\n for (var j: u32 = start1; j < end1; j++) {\n if (source1.indexes[j] == curIndex) {\n found = true;\n break;\n }\n }\n if (!found) {\n result.knnIndexes[curUnionOffset] = curIndex;\n result.knnDistances[curUnionOffset] = val1 ${op} 0.0;\n curUnionOffset += 1;\n }\n }\n }\n`;\n const storage32Size1 = sparseSize1 * 2 + numOfEntries + 1;\n const storage32Size2 = sparseSize2 * 2 + numOfEntries + 1;\n const resStorage32Size = unionMatrixSize * 2;\n // standard stuff to pad the storage size to multiple of 16 bytes\n let paddedStorage1ByteSize = storage32Size1 * 4;\n const remainder1 = paddedStorage1ByteSize & 15;\n if (remainder1 !== 0)\n paddedStorage1ByteSize += 16 - remainder1;\n let paddedStorage2ByteSize = storage32Size2 * 4;\n const remainder2 = paddedStorage2ByteSize & 15;\n if (remainder2 !== 0)\n paddedStorage2ByteSize += 16 - remainder2;\n let paddedResStorageByteSize = resStorage32Size * 4;\n const remainder3 = paddedResStorageByteSize & 15;\n if (remainder3 !== 0)\n paddedResStorageByteSize += 16 - remainder3;\n const device = yield getGPUDevice();\n if (device == null)\n return;\n const module = device.createShaderModule({\n label: 'pairwiseOpShader',\n code: processWgsl\n });\n const pipeline = device.createComputePipeline({\n label: 'pairwiseOpPipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'pairwiseOp',\n },\n });\n // input params\n const source1Buffer = device.createBuffer({\n label: 'source 1 buffer',\n size: paddedStorage1ByteSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedSource1Buffer = source1Buffer.getMappedRange();\n const source1IndexesArray = new Int32Array(mappedSource1Buffer, 0, sparseSize1);\n source1IndexesArray.set(indexes1);\n const source1DistancesArray = new Float32Array(mappedSource1Buffer, sparseSize1 * 4, sparseSize1);\n source1DistancesArray.set(distances1);\n const source1OffsetsArray = new Uint32Array(mappedSource1Buffer, sparseSize1 * 8, numOfEntries + 1);\n source1OffsetsArray.set(offsets1);\n source1Buffer.unmap();\n const source2Buffer = device.createBuffer({\n label: 'source 2 buffer',\n size: paddedStorage2ByteSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedSource2Buffer = source2Buffer.getMappedRange();\n const source2IndexesArray = new Int32Array(mappedSource2Buffer, 0, sparseSize2);\n source2IndexesArray.set(indexes2);\n const source2DistancesArray = new Float32Array(mappedSource2Buffer, sparseSize2 * 4, sparseSize2);\n source2DistancesArray.set(distances2);\n const source2OffsetsArray = new Uint32Array(mappedSource2Buffer, sparseSize2 * 8, numOfEntries + 1);\n source2OffsetsArray.set(offsets2);\n source2Buffer.unmap();\n const resBuffer = device.createBuffer({\n label: 'res buffer',\n size: paddedResStorageByteSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n });\n const unionMatrixOffsetsBuffer = device.createBuffer({\n label: 'union matrix offsets buffer',\n size: (numOfEntries + 1) * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedUnionMatrixOffsetsBuffer = unionMatrixOffsetsBuffer.getMappedRange();\n const unionMatrixOffsetsArray = new Uint32Array(mappedUnionMatrixOffsetsBuffer);\n unionMatrixOffsetsArray.set(unionMatrixOffsets);\n unionMatrixOffsetsBuffer.unmap();\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for pairwise ops',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: source1Buffer } },\n { binding: 1, resource: { buffer: source2Buffer } },\n { binding: 2, resource: { buffer: resBuffer } },\n { binding: 3, resource: { buffer: unionMatrixOffsetsBuffer } }\n ],\n });\n const encoder = device.createCommandEncoder({\n label: 'matrix ops encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'matrix ops compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n const resultBuffer = device.createBuffer({\n label: 'result buffer',\n size: paddedResStorageByteSize,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n encoder.copyBufferToBuffer(resBuffer, 0, resultBuffer, 0, resultBuffer.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n yield resultBuffer.mapAsync(GPUMapMode.READ);\n const resultArrayBuffer = resultBuffer.getMappedRange();\n const resultKnnIndexes = new Int32Array(unionMatrixSize);\n const resultKnnDistances = new Float32Array(unionMatrixSize);\n // its actually a sparse matrix.\n resultKnnIndexes.set(new Int32Array(resultArrayBuffer, 0, unionMatrixSize));\n resultKnnDistances.set(new Float32Array(resultArrayBuffer, unionMatrixSize * 4, unionMatrixSize));\n resultBuffer.unmap();\n resultBuffer.destroy();\n source1Buffer.destroy();\n source2Buffer.destroy();\n resBuffer.destroy();\n unionMatrixOffsetsBuffer.destroy();\n return { resultKnnIndexes, resultKnnDistances };\n });\n}\n//# sourceMappingURL=pairwise-sparse-ops.js.map","/**\n * the sum of the weighted squares of the errors (or weighted residuals) between the data.y\n * and the curve-fit function.\n * @ignore\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {ArrayLike<number>} parameters - Array of current parameter values\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n * @param {ArrayLike<number>} weightSquare - Square of weights\n * @return {number}\n */\nexport default function errorCalculation(data, parameters, parameterizedFunction, weightSquare) {\n let error = 0;\n const func = parameterizedFunction(parameters);\n for (let i = 0; i < data.x.length; i++) {\n error += Math.pow(data.y[i] - func(data.x[i]), 2) / weightSquare[i];\n }\n return error;\n}\n//# sourceMappingURL=errorCalculation.js.map","import { inverse, Matrix } from 'ml-matrix';\nimport gradientFunction from './gradientFunction';\n/**\n * Matrix function over the samples\n * @ignore\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {ArrayLike<number>} evaluatedData - Array of previous evaluated function values\n * @return {Matrix}\n */\nfunction matrixFunction(data, evaluatedData) {\n const m = data.x.length;\n let ans = new Matrix(m, 1);\n for (let point = 0; point < m; point++) {\n ans.set(point, 0, data.y[point] - evaluatedData[point]);\n }\n return ans;\n}\n/**\n * Iteration for Levenberg-Marquardt\n * @ignore\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number} damping - Levenberg-Marquardt parameter\n * @param {number|array} gradientDifference - The step size to approximate the jacobian matrix\n * @param {boolean} centralDifference - If true the jacobian matrix is approximated by central differences otherwise by forward differences\n * @param {function} parameterizedFunction - The parameters and returns a function with the independent variable as a parameter\n */\nexport default function step(data, params, damping, gradientDifference, parameterizedFunction, centralDifference, weights) {\n let value = damping;\n let identity = Matrix.eye(params.length, params.length, value);\n const func = parameterizedFunction(params);\n let evaluatedData = new Float64Array(data.x.length);\n for (let i = 0; i < data.x.length; i++) {\n evaluatedData[i] = func(data.x[i]);\n }\n let gradientFunc = gradientFunction(data, evaluatedData, params, gradientDifference, parameterizedFunction, centralDifference);\n let residualError = matrixFunction(data, evaluatedData);\n let inverseMatrix = inverse(identity.add(gradientFunc.mmul(gradientFunc.transpose().scale('row', { scale: weights }))));\n let jacobianWeightResidualError = gradientFunc.mmul(residualError.scale('row', { scale: weights }));\n let perturbations = inverseMatrix.mmul(jacobianWeightResidualError);\n return {\n perturbations,\n jacobianWeightResidualError,\n };\n}\n//# sourceMappingURL=step.js.map","import { Matrix } from 'ml-matrix';\n/**\n * Difference of the matrix function over the parameters\n * @ignore\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {ArrayLike<number>} evaluatedData - Array of previous evaluated function values\n * @param {Array<number>} params - Array of previous parameter values\n * @param {number|array} gradientDifference - The step size to approximate the jacobian matrix\n * @param {boolean} centralDifference - If true the jacobian matrix is approximated by central differences otherwise by forward differences\n * @param {function} paramFunction - The parameters and returns a function with the independent variable as a parameter\n * @return {Matrix}\n */\nexport default function gradientFunction(data, evaluatedData, params, gradientDifference, paramFunction, centralDifference) {\n const nbParams = params.length;\n const nbPoints = data.x.length;\n let ans = Matrix.zeros(nbParams, nbPoints);\n let rowIndex = 0;\n for (let param = 0; param < nbParams; param++) {\n if (gradientDifference[param] === 0)\n continue;\n let delta = gradientDifference[param];\n let auxParams = params.slice();\n auxParams[param] += delta;\n let funcParam = paramFunction(auxParams);\n if (!centralDifference) {\n for (let point = 0; point < nbPoints; point++) {\n ans.set(rowIndex, point, (evaluatedData[point] - funcParam(data.x[point])) / delta);\n }\n }\n else {\n auxParams = params.slice();\n auxParams[param] -= delta;\n delta *= 2;\n let funcParam2 = paramFunction(auxParams);\n for (let point = 0; point < nbPoints; point++) {\n ans.set(rowIndex, point, (funcParam2(data.x[point]) - funcParam(data.x[point])) / delta);\n }\n }\n rowIndex++;\n }\n return ans;\n}\n//# sourceMappingURL=gradientFunction.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { levenbergMarquardt } from 'ml-levenberg-marquardt';\nexport function linear(x1, x2, n) {\n const step = (x2 - x1) / (n - 1);\n return Array.from({ length: n }, (_, i) => x1 + step * i);\n}\n/**\n * Fit a, b params for the differentiable curve used in lower\n * dimensional fuzzy simplicial complex construction. We want the\n * smooth curve (from a pre-defined family with simple gradient) that\n * best matches an offset exponential decay.\n */\nexport function findABParams(spread, minDist) {\n const curve = ([a, b]) => (x) => {\n return 1.0 / (1.0 + a * Math.pow(x, (2 * b)));\n };\n const xv = linear(0, spread * 3, 300)\n .map((val) => (val < minDist ? 1.0 : val));\n const yv = new Array(xv.length).fill(0).map((val, index) => {\n const gte = xv[index] >= minDist;\n return gte ? Math.exp(-(xv[index] - minDist) / spread) : val;\n });\n const initialValues = [0.5, 0.5];\n const data = { x: xv, y: yv };\n // Default options for the algorithm (from github example)\n const options = {\n damping: 1.5,\n initialValues,\n gradientDifference: 10e-2,\n maxIterations: 100,\n errorTolerance: 10e-3,\n };\n // eslint-disable-next-line new-cap\n const { parameterValues } = levenbergMarquardt(data, curve, options);\n const [a, b] = parameterValues;\n return { a, b };\n}\n/**\n * heuristic for number of epochs of umap, differs from cpu version, because of the way gpu passes data\n * @param entryLen number of entries\n * @returns\n */\nexport function getNEpochs(entryLen) {\n //\n const length = entryLen;\n if (length <= 2500)\n return 1000;\n else if (length <= 5000)\n return 800;\n else if (length <= 7500)\n return 650;\n else\n return 400;\n}\n/** helper function that transforms array of sizes to offset form */\nexport function toOffsetForm(ar) {\n const res = new Uint32Array(ar.length + 1);\n let offset = 0;\n for (let i = 0; i < ar.length; i++) {\n res[i] = offset;\n offset += ar[i];\n }\n res[ar.length] = offset;\n return res;\n}\n/** multiplies flat representation of sparse knn info by scalar.\n * also no point of doing this on gpu, can be done on cpu pretty quickly.\n * if there will be need for it, it can be done on gpu as well very very easily.\n * @param values values array\n * @param scalar\n */\nexport function multiplyScalar(values, scalar) {\n for (let i = 0; i < values.length; i++)\n values[i] = values[i] * scalar;\n}\n/**\n * generate transpose of knn from the transposition info taken from sparse knn info\n * using this information avoids billions of array.push calls, is much cleaner, allows typed array use and is faster.\n * no point of doing this on gpu, can be done on cpu as we already have all the info needed.\n * @param knnIndexes\n * @param knnDistances\n * @param knnSparseInfo\n * @param knnSize\n * @returns\n */\nexport function transposeKNN(knnIndexes, knnDistances, knnSparseInfo, knnSize = 15) {\n return __awaiter(this, void 0, void 0, function* () {\n const numOfEntries = knnIndexes.length;\n const fullKnnEntrySize = knnSize * numOfEntries;\n const transposeSizes = knnSparseInfo.resultTransposeSizesArray;\n const transposeOffsets = toOffsetForm(transposeSizes);\n const offsetsCopy = new Uint32Array(transposeOffsets.length);\n offsetsCopy.set(transposeOffsets); // will be used for dynamic indexing\n const transposeKNNIndexes = new Int32Array(fullKnnEntrySize).fill(0);\n const transposeKNNDistances = new Float32Array(fullKnnEntrySize).fill(0);\n for (let i = 0; i < numOfEntries; i++) {\n for (let j = 0; j < knnSize; j++) {\n const otherIndex = knnIndexes[i][j];\n const otherIndexOffset = offsetsCopy[otherIndex];\n transposeKNNIndexes[otherIndexOffset] = i;\n transposeKNNDistances[otherIndexOffset] = knnDistances[i][j];\n offsetsCopy[otherIndex] += 1;\n }\n }\n return { transposeKNNIndexes, transposeKNNDistances, transposeOffsets };\n });\n}\n//# sourceMappingURL=utils.js.map","import checkOptions from './checkOptions';\nimport errorCalculation from './errorCalculation';\nimport step from './step';\n/**\n * Curve fitting algorithm\n * @param {{x:ArrayLike<number>, y:ArrayLike<number>}} data - Array of points to fit in the format [x1, x2, ... ], [y1, y2, ... ]\n * @param {function} parameterizedFunction - Takes an array of parameters and returns a function with the independent variable as its sole argument\n * @param {object} options - Options object\n * @param {ArrayLike<number>} options.initialValues - Array of initial parameter values\n * @param {number|ArrayLike<number>} [options.weights = 1] - weighting vector, if the length does not match with the number of data points, the vector is reconstructed with first value.\n * @param {number} [options.damping = 1e-2] - Levenberg-Marquardt parameter, small values of the damping parameter λ result in a Gauss-Newton update and large\nvalues of λ result in a gradient descent update\n * @param {number} [options.dampingStepDown = 9] - factor to reduce the damping (Levenberg-Marquardt parameter) when there is not an improvement when updating parameters.\n * @param {number} [options.dampingStepUp = 11] - factor to increase the damping (Levenberg-Marquardt parameter) when there is an improvement when updating parameters.\n * @param {number} [options.improvementThreshold = 1e-3] - the threshold to define an improvement through an update of parameters\n * @param {number|ArrayLike<number>} [options.gradientDifference = 10e-2] - The step size to approximate the jacobian matrix\n * @param {boolean} [options.centralDifference = false] - If true the jacobian matrix is approximated by central differences otherwise by forward differences\n * @param {ArrayLike<number>} [options.minValues] - Minimum allowed values for parameters\n * @param {ArrayLike<number>} [options.maxValues] - Maximum allowed values for parameters\n * @param {number} [options.maxIterations = 100] - Maximum of allowed iterations\n * @param {number} [options.errorTolerance = 10e-3] - Minimum uncertainty allowed for each point.\n * @param {number} [options.timeout] - maximum time running before throw in seconds.\n * @return {{parameterValues: Array<number>, parameterError: number, iterations: number}}\n */\nexport function levenbergMarquardt(data, parameterizedFunction, options) {\n let { checkTimeout, minValues, maxValues, parameters, weightSquare, damping, dampingStepUp, dampingStepDown, maxIterations, errorTolerance, centralDifference, gradientDifference, improvementThreshold, } = checkOptions(data, parameterizedFunction, options);\n let error = errorCalculation(data, parameters, parameterizedFunction, weightSquare);\n let optimalError = error;\n let optimalParameters = parameters.slice();\n let converged = error <= errorTolerance;\n let iteration = 0;\n for (; iteration < maxIterations && !converged; iteration++) {\n let previousError = error;\n let { perturbations, jacobianWeightResidualError } = step(data, parameters, damping, gradientDifference, parameterizedFunction, centralDifference, weightSquare);\n for (let k = 0; k < parameters.length; k++) {\n parameters[k] = Math.min(Math.max(minValues[k], parameters[k] - perturbations.get(k, 0)), maxValues[k]);\n }\n error = errorCalculation(data, parameters, parameterizedFunction, weightSquare);\n if (isNaN(error))\n break;\n if (error < optimalError - errorTolerance) {\n optimalError = error;\n optimalParameters = parameters.slice();\n }\n let improvementMetric = (previousError - error) /\n perturbations\n .transpose()\n .mmul(perturbations.mul(damping).add(jacobianWeightResidualError))\n .get(0, 0);\n if (improvementMetric > improvementThreshold) {\n damping = Math.max(damping / dampingStepDown, 1e-7);\n }\n else {\n damping = Math.min(damping * dampingStepUp, 1e7);\n }\n if (checkTimeout()) {\n throw new Error(`The execution time is over to ${options.timeout} seconds`);\n }\n converged = error <= errorTolerance;\n }\n return {\n parameterValues: optimalParameters,\n parameterError: optimalError,\n iterations: iteration,\n };\n}\n//# sourceMappingURL=index.js.map","import { isAnyArray } from 'is-any-array';\nexport default function checkOptions(data, parameterizedFunction, options) {\n let { timeout, minValues, maxValues, initialValues, weights = 1, damping = 1e-2, dampingStepUp = 11, dampingStepDown = 9, maxIterations = 100, errorTolerance = 1e-7, centralDifference = false, gradientDifference = 10e-2, improvementThreshold = 1e-3, } = options;\n if (damping <= 0) {\n throw new Error('The damping option must be a positive number');\n }\n else if (!data.x || !data.y) {\n throw new Error('The data parameter must have x and y elements');\n }\n else if (!isAnyArray(data.x) ||\n data.x.length < 2 ||\n !isAnyArray(data.y) ||\n data.y.length < 2) {\n throw new Error('The data parameter elements must be an array with more than 2 points');\n }\n else if (data.x.length !== data.y.length) {\n throw new Error('The data parameter elements must have the same size');\n }\n if (!(initialValues && initialValues.length > 0)) {\n throw new Error('The initialValues option is mandatory and must be an array');\n }\n let parameters = initialValues;\n let nbPoints = data.y.length;\n let parLen = parameters.length;\n maxValues = maxValues || new Array(parLen).fill(Number.MAX_SAFE_INTEGER);\n minValues = minValues || new Array(parLen).fill(Number.MIN_SAFE_INTEGER);\n if (maxValues.length !== minValues.length) {\n throw new Error('minValues and maxValues must be the same size');\n }\n if (typeof gradientDifference === 'number') {\n gradientDifference = new Array(parameters.length).fill(gradientDifference);\n }\n else if (isAnyArray(gradientDifference)) {\n if (gradientDifference.length !== parLen) {\n gradientDifference = new Array(parLen).fill(gradientDifference[0]);\n }\n }\n else {\n throw new Error('gradientDifference should be a number or array with length equal to the number of parameters');\n }\n let filler;\n if (typeof weights === 'number') {\n let value = 1 / weights ** 2;\n filler = () => value;\n }\n else if (isAnyArray(weights)) {\n if (weights.length < data.x.length) {\n let value = 1 / weights[0] ** 2;\n filler = () => value;\n }\n else {\n filler = (i) => 1 / weights[i] ** 2;\n }\n }\n else {\n throw new Error('weights should be a number or array with length equal to the number of data points');\n }\n let checkTimeout;\n if (timeout !== undefined) {\n if (typeof timeout !== 'number') {\n throw new Error('timeout should be a number');\n }\n let endTime = Date.now() + timeout * 1000;\n checkTimeout = () => Date.now() > endTime;\n }\n else {\n checkTimeout = () => false;\n }\n let weightSquare = new Array(data.x.length);\n for (let i = 0; i < nbPoints; i++) {\n weightSquare[i] = filler(i);\n }\n return {\n checkTimeout,\n minValues,\n maxValues,\n parameters,\n weightSquare,\n damping,\n dampingStepUp,\n dampingStepDown,\n maxIterations,\n errorTolerance,\n centralDifference,\n gradientDifference,\n improvementThreshold,\n };\n}\n//# sourceMappingURL=checkOptions.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getKnnSparseOpInfo } from './knn-sparse-info';\nimport { pairwiseOpSparse } from './pairwise-sparse-ops';\nimport { multiplyScalar, toOffsetForm, transposeKNN } from './utils';\nexport function performMatrixOps(knnIndexes, knnDistances, setOpMixRatio = 1.0) {\n return __awaiter(this, void 0, void 0, function* () {\n const flatKnnIndexes = new Int32Array(knnIndexes.length * knnIndexes[0].length);\n const flatKnnDistances = new Float32Array(knnDistances.length * knnDistances[0].length);\n for (let i = 0; i < knnIndexes.length; i++) {\n flatKnnIndexes.set(knnIndexes[i], i * knnIndexes[i].length);\n flatKnnDistances.set(knnDistances[i], i * knnDistances[i].length);\n }\n const unionInfo = yield getKnnSparseOpInfo(knnIndexes);\n const numOfEntries = knnIndexes.length;\n const transposed = yield transposeKNN(knnIndexes, knnDistances, unionInfo, knnDistances[0].length);\n const sourceOffsets = toOffsetForm(new Uint32Array(numOfEntries).fill(knnIndexes[0].length));\n const unionMatrixOffsets = toOffsetForm(unionInfo.resultUnionSizesArray);\n const transposeMultRes = yield pairwiseOpSparse(flatKnnIndexes, flatKnnDistances, sourceOffsets, transposed.transposeKNNIndexes, transposed.transposeKNNDistances, transposed.transposeOffsets, numOfEntries, unionMatrixOffsets, '*');\n const addRes = yield pairwiseOpSparse(flatKnnIndexes, flatKnnDistances, sourceOffsets, transposed.transposeKNNIndexes, transposed.transposeKNNDistances, transposed.transposeOffsets, numOfEntries, unionMatrixOffsets, '+');\n // these offsets will be same as union matrix offsets\n const subtRes = yield pairwiseOpSparse(addRes.resultKnnIndexes, addRes.resultKnnDistances, unionMatrixOffsets, transposeMultRes.resultKnnIndexes, transposeMultRes.resultKnnDistances, unionMatrixOffsets, numOfEntries, unionMatrixOffsets, '-');\n if (setOpMixRatio !== 1.0) {\n multiplyScalar(subtRes.resultKnnDistances, setOpMixRatio);\n multiplyScalar(transposeMultRes.resultKnnDistances, 1.0 - setOpMixRatio);\n const res = yield pairwiseOpSparse(subtRes.resultKnnIndexes, subtRes.resultKnnDistances, unionMatrixOffsets, transposeMultRes.resultKnnIndexes, transposeMultRes.resultKnnDistances, unionMatrixOffsets, numOfEntries, unionMatrixOffsets, '+');\n return { res, unionMatrixOffsets };\n }\n return { res: subtRes, unionMatrixOffsets, unionSizes: unionInfo.resultUnionSizesArray };\n });\n}\n//# sourceMappingURL=fuzzy-simplical-set.js.map","/* eslint-disable max-len */\nexport function knnMatrixOpInfoWGSL(threadsPerWorkgroupDim, threadsPerYDimension, entryLen, knnSize = 15) {\n return `\n\n @group(0) @binding(0) var<storage, read_write> knnIndexes: array<array<i32, ${knnSize}>, ${entryLen}>;\n @group(0) @binding(1) var<storage, read_write> resTransposedSizes: array<atomic<u32>, ${entryLen}>;\n // this array will store the union of knn and its transpose sizes per index. should be initialized to knnSize each.\n @group(0) @binding(2) var<storage, read_write> resUnionMatrixSizes: array<atomic<u32>, ${entryLen}>;\n\n @compute @workgroup_size(${threadsPerWorkgroupDim}, ${threadsPerWorkgroupDim}) fn countTransposedCols(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n let col: u32 = id.x;\n let row: u32 = id.y;\n let workingIndex: u32 = row * ${threadsPerYDimension} + col;\n\n if (workingIndex >= ${entryLen}) {\n return;\n }\n \n for (var i = 0u; i < ${knnSize}u; i++) {\n let otherIndex: i32 = knnIndexes[workingIndex][i];\n if (otherIndex != -1 && otherIndex < ${entryLen}) {\n atomicAdd(&resTransposedSizes[otherIndex], 1u);\n atomicAdd(&resUnionMatrixSizes[otherIndex], 1u);\n let otherIndexes = &knnIndexes[otherIndex];\n for(var j = 0u; j < ${knnSize}; j++) {\n if ((*otherIndexes)[j] == i32(workingIndex)) {\n atomicSub(&resUnionMatrixSizes[workingIndex], 1u);\n // if same is found in other array, decrement by one;\n break;\n }\n }\n }\n\n }\n }\n `;\n}\n//# sourceMappingURL=knn-sparse-info.wgsl.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\nimport { smoothKNNDistanceWGSL } from './wgsl/smooth-knn-distance.wgsl';\nexport function smoothKNNDistance(knnDistances, nNeighbors = 15, localConnectivity = 1.0, nIter = 64, bandwidth = 1.0) {\n return __awaiter(this, void 0, void 0, function* () {\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const numOfEntries = knnDistances.length;\n const requiredWorkgroups = Math.ceil(numOfEntries / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const processWgsl = smoothKNNDistanceWGSL(threadsPerWorkgroupDim, threadsPerWorkgroupDim * numOfWorkgroupsPerDim, knnDistances, nNeighbors, localConnectivity, nIter, bandwidth);\n const distanceBuffer32Size = numOfEntries * knnDistances[0].length;\n // const flatDistanceArray = new Float32Array(distanceBuffer32Size);\n // for (let i = 0; i < knnDistances.length; i ++) {\n // flatDistanceArray.set(knnDistances[i], i * knnDistances[i].length);\n // }\n const device = yield getGPUDevice();\n if (device == null)\n return;\n const resultSigmas = new Float32Array(numOfEntries);\n const resultRhos = new Float32Array(numOfEntries);\n const module = device.createShaderModule({\n label: 'sigmaRhoCalulation',\n code: processWgsl\n });\n const pipeline = device.createComputePipeline({\n label: 'sigmaRhoPipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'smoothKNNDistance',\n },\n });\n const distancesBuffer = device.createBuffer({\n label: 'distance buffer',\n size: distanceBuffer32Size * 4,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedDistanceBuffer = distancesBuffer.getMappedRange();\n const mappedDistanceArray = new Float32Array(mappedDistanceBuffer);\n for (let i = 0; i < knnDistances.length; i++)\n mappedDistanceArray.set(knnDistances[i], i * knnDistances[i].length);\n distancesBuffer.unmap();\n const bufferSigmas = device.createBuffer({\n label: 'buffer sigmas',\n size: numOfEntries * 4,\n usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,\n });\n const bufferRhos = device.createBuffer({\n label: 'buffer Rhos',\n size: numOfEntries * 4,\n usage: GPUBufferUsage.STORAGE | GPUBufferUsage.COPY_SRC,\n });\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for sigmarho buffers',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: bufferSigmas } },\n { binding: 1, resource: { buffer: bufferRhos } },\n { binding: 2, resource: { buffer: distancesBuffer } },\n // { binding: 4, resource: { buffer: arraySizesBuffer } },\n ],\n });\n const encoder = device.createCommandEncoder({\n label: 'sigmarho encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'sigmarho compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n const resultBufferRhos = device.createBuffer({\n label: 'result buffer rhos',\n size: bufferRhos.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n const resultBufferSigmas = device.createBuffer({\n label: 'result buffer sigmas',\n size: bufferSigmas.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n encoder.copyBufferToBuffer(bufferRhos, 0, resultBufferRhos, 0, resultBufferRhos.size);\n encoder.copyBufferToBuffer(bufferSigmas, 0, resultBufferSigmas, 0, resultBufferSigmas.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n yield resultBufferRhos.mapAsync(GPUMapMode.READ);\n yield resultBufferSigmas.mapAsync(GPUMapMode.READ);\n resultRhos.set(new Float32Array(resultBufferRhos.getMappedRange()));\n resultSigmas.set(new Float32Array(resultBufferSigmas.getMappedRange()));\n resultBufferRhos.unmap();\n resultBufferSigmas.unmap();\n distancesBuffer.destroy();\n bufferSigmas.destroy();\n bufferRhos.destroy();\n resultBufferRhos.destroy();\n resultBufferSigmas.destroy();\n return { resultRhos, resultSigmas };\n });\n}\n//# sourceMappingURL=smooth-knn-distance.js.map","export function smoothKNNDistanceWGSL(threadsPerWorkgroupDim = 10, threadsPerYDimension, knnDistances, nNeighbors = 15, localConnectivity = 1.0, nIter = 64, bandwidth = 1.0) {\n const numOfEntries = knnDistances.length;\n let meanDistancesSum = 0.0;\n for (let i = 0; i < numOfEntries; i++) {\n let currentMean = 0.0;\n for (let j = 0; j < nNeighbors; j++)\n currentMean += knnDistances[i][j];\n meanDistancesSum += currentMean / nNeighbors;\n }\n const meanDistances = meanDistancesSum / numOfEntries;\n const target = Math.log(nNeighbors) / Math.log(2) * bandwidth;\n return ` \n var<private> SMOOTH_K_TOLERANCE: f32 = 1e-5;\n var<private> MIN_K_DIST_SCALE: f32 = 1e-3;\n var<private> nNeighbors: u32 = ${nNeighbors};\n var<private> localConnectivity: f32 = ${localConnectivity}; \n var<private> nIter: u32 = ${nIter};\n var<private> bandwidth: u32 = ${bandwidth};\n var<private> meanDistances: f32 = ${meanDistances};\n var<private> targetValue: f32 = ${target};\n @group(0) @binding(0) var<storage, read_write> sigmas: array<f32, ${numOfEntries}>;\n @group(0) @binding(1) var<storage, read_write> rhos: array<f32, ${numOfEntries}>;\n @group(0) @binding(2) var<storage, read> distances: array<array<f32, ${nNeighbors}>, ${numOfEntries}>;\n @compute @workgroup_size(${threadsPerWorkgroupDim}, ${threadsPerWorkgroupDim}) fn smoothKNNDistance(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n let col: u32 = id.x;\n let row: u32 = id.y;\n let workingIndex: u32 = row * ${threadsPerYDimension} + col;\n\n if (workingIndex >= ${numOfEntries}) {\n return;\n }\n\n var lo: f32 = 0.0;\n var hi: f32 = 1.0e+30; // treated as Infinity\n var mid: f32 = 1.0;\n\n var nonZeroDists: array<f32, ${nNeighbors}>;\n var nonZeroDistsSize: u32 = 0;\n for (var j = 0u; j < nNeighbors; j = j + 1u) {\n if (distances[workingIndex][j] > 0.0) {\n nonZeroDists[nonZeroDistsSize] = distances[workingIndex][j];\n nonZeroDistsSize = nonZeroDistsSize + 1u;\n }\n }\n\n if (f32(nonZeroDistsSize) >= localConnectivity) {\n let index: u32 = u32(floor(localConnectivity));\n let interpolation: f32 = localConnectivity - f32(index);\n if (index > 0) {\n rhos[workingIndex] = nonZeroDists[index - 1];\n if (interpolation > SMOOTH_K_TOLERANCE) {\n rhos[workingIndex] += interpolation * (nonZeroDists[index] - nonZeroDists[index - 1]);\n }\n }\n else {\n rhos[workingIndex] = interpolation * nonZeroDists[0];\n }\n }\n else if (nonZeroDistsSize > 0u) {\n var maxDist: f32 = 0.0;\n for (var j = 0u; j < nonZeroDistsSize; j = j + 1u) {\n maxDist = max(nonZeroDists[j], maxDist);\n }\n rhos[workingIndex] = maxDist;\n }\n\n for (var n = 0u; n < nIter; n = n + 1u) {\n var psum: f32 = 0.0;\n for (var j = 1u; j < ${nNeighbors}; j = j + 1u) {\n let d: f32 = distances[workingIndex][j] - rhos[workingIndex];\n if (d > 0.0) {\n psum += exp(0.0 - (d / mid));\n }\n else {\n psum += 1.0;\n }\n }\n\n if (abs(psum - targetValue) < SMOOTH_K_TOLERANCE) {\n break;\n }\n\n if (psum > targetValue) {\n hi = mid;\n mid = (lo + hi) / 2.0;\n }\n else {\n lo = mid;\n if (hi == 1.0e+30) {\n mid *= 2.0;\n }\n else {\n mid = (lo + hi) / 2.0;\n }\n }\n }\n\n sigmas[workingIndex] = mid;\n\n if (rhos[workingIndex] > 0.0) {\n var sum: f32 = 0.0;\n for (var j = 0u; j < ${nNeighbors}; j = j + 1u) {\n sum += distances[workingIndex][j];\n }\n let meanIthDistances: f32 = sum / ${nNeighbors}.0;\n if (sigmas[workingIndex] < MIN_K_DIST_SCALE * meanIthDistances) {\n sigmas[workingIndex] = MIN_K_DIST_SCALE * meanIthDistances;\n }\n }\n else {\n if (sigmas[workingIndex] < MIN_K_DIST_SCALE * meanDistances) {\n sigmas[workingIndex] = MIN_K_DIST_SCALE * meanDistances;\n }\n }\n }\n `;\n}\n//# sourceMappingURL=smooth-knn-distance.wgsl.js.map","/* eslint-disable max-len */\nvar __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { performMatrixOps } from './fuzzy-simplical-set';\nimport { computeMembershipStrengths } from './membership-strengths';\nimport { optimizationLoop } from './optimization-loop';\nimport { initializeSimplicialSetEmbedding } from './simplical-set-embedding';\nimport { smoothKNNDistance } from './smooth-knn-distance';\n// TODO: FIT ASYNC METHOD WITH CALLBACKS on each step\n// TODO: random function passing in params\nexport class UmapParams {\n constructor() {\n this.nComponents = 2;\n this.gamma = 1;\n this.alpha = 1;\n this.entryLen = 0;\n this.nNeighbours = 15;\n this.spread = 1;\n this.minDist = 0.1;\n this.negativeSampleRate = 5;\n this.localConnectivity = 1.0;\n this.setOpMixRatio = 1.0;\n }\n}\nexport class WebGPUUMAP {\n constructor(entryLen, params) {\n this.params = new UmapParams();\n this.knnIndexes = null;\n this.knnDistances = null;\n this.rhos = null;\n this.sigmas = null;\n this.membershipStrengths = null;\n this.params.entryLen = entryLen;\n Object.assign(this.params, params);\n }\n setPrecomputedKNN(knnIndexes, knnDistances) {\n this.knnIndexes = knnIndexes;\n this.knnDistances = knnDistances;\n }\n // for now, not sure if we should include this, maybe webGPU UMAP should be stand alone.\n // eslint-disable-next-line max-len\n // async calcKNN(entryList: SupportedEntryTypes[][], distanceMetrics: WEBGPUDISTANCE[], aggregationFunction: WEBGSLAGGREGATION, weights: number[], options: {\n // [key: string]: any;\n // }[]) {\n // try {\n // const knnRes = await multiColWebGPUKNN(entryList, this.params.nNeighbours, distanceMetrics, aggregationFunction, weights, options);\n // if (knnRes) {\n // this.knnIndexes = knnRes.knnIndexes;\n // this.knnDistances = knnRes.knnDistances;\n // }\n // } catch (e) {\n // console.error(e);\n // }\n // if (!this.knnIndexes || !this.knnDistances)\n // throw new Error('failed to compute knn indexes and distances');\n // }\n // async calcKNNSingle(entryList: SupportedEntryTypes[], distanceMetrics: WEBGPUDISTANCE, options?: {\n // [key: string]: any;\n // }) {\n // if (!options)\n // options = {};\n // await this.calcKNN([entryList], [distanceMetrics], WEBGSLAGGREGATION.MANHATTAN, [1], [options]);\n // }\n initializeFit() {\n return __awaiter(this, void 0, void 0, function* () {\n yield this.calcSmoothKNNDistances();\n yield this.calcMembershipStrengths();\n });\n }\n fit() {\n return __awaiter(this, void 0, void 0, function* () {\n yield this.initializeFit();\n const umapParams = yield this.initializeSimplicialSetEmbedding();\n if (!umapParams)\n throw new Error('failed to compute umap simplistical set embeddings');\n const { head, tail, epochsPerSample, epochsPerNegativeSample, a, b, gamma, initialAlpha, nComponents, nEpochs, entryLen } = umapParams;\n const resEmbeddings = yield optimizationLoop(head, tail, entryLen, epochsPerSample, epochsPerNegativeSample, initialAlpha, gamma, a, b, nComponents, nEpochs, entryLen);\n return resEmbeddings;\n });\n }\n calcSmoothKNNDistances() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!this.knnIndexes || !this.knnDistances)\n throw new Error('knn indexes and distances must be set before calling fit');\n const res = yield smoothKNNDistance(this.knnDistances, this.params.nNeighbours, this.params.localConnectivity, 64);\n if (!res)\n throw new Error('failed to compute smooth knn distances');\n this.rhos = res.resultRhos;\n this.sigmas = res.resultSigmas;\n });\n }\n calcMembershipStrengths() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!this.knnIndexes || !this.knnDistances || !this.rhos || !this.sigmas)\n throw new Error('knn indexes, distances, rhos, and sigmas must be set before calling fit');\n const res = yield computeMembershipStrengths(this.knnDistances, this.sigmas, this.rhos);\n if (!res)\n throw new Error('failed to compute membership strengths');\n this.membershipStrengths = res;\n });\n }\n fuzzySimplicialSet() {\n return __awaiter(this, void 0, void 0, function* () {\n if (!this.knnIndexes || !this.knnDistances || !this.rhos || !this.sigmas || !this.membershipStrengths)\n throw new Error('knn indexes, distances, rhos, sigmas, and membership strengths must be set before calling fit');\n const res = yield performMatrixOps(this.knnIndexes, this.membershipStrengths, this.params.setOpMixRatio);\n if (!res)\n throw new Error('failed to compute pairwise multiply with transpose');\n return res;\n });\n }\n initializeSimplicialSetEmbedding() {\n return __awaiter(this, void 0, void 0, function* () {\n const fuzzySimplicialSetRes = yield this.fuzzySimplicialSet();\n if (!fuzzySimplicialSetRes || !fuzzySimplicialSetRes.res || !fuzzySimplicialSetRes.unionMatrixOffsets || !fuzzySimplicialSetRes.unionSizes)\n throw new Error('failed to compute fuzzy simplicial set');\n const eRes = yield initializeSimplicialSetEmbedding(fuzzySimplicialSetRes, this.params.entryLen, this.params.spread, this.params.minDist, this.params.negativeSampleRate);\n if (!eRes)\n throw new Error('failed to compute umap simplistical set embeddings');\n return eRes;\n });\n }\n}\n//# sourceMappingURL=WEBGPU-UMAP.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\nimport { optimizeLayoutWGSL } from './wgsl/optimization-loop.wgsl';\nexport function optimizationLoop(head, tail, embeddingSize, epochsPerSample, epochsPerNegativeSample, initialAlpha, gamma, a, b, dim, nEpochs, nVertices) {\n return __awaiter(this, void 0, void 0, function* () {\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const requiredWorkgroups = Math.ceil(head.length / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const threadsPerYDimension = threadsPerWorkgroupDim * numOfWorkgroupsPerDim;\n const device = yield getGPUDevice();\n if (!device)\n return;\n const divisionFactor = 10000000;\n const headSize = head.length;\n const processWGSL = optimizeLayoutWGSL(headSize, embeddingSize, true, initialAlpha, gamma, a, b, dim, nEpochs, nVertices, threadsPerWorkgroupDim, threadsPerYDimension, divisionFactor);\n // head/tail\n const matrixStorage32Size = headSize * 2;\n let paddedMatrixStorageSize = matrixStorage32Size * 4;\n const remainder1 = paddedMatrixStorageSize & 15;\n if (remainder1 !== 0)\n paddedMatrixStorageSize += 16 - remainder1;\n const epochStorage32Size = headSize * 4;\n let paddedepochStorageSize = epochStorage32Size * 4;\n const remainder2 = paddedepochStorageSize & 15;\n if (remainder2 !== 0)\n paddedepochStorageSize += 16 - remainder2;\n const embedStorage32Size = embeddingSize * 2 * 2;\n let paddedembedStorageSize = embedStorage32Size * 4;\n const remainder3 = paddedembedStorageSize & 15;\n if (remainder3 !== 0)\n paddedembedStorageSize += 16 - remainder3;\n const comuteInfo32Size = 2 + headSize;\n let paddedComputeInfoSize = comuteInfo32Size * 4;\n const remainder4 = paddedComputeInfoSize & 15;\n if (remainder4 !== 0)\n paddedComputeInfoSize += 16 - remainder4;\n const module = device.createShaderModule({\n label: 'optimizeShader',\n code: processWGSL\n });\n const pipeline = device.createComputePipeline({\n label: 'optimizePipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'optimizeStep',\n },\n });\n const matrixStorageBuffer = device.createBuffer({\n label: 'matrix storage buffer',\n size: paddedMatrixStorageSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const matrixStorageArrayBuffer = matrixStorageBuffer.getMappedRange();\n const headView = new Uint32Array(matrixStorageArrayBuffer, 0, headSize);\n headView.set(head);\n const tailView = new Uint32Array(matrixStorageArrayBuffer, headSize * 4, headSize);\n tailView.set(tail);\n matrixStorageBuffer.unmap();\n const epochStorageBuffer = device.createBuffer({\n label: 'epoch storage buffer',\n size: paddedepochStorageSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const epochStorageArrayBuffer = epochStorageBuffer.getMappedRange();\n // all are float32 so we get the whole view\n const epochStorageArrayView = new Float32Array(epochStorageArrayBuffer);\n // first epochsPerSample\n epochStorageArrayView.set(epochsPerSample, 0);\n //epochOfNextSample, set to same\n epochStorageArrayView.set(epochsPerSample, headSize);\n //epochsPerNegativeSample\n epochStorageArrayView.set(epochsPerNegativeSample, headSize * 2);\n //epochOfNextNegativeSample\n epochStorageArrayView.set(epochsPerNegativeSample, headSize * 3);\n epochStorageBuffer.unmap();\n const headEmbeddings = new Int32Array(embeddingSize * dim).map(() => Math.floor((Math.random() * 2 - 1) * divisionFactor));\n const tailEmbeddings = new Int32Array(embeddingSize * dim);\n tailEmbeddings.set(headEmbeddings);\n const embeddingStorageBuffer = device.createBuffer({\n label: 'embedding storage buffer',\n size: paddedembedStorageSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedEmbeddingStorageBuffer = embeddingStorageBuffer.getMappedRange();\n const mappedEmbeddingStorageArray = new Int32Array(mappedEmbeddingStorageBuffer);\n mappedEmbeddingStorageArray.set(headEmbeddings, 0);\n mappedEmbeddingStorageArray.set(headEmbeddings, headEmbeddings.length);\n embeddingStorageBuffer.unmap();\n const computeInfoBuffer = device.createBuffer({\n label: 'compute info buffer',\n size: paddedComputeInfoSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const randomNumbers = new Uint32Array(headSize).map(() => Math.floor(Math.random() * divisionFactor));\n const computeInfoArrayBuffer = computeInfoBuffer.getMappedRange();\n const computeInfoMappedArray = new Float32Array(computeInfoArrayBuffer, 0, 2);\n computeInfoMappedArray.set([0.0, initialAlpha]);\n const randomNumbersView = new Uint32Array(computeInfoArrayBuffer, 8, headSize);\n randomNumbersView.set(randomNumbers);\n computeInfoBuffer.unmap();\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for optimize',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: matrixStorageBuffer } },\n { binding: 1, resource: { buffer: epochStorageBuffer } },\n { binding: 2, resource: { buffer: embeddingStorageBuffer } },\n { binding: 3, resource: { buffer: computeInfoBuffer } }\n ],\n });\n let alpha = initialAlpha;\n const outEmbedViewBuffer = device.createBuffer({\n label: 'result buffer',\n size: embeddingStorageBuffer.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n for (let iter = 0; iter < nEpochs; iter++) {\n // write n and alpha\n device.queue.writeBuffer(computeInfoBuffer, 0, new Float32Array([iter, alpha]), 0);\n const encoder = device.createCommandEncoder({\n label: 'matrix ops encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'matrix ops compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n // here, we copy the head/tail views to their correct places in embeddings.\n if (iter === nEpochs - 1)\n encoder.copyBufferToBuffer(embeddingStorageBuffer, 0, outEmbedViewBuffer, 0, outEmbedViewBuffer.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n alpha = initialAlpha * (1.0 - iter / nEpochs);\n }\n yield outEmbedViewBuffer.mapAsync(GPUMapMode.READ);\n const resArrayBuffer = outEmbedViewBuffer.getMappedRange();\n const headEmbeddingsView = new Int32Array(resArrayBuffer, 0, headEmbeddings.length);\n headEmbeddings.set(headEmbeddingsView);\n outEmbedViewBuffer.unmap();\n const result = new Array(dim).fill(null).map((_) => new Float32Array(embeddingSize));\n for (let i = 0; i < embeddingSize; i++) {\n for (let j = 0; j < dim; j++)\n result[j][i] = headEmbeddings[i * dim + j] / divisionFactor;\n }\n matrixStorageBuffer.destroy();\n epochStorageBuffer.destroy();\n embeddingStorageBuffer.destroy();\n computeInfoBuffer.destroy();\n outEmbedViewBuffer.destroy();\n return result;\n });\n}\n//# sourceMappingURL=optimization-loop.js.map","/* eslint-disable max-len */\nexport function optimizeLayoutWGSL(headSize, embedSize, moveOther, initialAlpha, gamma, a, b, dim, nEpochs, nVertices, workgroupDim, threadsPerRow, divisionFactor = 100000) {\n return `\n// first define some functions\n\nfn rDist(ar1: array<f32, ${dim}>, ar2: array<f32, ${dim}>) -> f32 {\n var res = 0.0;\n for (var i1 = 0u; i1 < ${dim}; i1++) {\n let diff = ar1[i1] - ar2[i1];\n res += pow(diff, 2);\n }\n return res;\n}\n\nfn clip(x: f32, clipValue: f32) -> f32 {\n if (x > clipValue) {\n return clipValue;\n }\n else if (x < 0.0 - clipValue) {\n return 0.0 - clipValue;\n }\n return x;\n}\n\nvar<private> randomSeedInt: u32 = 0;\nvar<private> nVertices: u32 = ${nVertices};\nvar<private> initialAlpha: f32 = ${initialAlpha};\nvar<private> gamma: f32 = ${gamma};\nvar<private> a: f32 = ${a};\nvar<private> b: f32 = ${b};\nvar<private> dim: u32 = ${dim};\nvar<private> nEpochs: f32 = ${nEpochs};\nvar<private> moveOther: u32 = ${moveOther === true ? 1 : 0};\n\nfn random() -> u32 {\n randomSeedInt = (randomSeedInt ^ 61) ^ (randomSeedInt >> 16);\n randomSeedInt *= 9;\n randomSeedInt = randomSeedInt ^ (randomSeedInt >> 4);\n randomSeedInt *= 0x27d4eb2d;\n randomSeedInt = randomSeedInt ^ (randomSeedInt >> 15);\n return randomSeedInt;\n}\n\nfn randInt(maxVal: u32) -> u32 {\n let nextRandomNum = random();\n return u32(floor((f32(nextRandomNum) * (f32(maxVal) / 4294967296.0))));\n}\n\nstruct MatrixStorage {\n head: array<u32, ${headSize}>,\n tail: array<u32, ${headSize}>,\n}\n\nstruct EpochStorage {\n epochsPerSample: array<f32, ${headSize}>,\n epochOfNextSample: array<f32, ${headSize}>,\n epochsPerNegativeSample: array<f32, ${headSize}>,\n epochOfNextNegativeSample: array<f32, ${headSize}>\n}\n\nstruct EmbeddingStorage {\n // embeddings will be in range of -10 to 10, as atomics only can store i32 or u32, we will store them as floor(f32 * 100_000)\n headEmbeddings: array<array<atomic<i32>, ${dim}>, ${embedSize}>,\n tailEmbeddings: array<array<atomic<i32>, ${dim}>, ${embedSize}>\n}\n\nstruct ComputeInfo {\n n: f32,\n alpha: f32,\n randomNumbers: array<u32, ${headSize}>,\n //tailOffsets: array<u32, ${embedSize + 1}>\n}\n @group(0) @binding(0) var<storage, read_write> matrixStorage: MatrixStorage;\n @group(0) @binding(1) var<storage, read_write> epochStorage: EpochStorage;\n @group(0) @binding(2) var<storage, read_write> embedStorage: EmbeddingStorage;\n @group(0) @binding(3) var<storage, read_write> computeInfo: ComputeInfo;\n @compute @workgroup_size(${workgroupDim}, ${workgroupDim}) fn optimizeStep(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n let divisionFactor: f32 = ${divisionFactor};\n let col: u32 = id.x;\n let row: u32 = id.y;\n let threadIndex: u32 = row * ${threadsPerRow} + col;\n let clipValue: f32 = 4.0;\n\n if (threadIndex >= ${headSize}) {\n return;\n }\n\n let workingIndex = threadIndex;\n //let startAtOffset = computeInfo.tailOffsets[threadIndex];\n //let endAtOffset = computeInfo.tailOffsets[threadIndex + 1];\n //for (var workingIndex = startAtOffset; workingIndex < endAtOffset; workingIndex++) {\n randomSeedInt = computeInfo.randomNumbers[workingIndex] * u32(computeInfo.n);\n\n let epochOfNextSample = epochStorage.epochOfNextSample[workingIndex];\n if (epochOfNextSample > computeInfo.n) {\n return;\n }\n\n let j = matrixStorage.head[workingIndex];\n let k = matrixStorage.tail[workingIndex];\n\n // as said before, we will store embeddings as floor(f32 * 100_000)\n var current: array<f32, ${dim}>;\n var other: array<f32, ${dim}>;\n for (var i = 0u; i < ${dim}u; i++) {\n current[i] = f32(atomicLoad(&embedStorage.headEmbeddings[j][i])) / divisionFactor;\n other[i] = f32(atomicLoad(&embedStorage.tailEmbeddings[k][i])) / divisionFactor;\n }\n\n let distSquared = rDist(current, other);\n \n var gradCoeff: f32 = 0.0;\n if (distSquared > 0.0) {\n gradCoeff = (0.0 - 2.0) * ${a} * ${b} * pow(distSquared, b - 1.0);\n gradCoeff /= (a * pow(distSquared, b) + 1.0);\n }\n\n var gradBuff: array<i32, ${dim}>;\n for (var d = 0u; d < ${dim}u; d++) {\n let gradD = clip((gradCoeff * (current[d] - other[d])), clipValue);\n let toAdd = gradD * computeInfo.alpha;\n gradBuff[d] = i32(floor(toAdd * divisionFactor));\n current[d] += toAdd;\n other[d] -= toAdd;\n }\n\n for (var d = 0u; d < ${dim}u; d++) {\n atomicAdd(&embedStorage.headEmbeddings[j][d], gradBuff[d]);\n atomicSub(&embedStorage.tailEmbeddings[k][d], gradBuff[d]);\n }\n\n epochStorage.epochOfNextSample[workingIndex] += epochStorage.epochsPerSample[workingIndex];\n var nNegSamples: i32 = i32(floor((computeInfo.n - epochStorage.epochOfNextNegativeSample[workingIndex]) / epochStorage.epochsPerNegativeSample[workingIndex]));\n\n for (var p = 0i; p < nNegSamples; p++) {\n let k1 = randInt(nVertices);\n var other1: array<f32, ${dim}>;\n for (var i = 0u; i < ${dim}u; i++) {\n other1[i] = f32(atomicLoad(&embedStorage.tailEmbeddings[k1][i])) / divisionFactor;\n }\n\n let distSquared1 = rDist(current, other1);\n\n var gradCoeff1: f32 = 0.0;\n if (distSquared1 > 0.0) {\n gradCoeff1 = 2.0 * gamma * b;\n gradCoeff1 /= (0.001 + distSquared1) * (a * pow(distSquared1, b) + 1);\n }\n else if (j == k1) {\n continue;\n }\n\n var gradDBuff: array<i32, ${dim}>;\n for (var d = 0u; d < ${dim}u; d++) {\n var gradD: f32 = 4.0;\n if (gradCoeff1 > 0.0) {\n gradD = clip(gradCoeff1 * (current[d] - other1[d]), clipValue);\n }\n\n gradDBuff[d] = i32(floor(gradD * computeInfo.alpha * divisionFactor));\n \n }\n for (var d = 0u; d < ${dim}u; d++) {\n atomicAdd(&embedStorage.headEmbeddings[j][d], gradDBuff[d]);\n }\n }\n epochStorage.epochOfNextNegativeSample[workingIndex] += f32(nNegSamples) * epochStorage.epochsPerNegativeSample[workingIndex];\n //}\n }\n`;\n}\n//# sourceMappingURL=optimization-loop.wgsl.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { getGPUDevice } from '../getGPUDevice';\nimport { computeMembershipStrengthsWGSL } from './wgsl/membership-strengths.wgsl';\nexport function computeMembershipStrengths(knnDistances, sigmas, rhos) {\n return __awaiter(this, void 0, void 0, function* () {\n const threadsPerWorkgroupDim = 10;\n const threadsPerWorkgroup = threadsPerWorkgroupDim * threadsPerWorkgroupDim;\n const numOfEntries = knnDistances.length;\n const requiredWorkgroups = Math.ceil(numOfEntries / threadsPerWorkgroup);\n const numOfWorkgroupsPerDim = Math.ceil(Math.sqrt(requiredWorkgroups));\n const processWgsl = computeMembershipStrengthsWGSL(threadsPerWorkgroupDim, threadsPerWorkgroupDim * numOfWorkgroupsPerDim, knnDistances, sigmas, rhos);\n const distanceBuffer32Size = numOfEntries * knnDistances[0].length;\n const device = yield getGPUDevice();\n if (device == null)\n return;\n const module = device.createShaderModule({\n label: 'rowsColsValsCalulation',\n code: processWgsl\n });\n const pipeline = device.createComputePipeline({\n label: 'rowsColsValsPipeline',\n layout: 'auto',\n compute: {\n module,\n entryPoint: 'computeMembershipStrengths',\n },\n });\n const rhos32Size = rhos.length;\n const sigmas32Size = sigmas.length;\n const combinedMembershipStrengthsInfo32Size = rhos32Size + sigmas32Size + distanceBuffer32Size;\n let paddedCombinedMembershipStructByteSize = combinedMembershipStrengthsInfo32Size * 4;\n const remainder = paddedCombinedMembershipStructByteSize & 15;\n if (remainder != 0)\n paddedCombinedMembershipStructByteSize += 16 - remainder;\n // input params\n const membershipStrengthsInfoBuffer = device.createBuffer({\n label: 'info buffer',\n size: paddedCombinedMembershipStructByteSize,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n mappedAtCreation: true,\n });\n const mappedInfoBuffer = membershipStrengthsInfoBuffer.getMappedRange();\n const mappedInfoArray = new Float32Array(mappedInfoBuffer);\n // first set knn distances\n for (let i = 0; i < knnDistances.length; i++)\n mappedInfoArray.set(knnDistances[i], i * knnDistances[i].length);\n let offset = knnDistances[0].length * knnDistances.length;\n // now set sigmas\n mappedInfoArray.set(sigmas, offset);\n offset += sigmas.length;\n // now set rhos\n mappedInfoArray.set(rhos, offset);\n membershipStrengthsInfoBuffer.unmap();\n const knnDistancesBuffer = device.createBuffer({\n label: 'knn distance buffer',\n size: knnDistances[0].length * knnDistances.length * Float32Array.BYTES_PER_ELEMENT,\n usage: GPUBufferUsage.STORAGE |\n GPUBufferUsage.COPY_SRC |\n GPUBufferUsage.COPY_DST,\n });\n const bindGroup = device.createBindGroup({\n label: 'bindGroup for membership strhegths buffers',\n layout: pipeline.getBindGroupLayout(0),\n entries: [\n { binding: 0, resource: { buffer: membershipStrengthsInfoBuffer } },\n { binding: 1, resource: { buffer: knnDistancesBuffer } },\n // { binding: 4, resource: { buffer: arraySizesBuffer } },\n ],\n });\n const encoder = device.createCommandEncoder({\n label: 'membership strengths encoder',\n });\n const pass = encoder.beginComputePass({\n label: 'membership strengths compute pass',\n });\n pass.setPipeline(pipeline);\n pass.setBindGroup(0, bindGroup);\n pass.dispatchWorkgroups(numOfWorkgroupsPerDim, numOfWorkgroupsPerDim);\n pass.end();\n const resultBufferDistances = device.createBuffer({\n label: 'result buffer distances',\n size: knnDistancesBuffer.size,\n usage: GPUBufferUsage.MAP_READ | GPUBufferUsage.COPY_DST,\n });\n encoder.copyBufferToBuffer(knnDistancesBuffer, 0, resultBufferDistances, 0, resultBufferDistances.size);\n const commandBuffer = encoder.finish();\n device.queue.submit([commandBuffer]);\n yield device.queue.onSubmittedWorkDone();\n yield resultBufferDistances.mapAsync(GPUMapMode.READ);\n const resultKnnDistancesArrayBuffer = resultBufferDistances.getMappedRange();\n const bytesPerKnnRow = knnDistances[0].length * Float32Array.BYTES_PER_ELEMENT;\n const resKnnDistances = new Array(knnDistances.length).fill(null).map((_, i) => {\n const dataView = new Float32Array(resultKnnDistancesArrayBuffer, bytesPerKnnRow * i, knnDistances[0].length);\n const out = new Float32Array(knnDistances[0].length);\n out.set(dataView);\n return out;\n });\n resultBufferDistances.unmap();\n resultBufferDistances.destroy();\n knnDistancesBuffer.destroy();\n membershipStrengthsInfoBuffer.destroy();\n return resKnnDistances;\n });\n}\n//# sourceMappingURL=membership-strengths.js.map","/* eslint-disable max-len */\nexport function computeMembershipStrengthsWGSL(threadsPerWorkgroupDim = 10, threadsPerYDimension, knnDistances, sigmas, rhos) {\n const numOfEntries = knnDistances.length;\n const sigmasLength = sigmas.length;\n const rhosLength = rhos.length;\n // TODO: do it with structs\n return `\n struct MembershipStrengthsInfo {\n knnDistances: array<array<f32, ${knnDistances[0].length}>, ${numOfEntries}>,\n sigmas: array<f32, ${sigmasLength}>,\n rhos: array<f32, ${rhosLength}>\n };\n var<private> nNeighbors: u32 = ${knnDistances[0].length};\n @group(0) @binding(0) var<storage, read> membershipStrengthsInfo: MembershipStrengthsInfo;\n @group(0) @binding(1) var<storage, read_write> resultKnnDistances: array<array<f32, ${knnDistances[0].length}>, ${numOfEntries}>;\n @compute @workgroup_size(${threadsPerWorkgroupDim}, ${threadsPerWorkgroupDim}) fn computeMembershipStrengths(\n @builtin(global_invocation_id) id: vec3<u32>,\n ) {\n let col: u32 = id.x;\n let row: u32 = id.y;\n let workingIndex: u32 = row * ${threadsPerYDimension} + col;\n\n if (workingIndex >= ${numOfEntries}) {\n return;\n }\n\n let workingResKnnDistances = &resultKnnDistances[workingIndex];\n let knnDistances = &membershipStrengthsInfo.knnDistances[workingIndex];\n for (var j = 0u; j < nNeighbors; j = j + 1u) {\n var val: f32 = 0.0;\n\n if ((*knnDistances)[j] - membershipStrengthsInfo.rhos[workingIndex] <= 0.0) {\n val = 1.0;\n } else {\n val = exp(0.0 - ((knnDistances[j] - membershipStrengthsInfo.rhos[workingIndex]) / membershipStrengthsInfo.sigmas[workingIndex])); \n }\n\n (*workingResKnnDistances)[j] = val;\n }\n }\n `;\n}\n//# sourceMappingURL=membership-strengths.wgsl.js.map","var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\n return new (P || (P = Promise))(function (resolve, reject) {\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\n step((generator = generator.apply(thisArg, _arguments || [])).next());\n });\n};\nimport { findABParams, getNEpochs, toOffsetForm } from './utils';\nexport function initializeSimplicialSetEmbedding(graph, entryLen, spread, minDist, negativeSampleRate = 5) {\n return __awaiter(this, void 0, void 0, function* () {\n if (!graph.unionSizes)\n return;\n const nEpochs = getNEpochs(entryLen);\n const nComponents = 2; // todo: support mult dims\n // get max value:\n const maxVal = graph.res.resultKnnDistances.reduce((prev, cur) => Math.max(prev, cur));\n //let offsetAccum = 0;\n // for (let i = 0; i < graph.unionSizes.length; i++) {\n // for (let j = 0; j < graph.unionSizes)\n // }\n const minGraphVal = maxVal / nEpochs;\n // this will hold the sizes of arrays with all zeros removed.\n const unionSizesCopy = new Uint32Array(graph.unionSizes.length);\n unionSizesCopy.set(graph.unionSizes);\n let offsetAccum = 0;\n for (let i = 0; i < graph.unionSizes.length; i++) {\n for (let j = 0; j < graph.unionSizes[i]; j++) {\n const index = offsetAccum + j;\n if (graph.res.resultKnnDistances[index] < minGraphVal) {\n graph.res.resultKnnDistances[index] = 0;\n unionSizesCopy[i]--;\n }\n }\n offsetAccum += graph.unionSizes[i];\n }\n const nonZeroGraphOffsets = toOffsetForm(unionSizesCopy);\n const nonZeroGraphSize = nonZeroGraphOffsets[nonZeroGraphOffsets.length - 1];\n const weights = new Float32Array(nonZeroGraphSize);\n const head = new Uint32Array(nonZeroGraphSize);\n const tail = new Uint32Array(nonZeroGraphSize);\n offsetAccum = 0;\n for (let i = 0; i < graph.unionSizes.length; i++) {\n for (let j = 0; j < graph.unionSizes[i]; j++) {\n const index = graph.unionMatrixOffsets[i] + j;\n if (graph.res.resultKnnDistances[index] != 0) {\n weights[offsetAccum] = graph.res.resultKnnDistances[index];\n head[offsetAccum] = graph.res.resultKnnIndexes[index];\n tail[offsetAccum] = i;\n offsetAccum += 1;\n }\n }\n }\n const epochsPerSample = new Float32Array(weights.length).fill(-1);\n const nSamples = weights.map((w) => (w / maxVal) * nEpochs);\n nSamples.forEach((n, i) => {\n if (n > 0)\n epochsPerSample[i] = nEpochs / nSamples[i];\n });\n const { a, b } = findABParams(spread, minDist);\n const epochsPerNegativeSample = epochsPerSample.map((e) => e / negativeSampleRate);\n const gamma = 1.0;\n const initialAlpha = 1.0;\n return { epochsPerSample, epochsPerNegativeSample, a, b,\n head, tail, entryLen, nEpochs, nComponents, initialAlpha, gamma };\n });\n}\n//# sourceMappingURL=simplical-set-embedding.js.map","import { Vector } from '@datagrok-libraries/utils/src/type-declarations';\nimport { AvailableMetrics, Measure, isBitArrayMetric } from '../typed-metrics';\nimport { DistanceMatrixService } from '../distance-matrix';\nimport { UMAP } from '../umap';\nimport { assert, transposeMatrix } from '@datagrok-libraries/utils/src/vector-operations';\nimport { SparseMatrixService } from '../distance-matrix/sparse-matrix-service';\nimport BitArray from '@datagrok-libraries/utils/src/bit-array';\nimport seedRandom from 'seedrandom';\n//import {TSNE} from '@keckelt/tsne';\nimport { TSNE } from '../t-sne/t-sne';\nimport { multiColWebGPUKNN } from '@datagrok-libraries/math';\nimport { WebGPUUMAP } from '@datagrok-libraries/math/src/webGPU/umap';\nclass MultiColumnReducer {\n constructor(options) {\n this.data = options.data;\n this.weights = options.weights;\n this.aggregationMethod = options.aggregationMethod;\n }\n}\nclass TSNEReducer extends MultiColumnReducer {\n /**\n * Creates an instance of TSNEReducer.\n * @param {Options} options Options to pass to the constructor.\n * @memberof TSNEReducer\n */\n constructor(options) {\n super(options);\n const randomSeed = options.randomSeed ?? Date();\n const randomFn = seedRandom(randomSeed);\n options.dim = 2; // TODO: make it configurable\n options.random = randomFn;\n this.reducer = new TSNE(options);\n this.iterations = options?.iterations ?? this.reducer.getIterSize(this.data[0].length);\n this.distanceFnames = options.distanceFnames;\n this.distanceFns = options.distanceFns;\n this.distanceFnArgs = options.distanceFnArgs;\n this.progressFunc = options.progressFunc;\n }\n /**\n * Embeds the data given into the two-dimensional space using t-SNE method.\\\n * @param {boolean} [parallelDistanceWorkers] Whether to use parallel distance workers.\n * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable.\n */\n async transform() {\n if (this.data[0].length > 10000)\n throw new Error('Maximum number of samples for T-SNE is 10000');\n const matrixService = new DistanceMatrixService(true, false);\n try {\n // const aggregate = getAggregationFunction(this.aggregationMethod, this.weights);\n // const distances: Array<Float32Array> = [];\n // for (let i = 0; i < this.data.length; ++i) {\n // const dist = await matrixService.calc(this.data[i], this.distanceFnames[i], false, this.distanceFnArgs[i]);\n // distances.push(dist);\n // }\n // const distance = new Float32Array(distances[0].length).fill(0);\n // for (let i = 0; i < distances[0].length; ++i)\n // distance[i] = aggregate(distances.map((d) => d[i]));\n const distance = await matrixService.calcMulti(this.data, this.distanceFnames, false, this.distanceFnArgs, this.weights, this.aggregationMethod);\n matrixService.terminate();\n // const matrixProxy = distanceMatrixProxy(distance, this.data[0].length);\n this.reducer.initDataDist(distance, this.data[0].length);\n for (let i = 0; i < this.iterations; ++i) {\n this.reducer.step(); // every time you call this, solution gets better\n if (this.progressFunc)\n this.progressFunc(i, this.iterations, []);\n }\n return this.reducer.getSolution();\n }\n catch (e) {\n matrixService.terminate();\n throw e;\n }\n }\n}\nclass UMAPReducer extends MultiColumnReducer {\n /**\n * Creates an instance of UMAPReducer.\n * @param {Options} options Options to pass to the constructor.\n * @memberof UMAPReducer\n */\n constructor(options) {\n const randomSeed = options.randomSeed ?? Date();\n const randomFn = seedRandom(randomSeed);\n super(options);\n this.useWebGPU = false;\n assert('distanceFnames' in options);\n assert('distanceFns' in options);\n this.distanceFnArgs = options.distanceFnArgs;\n this.distanceFns = options.distanceFns;\n this.progressFunc = options.progressFunc;\n this.useWebGPU = options.useWebGPU ?? false;\n this.distanceFnames = options.distanceFnames;\n options.nComponents = 2; // TODO: make it configurable\n //Umap uses vector indexing, so we need to create an array of vectors as indeces.\n this.vectors = new Array(this.data[0].length).fill(0).map((_, i) => i);\n if (this.data[0].length <= (options.nNeighbors ?? 15))\n options.nNeighbors = this.data[0].length - 1;\n options.random = randomFn;\n this.reducer = new UMAP(options);\n // this.reducer.distanceFn = this._encodedDistance.bind(this);\n }\n /**\n * Embeds the data given into the two-dimensional space using UMAP method.\n * @param {boolean} [_parallelDistanceWorkers] Whether to use parallel distance matrix workers.\n * @return {any} Cartesian coordinate of this embedding.\n */\n async transform(_parallelDistanceWorkers) {\n console.time('knn graph');\n let knnGraph = undefined;\n if (this.useWebGPU) {\n try {\n knnGraph = await multiColWebGPUKNN(this.data, this.reducer.neighbors, this.distanceFnames, this.aggregationMethod, this.weights, this.distanceFnArgs);\n }\n catch (e) {\n console.error(e);\n }\n }\n if (!knnGraph) {\n if (this.useWebGPU)\n console.error('WEBGPU KNN failed, falling back to multithreaded CPU implementation');\n knnGraph = await new SparseMatrixService()\n .multiColumnKNN(this.data, this.distanceFnames, this.reducer.neighbors, this.distanceFnArgs, this.weights, this.aggregationMethod);\n }\n console.timeEnd('knn graph');\n if (this.useWebGPU) {\n this.webGPUReducer = new WebGPUUMAP(this.vectors.length, {\n nComponents: this.reducer.nComponents,\n gamma: this.reducer.repulsionStrength,\n alpha: this.reducer.learningRate,\n nNeighbours: this.reducer.neighbors,\n spread: this.reducer.spread,\n minDist: this.reducer.minDist,\n negativeSampleRate: this.reducer.negativeSampleRate,\n localConnectivity: this.reducer.localConnectivity,\n setOpMixRatio: this.reducer.setOpMixRatio,\n });\n this.webGPUReducer.setPrecomputedKNN(knnGraph.knnIndexes, knnGraph.knnDistances);\n }\n else {\n this.reducer.setPrecomputedKNN(knnGraph.knnIndexes, knnGraph.knnDistances);\n }\n // needed so that garbage collector can free memory from distance matrix\n await new Promise((resolve) => {\n setTimeout(() => {\n resolve();\n }, 300);\n });\n let embedding = null;\n console.time('fit');\n try {\n if (this.useWebGPU && this.webGPUReducer) {\n embedding = await this.webGPUReducer.fit();\n if (!embedding)\n throw new Error('Failed to compute embedding');\n embedding = // transpose TODO: do a better job here\n new Array(embedding[0].length).fill(null).map((_, i) => new Float32Array(embedding.map((v) => v[i])));\n }\n }\n catch (e) {\n console.error(e);\n }\n if (!embedding) {\n if (this.useWebGPU)\n console.error('WEBGPU UMAP failed, falling back to CPU implementation');\n embedding = await this.reducer.fitAsync(this.vectors, (epoc) => {\n if (this.progressFunc)\n this.progressFunc(epoc, this.reducer.getNEpochs(), this.reducer.getEmbedding());\n });\n }\n console.timeEnd('fit');\n return arrayCast2Coordinates(embedding);\n function arrayCast2Coordinates(data) {\n return new Array(data.length).fill(0).map((_, i) => (Vector.from(data[i])));\n }\n }\n}\nconst AvailableReducers = {\n 'UMAP': UMAPReducer,\n 't-SNE': TSNEReducer,\n};\nexport class MultiColDimReducer {\n /**\n * Creates an instance of DimensionalityReducer.\n * @param {any[]} data Vectors to embed.\n * @param {KnownMethods} method Embedding method to be applied\n * @param {KnownMetrics} metric Distance metric to be computed between each of the vectors.\n * @param {Options} [options] Options to pass to the implementing embedders.\n * @memberof DimensionalityReducer\n */\n constructor(data, method, metrics, weights, distanceAggregation, options) {\n const measures = [];\n for (let idx = 0; idx < metrics.length; ++idx) {\n const measure = new Measure(metrics[idx]).getMeasure(options.distanceFnArgs[idx]);\n measures.push(measure);\n let bitArrayLength = 2048;\n for (let i = 0; i < data[idx].length; ++i) {\n if (data[idx][i] && data[idx][i]._length) {\n bitArrayLength = data[idx][i]._length;\n break;\n }\n }\n if (isBitArrayMetric(metrics[idx])) {\n for (let i = 0; i < data[idx].length; ++i) {\n if (data[idx][i] && data[idx][i]._data)\n data[idx][i] = new BitArray(data[idx][i]._data, data[idx][i]._length);\n else\n data[idx][i] = new BitArray(bitArrayLength);\n }\n }\n }\n if (method == 'UMAP') {\n this.reducer = new UMAPReducer({\n data: data,\n distanceFnames: metrics,\n distanceFns: measures,\n distanceFnArgs: options.distanceFnArgs,\n weights: weights,\n aggregationMethod: distanceAggregation,\n ...options\n });\n }\n else if (method == 't-SNE') {\n this.reducer = new TSNEReducer({\n data: data,\n distanceFnames: metrics,\n distanceFns: measures,\n distanceFnArgs: options.distanceFnArgs,\n weights: weights,\n aggregationMethod: distanceAggregation,\n ...options\n });\n }\n }\n /**\n * Embeds the data given into the two-dimensional space using the chosen method.\n *\n * @param {boolean} transpose Whether to transform coordinates to have columns-first orientation.\n * @param {boolean} parallelDistanceWorkers Whether to use parallel distance computation.\n * @throws {Error} If the embedding method was not found.\n * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable.\n * @memberof DimensionalityReducer\n */\n async transform(transpose = false) {\n if (this.reducer === undefined)\n throw new Error('Reducer was not defined.');\n let embedding = await this.reducer.transform();\n if (transpose)\n embedding = transposeMatrix(embedding);\n return embedding;\n }\n /**\n * Returns metrics available by type.\n *\n * @param {AvailableDataTypes} typeName type name\n * @return {string[]} Metric names which expects the given data type\n * @memberof DimensionalityReducer\n */\n static availableMetricsByType(typeName) {\n return Object.keys(AvailableMetrics[typeName]);\n }\n /**\n * Returns dimensionality reduction methods available.\n *\n * @readonly\n * @memberof DimensionalityReducer\n */\n static get availableMethods() {\n return Object.keys(AvailableReducers);\n }\n /**\n * Returns metrics available.\n *\n * @readonly\n * @memberof DimensionalityReducer\n */\n static get availableMetrics() {\n let ans = [];\n Object.values(AvailableMetrics).forEach((obj) => {\n const array = Object.values(obj);\n ans = [...ans, ...array];\n });\n return ans;\n }\n}\n//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"multi-column-dim-reducer.js","sourceRoot":"","sources":["multi-column-dim-reducer.ts"],"names":[],"mappings":"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","sourcesContent":["import {Coordinates, DistanceMetric, Matrix, Options, Vector, Vectors}\n  from '@datagrok-libraries/utils/src/type-declarations';\nimport {AvailableDataTypes, AvailableMetrics, KnownMetrics, Measure, isBitArrayMetric} from '../typed-metrics';\nimport {DistanceMatrixService} from '../distance-matrix';\nimport {DistanceAggregationMethod} from '../distance-matrix/types';\nimport {UMAP} from '../umap';\nimport {assert, transposeMatrix} from '@datagrok-libraries/utils/src/vector-operations';\nimport {KnnResult, SparseMatrixService} from '../distance-matrix/sparse-matrix-service';\nimport {DimReductionMethods} from './types';\nimport BitArray from '@datagrok-libraries/utils/src/bit-array';\nimport seedRandom from 'seedrandom';\n//import {TSNE} from '@keckelt/tsne';\nimport {TSNE} from '../t-sne/t-sne';\nimport {multiColWebGPUKNN} from '@datagrok-libraries/math';\nimport {WebGPUUMAP} from '@datagrok-libraries/math/src/webGPU/umap';\n\nexport interface IUMAPOptions {\n    learningRate?: number;\n    nComponents?: number;\n    nEpochs?: number;\n    nNeighbors?: number;\n    spread?: number;\n    minDist?: number;\n    progressFunc?: (epoc: number, epochsLength: number, embeddings: number[][]) => void;\n    randomSeed?: string;\n    useWebGPU?: boolean;\n}\n\nexport interface ITSNEOptions {\n    epsilon?: number;\n    perplexity?: number;\n    dim?: number;\n}\n\nexport interface IDimReductionParam<T extends number | string | boolean = number> {\n    uiName: string;\n    value: (T extends number ? number : T extends string ? string : boolean) | null;\n    tooltip: string;\n    type?: T extends number ? 'number' : T extends string ? 'string' : 'boolean';\n    placeholder?: string;\n    min?: number;\n    max?: number;\n    step?: number;\n    disable?: boolean;\n    disableTooltip?: string;\n}\n\nabstract class MultiColumnReducer {\n    protected data: Vectors[];\n    protected weights: number[];\n    protected aggregationMethod: DistanceAggregationMethod;\n    constructor(options: Options) {\n      this.data = options.data;\n      this.weights = options.weights;\n      this.aggregationMethod = options.aggregationMethod;\n    }\n\n    /** Embeds the data given into the two-dimensional space.\n     * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable. */\n    abstract transform(): Promise<Matrix>;\n}\n\nclass TSNEReducer extends MultiColumnReducer {\n    protected reducer: TSNE;\n    protected iterations: number;\n    protected distanceFnames: KnownMetrics[];\n    protected distanceFns: ((a: any, b: any) => number)[];\n    protected distanceFnArgs: {[_: string]: any}[];\n    protected progressFunc?: (epoc: number, epochsLength: number, embeddings?: number[][]) => void;\n    /**\n     * Creates an instance of TSNEReducer.\n     * @param {Options} options Options to pass to the constructor.\n     * @memberof TSNEReducer\n     */\n    constructor(options: Options) {\n      super(options);\n      const randomSeed: string = options.randomSeed ?? Date();\n      const randomFn = seedRandom(randomSeed);\n      options.dim = 2; // TODO: make it configurable\n      options.random = randomFn;\n      this.reducer = new TSNE(options);\n      this.iterations = options?.iterations ?? this.reducer.getIterSize(this.data[0].length);\n      this.distanceFnames = options.distanceFnames;\n      this.distanceFns = options.distanceFns;\n      this.distanceFnArgs = options.distanceFnArgs;\n      this.progressFunc = options.progressFunc;\n    }\n\n    /**\n     * Embeds the data given into the two-dimensional space using t-SNE method.\\\n     * @param {boolean} [parallelDistanceWorkers] Whether to use parallel distance workers.\n     * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable.\n     */\n    public async transform(): Promise<Matrix> {\n      if (this.data[0].length > 10000)\n        throw new Error('Maximum number of samples for T-SNE is 10000');\n      const matrixService = new DistanceMatrixService(true, false);\n      try {\n        // const aggregate = getAggregationFunction(this.aggregationMethod, this.weights);\n        // const distances: Array<Float32Array> = [];\n        // for (let i = 0; i < this.data.length; ++i) {\n        //   const dist = await matrixService.calc(this.data[i], this.distanceFnames[i], false, this.distanceFnArgs[i]);\n        //   distances.push(dist);\n        // }\n        // const distance = new Float32Array(distances[0].length).fill(0);\n        // for (let i = 0; i < distances[0].length; ++i)\n        //   distance[i] = aggregate(distances.map((d) => d[i]));\n        const distance = await matrixService.calcMulti(this.data, this.distanceFnames, false, this.distanceFnArgs,\n          this.weights, this.aggregationMethod);\n        matrixService.terminate();\n        // const matrixProxy = distanceMatrixProxy(distance, this.data[0].length);\n        this.reducer.initDataDist(distance, this.data[0].length);\n\n        for (let i = 0; i < this.iterations; ++i) {\n          this.reducer.step(); // every time you call this, solution gets better\n          if (this.progressFunc)\n            this.progressFunc(i, this.iterations, []);\n        }\n        return this.reducer.getSolution();\n      } catch (e) {\n        matrixService.terminate();\n        throw e;\n      }\n    }\n}\n\nclass UMAPReducer extends MultiColumnReducer {\n    protected reducer: UMAP;\n    protected distanceFnames: KnownMetrics[];\n    protected distanceFns: Function[];\n    protected vectors: number[];\n    protected progressFunc?: (epoc: number, epochsLength: number, embedding: number[][]) => void;\n    protected distanceFnArgs: {[_: string]: any}[];\n    protected useWebGPU: boolean = false;\n    protected webGPUReducer: WebGPUUMAP | undefined;\n    /**\n     * Creates an instance of UMAPReducer.\n     * @param {Options} options Options to pass to the constructor.\n     * @memberof UMAPReducer\n     */\n    constructor(options: Options) {\n      const randomSeed: string = options.randomSeed ?? Date();\n      const randomFn = seedRandom(randomSeed);\n      super(options);\n      assert('distanceFnames' in options);\n      assert('distanceFns' in options);\n      this.distanceFnArgs = options.distanceFnArgs;\n      this.distanceFns = options.distanceFns!;\n      this.progressFunc = options.progressFunc;\n      this.useWebGPU = options.useWebGPU ?? false;\n      this.distanceFnames = options.distanceFnames!;\n      options.nComponents = 2; // TODO: make it configurable\n      //Umap uses vector indexing, so we need to create an array of vectors as indeces.\n      this.vectors = new Array(this.data[0].length).fill(0).map((_, i) => i);\n\n      if (this.data[0].length <= (options.nNeighbors ?? 15))\n        options.nNeighbors = this.data[0].length - 1;\n      options.random = randomFn;\n      this.reducer = new UMAP(options);\n      // this.reducer.distanceFn = this._encodedDistance.bind(this);\n    }\n\n    /**\n     * Embeds the data given into the two-dimensional space using UMAP method.\n     * @param {boolean} [_parallelDistanceWorkers] Whether to use parallel distance matrix workers.\n     * @return {any} Cartesian coordinate of this embedding.\n     */\n    public async transform(_parallelDistanceWorkers?: boolean): Promise<Matrix> {\n      console.time('knn graph');\n      let knnGraph: KnnResult | undefined = undefined;\n      if (this.useWebGPU) {\n        try {\n          knnGraph = await multiColWebGPUKNN(\n            this.data, this.reducer.neighbors, this.distanceFnames as any, this.aggregationMethod as any,\n            this.weights, this.distanceFnArgs\n          ) as unknown as KnnResult;\n        } catch (e) {\n          console.error(e);\n        }\n      }\n      if (!knnGraph) {\n        if (this.useWebGPU)\n          console.error('WEBGPU KNN failed, falling back to multithreaded CPU implementation');\n        knnGraph = await new SparseMatrixService()\n          .multiColumnKNN(this.data, this.distanceFnames, this.reducer.neighbors,\n            this.distanceFnArgs, this.weights, this.aggregationMethod);\n      }\n      console.timeEnd('knn graph');\n      if (this.useWebGPU) {\n        this.webGPUReducer = new WebGPUUMAP(this.vectors.length, {\n          nComponents: this.reducer.nComponents,\n          gamma: this.reducer.repulsionStrength,\n          alpha: this.reducer.learningRate,\n          nNeighbours: this.reducer.neighbors,\n          spread: this.reducer.spread,\n          minDist: this.reducer.minDist,\n          negativeSampleRate: this.reducer.negativeSampleRate,\n          localConnectivity: this.reducer.localConnectivity,\n          setOpMixRatio: this.reducer.setOpMixRatio,\n        });\n        this.webGPUReducer.setPrecomputedKNN(knnGraph.knnIndexes, knnGraph.knnDistances);\n      } else {\n        this.reducer.setPrecomputedKNN(knnGraph.knnIndexes, knnGraph.knnDistances);\n      }\n\n      // needed so that garbage collector can free memory from distance matrix\n      await new Promise<void>((resolve) => {\n        setTimeout(() => {\n          resolve();\n        }, 300);\n      });\n\n      let embedding: number[][] | Float32Array[] | undefined |null = null;\n      console.time('fit');\n      try {\n        if (this.useWebGPU && this.webGPUReducer) {\n          embedding = await this.webGPUReducer.fit();\n          if (!embedding)\n            throw new Error('Failed to compute embedding');\n          embedding = // transpose TODO: do a better job here\n            new Array(embedding[0].length).fill(null).map((_, i) => new Float32Array(embedding!.map((v) => v[i])));\n        }\n      } catch (e) {\n        console.error(e);\n      }\n      if (!embedding) {\n        if (this.useWebGPU)\n          console.error('WEBGPU UMAP failed, falling back to CPU implementation');\n        embedding = await this.reducer.fitAsync(this.vectors, (epoc) => {\n          if (this.progressFunc)\n            this.progressFunc(epoc, this.reducer.getNEpochs(), this.reducer.getEmbedding());\n        });\n      }\n      console.timeEnd('fit');\n      return arrayCast2Coordinates(embedding);\n      function arrayCast2Coordinates(data: number[][] | Float32Array[]): Coordinates {\n        return new Array(data.length).fill(0).map((_, i) => (Vector.from(data[i])));\n      }\n    }\n}\n\nconst AvailableReducers = {\n  'UMAP': UMAPReducer,\n  't-SNE': TSNEReducer,\n};\n\nexport type KnownMethods = keyof typeof AvailableReducers;\n\nexport class MultiColDimReducer {\n    private reducer: MultiColumnReducer | undefined;\n    /**\n   * Creates an instance of DimensionalityReducer.\n   * @param {any[]} data Vectors to embed.\n   * @param {KnownMethods} method Embedding method to be applied\n   * @param {KnownMetrics} metric Distance metric to be computed between each of the vectors.\n   * @param {Options} [options] Options to pass to the implementing embedders.\n   * @memberof DimensionalityReducer\n   */\n    constructor(data: Array<any[]>, method: DimReductionMethods, metrics: KnownMetrics[],\n      weights: number[], distanceAggregation: DistanceAggregationMethod, options: Options) {\n      const measures: DistanceMetric[] = [];\n      for (let idx = 0; idx < metrics.length; ++idx) {\n        const measure = new Measure(metrics[idx]).getMeasure(options.distanceFnArgs[idx]);\n        measures.push(measure);\n        let bitArrayLength = 2048;\n        for (let i = 0; i < data[idx].length; ++i) {\n          if (data[idx][i] && data[idx][i]._length) {\n            bitArrayLength = data[idx][i]._length;\n            break;\n          }\n        }\n        if (isBitArrayMetric(metrics[idx])) {\n          for (let i = 0; i < data[idx].length; ++i) {\n            if (data[idx][i] && data[idx][i]._data)\n              data[idx][i] = new BitArray(data[idx][i]._data, data[idx][i]._length);\n            else\n              data[idx][i] = new BitArray(bitArrayLength);\n          }\n        }\n      }\n\n      if (method == 'UMAP') {\n        this.reducer = new UMAPReducer({\n          data: data,\n          distanceFnames: metrics,\n          distanceFns: measures,\n          distanceFnArgs: options.distanceFnArgs,\n          weights: weights,\n          aggregationMethod: distanceAggregation,\n          ...options\n        });\n      } else if (method == 't-SNE') {\n        this.reducer = new TSNEReducer({\n          data: data,\n          distanceFnames: metrics,\n          distanceFns: measures,\n          distanceFnArgs: options.distanceFnArgs,\n          weights: weights,\n          aggregationMethod: distanceAggregation,\n          ...options\n        });\n      }\n    }\n\n    /**\n   * Embeds the data given into the two-dimensional space using the chosen method.\n   *\n   * @param {boolean} transpose Whether to transform coordinates to have columns-first orientation.\n   * @param {boolean} parallelDistanceWorkers Whether to use parallel distance computation.\n   * @throws {Error} If the embedding method was not found.\n   * @return {any} Cartesian coordinate of this embedding and distance matrix where applicable.\n   * @memberof DimensionalityReducer\n   */\n    public async transform(transpose: boolean = false): Promise<Matrix> {\n      if (this.reducer === undefined)\n        throw new Error('Reducer was not defined.');\n\n      let embedding = await this.reducer.transform();\n\n      if (transpose)\n        embedding = transposeMatrix(embedding);\n\n      return embedding;\n    }\n\n    /**\n   * Returns metrics available by type.\n   *\n   * @param {AvailableDataTypes} typeName type name\n   * @return {string[]} Metric names which expects the given data type\n   * @memberof DimensionalityReducer\n   */\n    static availableMetricsByType(typeName: AvailableDataTypes) {\n      return Object.keys(AvailableMetrics[typeName]);\n    }\n\n    /**\n   * Returns dimensionality reduction methods available.\n   *\n   * @readonly\n   * @memberof DimensionalityReducer\n   */\n    static get availableMethods() {\n      return Object.keys(AvailableReducers);\n    }\n\n    /**\n   * Returns metrics available.\n   *\n   * @readonly\n   * @memberof DimensionalityReducer\n   */\n    static get availableMetrics() {\n      let ans: string[] = [];\n      Object.values(AvailableMetrics).forEach((obj) => {\n        const array = Object.values(obj);\n        ans = [...ans, ...array];\n      });\n      return ans;\n    }\n}\n"]}","import { MultiColDimReducer } from './multi-column-dim-reducer';\n/**\n * Worker thread receiving data function.\n *\n * @param {any[]} columnData Samples to process.\n * @param {KnownMethods} method Embedding method.\n * @param {KnownMetrics} measure Distance metric.\n * @param {any} options Options to pass to algorithm.\n * @param {boolean} parallelDistanceWorkers Whether to use parallel distance workers.\n * @return {any} Embedding (and distance matrix where applicable).\n */\nasync function onMessage(columnsData, method, metrics, weights, aggregationMethod, options) {\n const reducer = new MultiColDimReducer(columnsData, method, metrics, weights, aggregationMethod, { ...options, progressFunc });\n return await reducer.transform(true);\n}\nasync function progressFunc(epochNum, epochsLength, embedding) {\n if (epochNum % 5 === 0)\n self.postMessage({ epochNum, epochsLength, embedding });\n}\nself.onmessage = async ({ data: { columnsData, method, distanceMetrics, options, weights, aggregationMethod } }) => {\n let data;\n try {\n const embedding = await onMessage(columnsData, method, distanceMetrics, weights, aggregationMethod, options);\n data = { embedding };\n }\n catch (e) {\n data = { error: e };\n }\n self.postMessage({\n error: data.error,\n embedding: data.embedding,\n });\n};\n//# sourceMappingURL=data:application/json;base64,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","// A library of seedable RNGs implemented in Javascript.\n//\n// Usage:\n//\n// var seedrandom = require('seedrandom');\n// var random = seedrandom(1); // or any seed.\n// var x = random(); // 0 <= x < 1. Every bit is random.\n// var x = random.quick(); // 0 <= x < 1. 32 bits of randomness.\n\n// alea, a 53-bit multiply-with-carry generator by Johannes Baagøe.\n// Period: ~2^116\n// Reported to pass all BigCrush tests.\nvar alea = require('./lib/alea');\n\n// xor128, a pure xor-shift generator by George Marsaglia.\n// Period: 2^128-1.\n// Reported to fail: MatrixRank and LinearComp.\nvar xor128 = require('./lib/xor128');\n\n// xorwow, George Marsaglia's 160-bit xor-shift combined plus weyl.\n// Period: 2^192-2^32\n// Reported to fail: CollisionOver, SimpPoker, and LinearComp.\nvar xorwow = require('./lib/xorwow');\n\n// xorshift7, by François Panneton and Pierre L'ecuyer, takes\n// a different approach: it adds robustness by allowing more shifts\n// than Marsaglia's original three. It is a 7-shift generator\n// with 256 bits, that passes BigCrush with no systmatic failures.\n// Period 2^256-1.\n// No systematic BigCrush failures reported.\nvar xorshift7 = require('./lib/xorshift7');\n\n// xor4096, by Richard Brent, is a 4096-bit xor-shift with a\n// very long period that also adds a Weyl generator. It also passes\n// BigCrush with no systematic failures. Its long period may\n// be useful if you have many generators and need to avoid\n// collisions.\n// Period: 2^4128-2^32.\n// No systematic BigCrush failures reported.\nvar xor4096 = require('./lib/xor4096');\n\n// Tyche-i, by Samuel Neves and Filipe Araujo, is a bit-shifting random\n// number generator derived from ChaCha, a modern stream cipher.\n// https://eden.dei.uc.pt/~sneves/pubs/2011-snfa2.pdf\n// Period: ~2^127\n// No systematic BigCrush failures reported.\nvar tychei = require('./lib/tychei');\n\n// The original ARC4-based prng included in this library.\n// Period: ~2^1600\nvar sr = require('./seedrandom');\n\nsr.alea = alea;\nsr.xor128 = xor128;\nsr.xorwow = xorwow;\nsr.xorshift7 = xorshift7;\nsr.xor4096 = xor4096;\nsr.tychei = tychei;\n\nmodule.exports = sr;\n","// A port of an algorithm by Johannes Baagøe <baagoe@baagoe.com>, 2010\n// http://baagoe.com/en/RandomMusings/javascript/\n// https://github.com/nquinlan/better-random-numbers-for-javascript-mirror\n// Original work is under MIT license -\n\n// Copyright (C) 2010 by Johannes Baagøe <baagoe@baagoe.org>\n//\n// Permission is hereby granted, free of charge, to any person obtaining a copy\n// of this software and associated documentation files (the \"Software\"), to deal\n// in the Software without restriction, including without limitation the rights\n// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n// copies of the Software, and to permit persons to whom the Software is\n// furnished to do so, subject to the following conditions:\n//\n// The above copyright notice and this permission notice shall be included in\n// all copies or substantial portions of the Software.\n//\n// THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n// THE SOFTWARE.\n\n\n\n(function(global, module, define) {\n\nfunction Alea(seed) {\n var me = this, mash = Mash();\n\n me.next = function() {\n var t = 2091639 * me.s0 + me.c * 2.3283064365386963e-10; // 2^-32\n me.s0 = me.s1;\n me.s1 = me.s2;\n return me.s2 = t - (me.c = t | 0);\n };\n\n // Apply the seeding algorithm from Baagoe.\n me.c = 1;\n me.s0 = mash(' ');\n me.s1 = mash(' ');\n me.s2 = mash(' ');\n me.s0 -= mash(seed);\n if (me.s0 < 0) { me.s0 += 1; }\n me.s1 -= mash(seed);\n if (me.s1 < 0) { me.s1 += 1; }\n me.s2 -= mash(seed);\n if (me.s2 < 0) { me.s2 += 1; }\n mash = null;\n}\n\nfunction copy(f, t) {\n t.c = f.c;\n t.s0 = f.s0;\n t.s1 = f.s1;\n t.s2 = f.s2;\n return t;\n}\n\nfunction impl(seed, opts) {\n var xg = new Alea(seed),\n state = opts && opts.state,\n prng = xg.next;\n prng.int32 = function() { return (xg.next() * 0x100000000) | 0; }\n prng.double = function() {\n return prng() + (prng() * 0x200000 | 0) * 1.1102230246251565e-16; // 2^-53\n };\n prng.quick = prng;\n if (state) {\n if (typeof(state) == 'object') copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nfunction Mash() {\n var n = 0xefc8249d;\n\n var mash = function(data) {\n data = String(data);\n for (var i = 0; i < data.length; i++) {\n n += data.charCodeAt(i);\n var h = 0.02519603282416938 * n;\n n = h >>> 0;\n h -= n;\n h *= n;\n n = h >>> 0;\n h -= n;\n n += h * 0x100000000; // 2^32\n }\n return (n >>> 0) * 2.3283064365386963e-10; // 2^-32\n };\n\n return mash;\n}\n\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.alea = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n\n","// A Javascript implementaion of the \"Tyche-i\" prng algorithm by\n// Samuel Neves and Filipe Araujo.\n// See https://eden.dei.uc.pt/~sneves/pubs/2011-snfa2.pdf\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this, strseed = '';\n\n // Set up generator function.\n me.next = function() {\n var b = me.b, c = me.c, d = me.d, a = me.a;\n b = (b << 25) ^ (b >>> 7) ^ c;\n c = (c - d) | 0;\n d = (d << 24) ^ (d >>> 8) ^ a;\n a = (a - b) | 0;\n me.b = b = (b << 20) ^ (b >>> 12) ^ c;\n me.c = c = (c - d) | 0;\n me.d = (d << 16) ^ (c >>> 16) ^ a;\n return me.a = (a - b) | 0;\n };\n\n /* The following is non-inverted tyche, which has better internal\n * bit diffusion, but which is about 25% slower than tyche-i in JS.\n me.next = function() {\n var a = me.a, b = me.b, c = me.c, d = me.d;\n a = (me.a + me.b | 0) >>> 0;\n d = me.d ^ a; d = d << 16 ^ d >>> 16;\n c = me.c + d | 0;\n b = me.b ^ c; b = b << 12 ^ d >>> 20;\n me.a = a = a + b | 0;\n d = d ^ a; me.d = d = d << 8 ^ d >>> 24;\n me.c = c = c + d | 0;\n b = b ^ c;\n return me.b = (b << 7 ^ b >>> 25);\n }\n */\n\n me.a = 0;\n me.b = 0;\n me.c = 2654435769 | 0;\n me.d = 1367130551;\n\n if (seed === Math.floor(seed)) {\n // Integer seed.\n me.a = (seed / 0x100000000) | 0;\n me.b = seed | 0;\n } else {\n // String seed.\n strseed += seed;\n }\n\n // Mix in string seed, then discard an initial batch of 64 values.\n for (var k = 0; k < strseed.length + 20; k++) {\n me.b ^= strseed.charCodeAt(k) | 0;\n me.next();\n }\n}\n\nfunction copy(f, t) {\n t.a = f.a;\n t.b = f.b;\n t.c = f.c;\n t.d = f.d;\n return t;\n};\n\nfunction impl(seed, opts) {\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (typeof(state) == 'object') copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.tychei = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n\n","// A Javascript implementaion of the \"xor128\" prng algorithm by\n// George Marsaglia. See http://www.jstatsoft.org/v08/i14/paper\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this, strseed = '';\n\n me.x = 0;\n me.y = 0;\n me.z = 0;\n me.w = 0;\n\n // Set up generator function.\n me.next = function() {\n var t = me.x ^ (me.x << 11);\n me.x = me.y;\n me.y = me.z;\n me.z = me.w;\n return me.w ^= (me.w >>> 19) ^ t ^ (t >>> 8);\n };\n\n if (seed === (seed | 0)) {\n // Integer seed.\n me.x = seed;\n } else {\n // String seed.\n strseed += seed;\n }\n\n // Mix in string seed, then discard an initial batch of 64 values.\n for (var k = 0; k < strseed.length + 64; k++) {\n me.x ^= strseed.charCodeAt(k) | 0;\n me.next();\n }\n}\n\nfunction copy(f, t) {\n t.x = f.x;\n t.y = f.y;\n t.z = f.z;\n t.w = f.w;\n return t;\n}\n\nfunction impl(seed, opts) {\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (typeof(state) == 'object') copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.xor128 = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n\n","// A Javascript implementaion of Richard Brent's Xorgens xor4096 algorithm.\n//\n// This fast non-cryptographic random number generator is designed for\n// use in Monte-Carlo algorithms. It combines a long-period xorshift\n// generator with a Weyl generator, and it passes all common batteries\n// of stasticial tests for randomness while consuming only a few nanoseconds\n// for each prng generated. For background on the generator, see Brent's\n// paper: \"Some long-period random number generators using shifts and xors.\"\n// http://arxiv.org/pdf/1004.3115v1.pdf\n//\n// Usage:\n//\n// var xor4096 = require('xor4096');\n// random = xor4096(1); // Seed with int32 or string.\n// assert.equal(random(), 0.1520436450538547); // (0, 1) range, 53 bits.\n// assert.equal(random.int32(), 1806534897); // signed int32, 32 bits.\n//\n// For nonzero numeric keys, this impelementation provides a sequence\n// identical to that by Brent's xorgens 3 implementaion in C. This\n// implementation also provides for initalizing the generator with\n// string seeds, or for saving and restoring the state of the generator.\n//\n// On Chrome, this prng benchmarks about 2.1 times slower than\n// Javascript's built-in Math.random().\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this;\n\n // Set up generator function.\n me.next = function() {\n var w = me.w,\n X = me.X, i = me.i, t, v;\n // Update Weyl generator.\n me.w = w = (w + 0x61c88647) | 0;\n // Update xor generator.\n v = X[(i + 34) & 127];\n t = X[i = ((i + 1) & 127)];\n v ^= v << 13;\n t ^= t << 17;\n v ^= v >>> 15;\n t ^= t >>> 12;\n // Update Xor generator array state.\n v = X[i] = v ^ t;\n me.i = i;\n // Result is the combination.\n return (v + (w ^ (w >>> 16))) | 0;\n };\n\n function init(me, seed) {\n var t, v, i, j, w, X = [], limit = 128;\n if (seed === (seed | 0)) {\n // Numeric seeds initialize v, which is used to generates X.\n v = seed;\n seed = null;\n } else {\n // String seeds are mixed into v and X one character at a time.\n seed = seed + '\\0';\n v = 0;\n limit = Math.max(limit, seed.length);\n }\n // Initialize circular array and weyl value.\n for (i = 0, j = -32; j < limit; ++j) {\n // Put the unicode characters into the array, and shuffle them.\n if (seed) v ^= seed.charCodeAt((j + 32) % seed.length);\n // After 32 shuffles, take v as the starting w value.\n if (j === 0) w = v;\n v ^= v << 10;\n v ^= v >>> 15;\n v ^= v << 4;\n v ^= v >>> 13;\n if (j >= 0) {\n w = (w + 0x61c88647) | 0; // Weyl.\n t = (X[j & 127] ^= (v + w)); // Combine xor and weyl to init array.\n i = (0 == t) ? i + 1 : 0; // Count zeroes.\n }\n }\n // We have detected all zeroes; make the key nonzero.\n if (i >= 128) {\n X[(seed && seed.length || 0) & 127] = -1;\n }\n // Run the generator 512 times to further mix the state before using it.\n // Factoring this as a function slows the main generator, so it is just\n // unrolled here. The weyl generator is not advanced while warming up.\n i = 127;\n for (j = 4 * 128; j > 0; --j) {\n v = X[(i + 34) & 127];\n t = X[i = ((i + 1) & 127)];\n v ^= v << 13;\n t ^= t << 17;\n v ^= v >>> 15;\n t ^= t >>> 12;\n X[i] = v ^ t;\n }\n // Storing state as object members is faster than using closure variables.\n me.w = w;\n me.X = X;\n me.i = i;\n }\n\n init(me, seed);\n}\n\nfunction copy(f, t) {\n t.i = f.i;\n t.w = f.w;\n t.X = f.X.slice();\n return t;\n};\n\nfunction impl(seed, opts) {\n if (seed == null) seed = +(new Date);\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (state.X) copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.xor4096 = impl;\n}\n\n})(\n this, // window object or global\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n","// A Javascript implementaion of the \"xorshift7\" algorithm by\n// François Panneton and Pierre L'ecuyer:\n// \"On the Xorgshift Random Number Generators\"\n// http://saluc.engr.uconn.edu/refs/crypto/rng/panneton05onthexorshift.pdf\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this;\n\n // Set up generator function.\n me.next = function() {\n // Update xor generator.\n var X = me.x, i = me.i, t, v, w;\n t = X[i]; t ^= (t >>> 7); v = t ^ (t << 24);\n t = X[(i + 1) & 7]; v ^= t ^ (t >>> 10);\n t = X[(i + 3) & 7]; v ^= t ^ (t >>> 3);\n t = X[(i + 4) & 7]; v ^= t ^ (t << 7);\n t = X[(i + 7) & 7]; t = t ^ (t << 13); v ^= t ^ (t << 9);\n X[i] = v;\n me.i = (i + 1) & 7;\n return v;\n };\n\n function init(me, seed) {\n var j, w, X = [];\n\n if (seed === (seed | 0)) {\n // Seed state array using a 32-bit integer.\n w = X[0] = seed;\n } else {\n // Seed state using a string.\n seed = '' + seed;\n for (j = 0; j < seed.length; ++j) {\n X[j & 7] = (X[j & 7] << 15) ^\n (seed.charCodeAt(j) + X[(j + 1) & 7] << 13);\n }\n }\n // Enforce an array length of 8, not all zeroes.\n while (X.length < 8) X.push(0);\n for (j = 0; j < 8 && X[j] === 0; ++j);\n if (j == 8) w = X[7] = -1; else w = X[j];\n\n me.x = X;\n me.i = 0;\n\n // Discard an initial 256 values.\n for (j = 256; j > 0; --j) {\n me.next();\n }\n }\n\n init(me, seed);\n}\n\nfunction copy(f, t) {\n t.x = f.x.slice();\n t.i = f.i;\n return t;\n}\n\nfunction impl(seed, opts) {\n if (seed == null) seed = +(new Date);\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (state.x) copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.xorshift7 = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n","// A Javascript implementaion of the \"xorwow\" prng algorithm by\n// George Marsaglia. See http://www.jstatsoft.org/v08/i14/paper\n\n(function(global, module, define) {\n\nfunction XorGen(seed) {\n var me = this, strseed = '';\n\n // Set up generator function.\n me.next = function() {\n var t = (me.x ^ (me.x >>> 2));\n me.x = me.y; me.y = me.z; me.z = me.w; me.w = me.v;\n return (me.d = (me.d + 362437 | 0)) +\n (me.v = (me.v ^ (me.v << 4)) ^ (t ^ (t << 1))) | 0;\n };\n\n me.x = 0;\n me.y = 0;\n me.z = 0;\n me.w = 0;\n me.v = 0;\n\n if (seed === (seed | 0)) {\n // Integer seed.\n me.x = seed;\n } else {\n // String seed.\n strseed += seed;\n }\n\n // Mix in string seed, then discard an initial batch of 64 values.\n for (var k = 0; k < strseed.length + 64; k++) {\n me.x ^= strseed.charCodeAt(k) | 0;\n if (k == strseed.length) {\n me.d = me.x << 10 ^ me.x >>> 4;\n }\n me.next();\n }\n}\n\nfunction copy(f, t) {\n t.x = f.x;\n t.y = f.y;\n t.z = f.z;\n t.w = f.w;\n t.v = f.v;\n t.d = f.d;\n return t;\n}\n\nfunction impl(seed, opts) {\n var xg = new XorGen(seed),\n state = opts && opts.state,\n prng = function() { return (xg.next() >>> 0) / 0x100000000; };\n prng.double = function() {\n do {\n var top = xg.next() >>> 11,\n bot = (xg.next() >>> 0) / 0x100000000,\n result = (top + bot) / (1 << 21);\n } while (result === 0);\n return result;\n };\n prng.int32 = xg.next;\n prng.quick = prng;\n if (state) {\n if (typeof(state) == 'object') copy(state, xg);\n prng.state = function() { return copy(xg, {}); }\n }\n return prng;\n}\n\nif (module && module.exports) {\n module.exports = impl;\n} else if (define && define.amd) {\n define(function() { return impl; });\n} else {\n this.xorwow = impl;\n}\n\n})(\n this,\n (typeof module) == 'object' && module, // present in node.js\n (typeof define) == 'function' && define // present with an AMD loader\n);\n\n\n","/*\nCopyright 2019 David Bau.\n\nPermission is hereby granted, free of charge, to any person obtaining\na copy of this software and associated documentation files (the\n\"Software\"), to deal in the Software without restriction, including\nwithout limitation the rights to use, copy, modify, merge, publish,\ndistribute, sublicense, and/or sell copies of the Software, and to\npermit persons to whom the Software is furnished to do so, subject to\nthe following conditions:\n\nThe above copyright notice and this permission notice shall be\nincluded in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND,\nEXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF\nMERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.\nIN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY\nCLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,\nTORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE\nSOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n\n*/\n\n(function (global, pool, math) {\n//\n// The following constants are related to IEEE 754 limits.\n//\n\nvar width = 256, // each RC4 output is 0 <= x < 256\n chunks = 6, // at least six RC4 outputs for each double\n digits = 52, // there are 52 significant digits in a double\n rngname = 'random', // rngname: name for Math.random and Math.seedrandom\n startdenom = math.pow(width, chunks),\n significance = math.pow(2, digits),\n overflow = significance * 2,\n mask = width - 1,\n nodecrypto; // node.js crypto module, initialized at the bottom.\n\n//\n// seedrandom()\n// This is the seedrandom function described above.\n//\nfunction seedrandom(seed, options, callback) {\n var key = [];\n options = (options == true) ? { entropy: true } : (options || {});\n\n // Flatten the seed string or build one from local entropy if needed.\n var shortseed = mixkey(flatten(\n options.entropy ? [seed, tostring(pool)] :\n (seed == null) ? autoseed() : seed, 3), key);\n\n // Use the seed to initialize an ARC4 generator.\n var arc4 = new ARC4(key);\n\n // This function returns a random double in [0, 1) that contains\n // randomness in every bit of the mantissa of the IEEE 754 value.\n var prng = function() {\n var n = arc4.g(chunks), // Start with a numerator n < 2 ^ 48\n d = startdenom, // and denominator d = 2 ^ 48.\n x = 0; // and no 'extra last byte'.\n while (n < significance) { // Fill up all significant digits by\n n = (n + x) * width; // shifting numerator and\n d *= width; // denominator and generating a\n x = arc4.g(1); // new least-significant-byte.\n }\n while (n >= overflow) { // To avoid rounding up, before adding\n n /= 2; // last byte, shift everything\n d /= 2; // right using integer math until\n x >>>= 1; // we have exactly the desired bits.\n }\n return (n + x) / d; // Form the number within [0, 1).\n };\n\n prng.int32 = function() { return arc4.g(4) | 0; }\n prng.quick = function() { return arc4.g(4) / 0x100000000; }\n prng.double = prng;\n\n // Mix the randomness into accumulated entropy.\n mixkey(tostring(arc4.S), pool);\n\n // Calling convention: what to return as a function of prng, seed, is_math.\n return (options.pass || callback ||\n function(prng, seed, is_math_call, state) {\n if (state) {\n // Load the arc4 state from the given state if it has an S array.\n if (state.S) { copy(state, arc4); }\n // Only provide the .state method if requested via options.state.\n prng.state = function() { return copy(arc4, {}); }\n }\n\n // If called as a method of Math (Math.seedrandom()), mutate\n // Math.random because that is how seedrandom.js has worked since v1.0.\n if (is_math_call) { math[rngname] = prng; return seed; }\n\n // Otherwise, it is a newer calling convention, so return the\n // prng directly.\n else return prng;\n })(\n prng,\n shortseed,\n 'global' in options ? options.global : (this == math),\n options.state);\n}\n\n//\n// ARC4\n//\n// An ARC4 implementation. The constructor takes a key in the form of\n// an array of at most (width) integers that should be 0 <= x < (width).\n//\n// The g(count) method returns a pseudorandom integer that concatenates\n// the next (count) outputs from ARC4. Its return value is a number x\n// that is in the range 0 <= x < (width ^ count).\n//\nfunction ARC4(key) {\n var t, keylen = key.length,\n me = this, i = 0, j = me.i = me.j = 0, s = me.S = [];\n\n // The empty key [] is treated as [0].\n if (!keylen) { key = [keylen++]; }\n\n // Set up S using the standard key scheduling algorithm.\n while (i < width) {\n s[i] = i++;\n }\n for (i = 0; i < width; i++) {\n s[i] = s[j = mask & (j + key[i % keylen] + (t = s[i]))];\n s[j] = t;\n }\n\n // The \"g\" method returns the next (count) outputs as one number.\n (me.g = function(count) {\n // Using instance members instead of closure state nearly doubles speed.\n var t, r = 0,\n i = me.i, j = me.j, s = me.S;\n while (count--) {\n t = s[i = mask & (i + 1)];\n r = r * width + s[mask & ((s[i] = s[j = mask & (j + t)]) + (s[j] = t))];\n }\n me.i = i; me.j = j;\n return r;\n // For robust unpredictability, the function call below automatically\n // discards an initial batch of values. This is called RC4-drop[256].\n // See http://google.com/search?q=rsa+fluhrer+response&btnI\n })(width);\n}\n\n//\n// copy()\n// Copies internal state of ARC4 to or from a plain object.\n//\nfunction copy(f, t) {\n t.i = f.i;\n t.j = f.j;\n t.S = f.S.slice();\n return t;\n};\n\n//\n// flatten()\n// Converts an object tree to nested arrays of strings.\n//\nfunction flatten(obj, depth) {\n var result = [], typ = (typeof obj), prop;\n if (depth && typ == 'object') {\n for (prop in obj) {\n try { result.push(flatten(obj[prop], depth - 1)); } catch (e) {}\n }\n }\n return (result.length ? result : typ == 'string' ? obj : obj + '\\0');\n}\n\n//\n// mixkey()\n// Mixes a string seed into a key that is an array of integers, and\n// returns a shortened string seed that is equivalent to the result key.\n//\nfunction mixkey(seed, key) {\n var stringseed = seed + '', smear, j = 0;\n while (j < stringseed.length) {\n key[mask & j] =\n mask & ((smear ^= key[mask & j] * 19) + stringseed.charCodeAt(j++));\n }\n return tostring(key);\n}\n\n//\n// autoseed()\n// Returns an object for autoseeding, using window.crypto and Node crypto\n// module if available.\n//\nfunction autoseed() {\n try {\n var out;\n if (nodecrypto && (out = nodecrypto.randomBytes)) {\n // The use of 'out' to remember randomBytes makes tight minified code.\n out = out(width);\n } else {\n out = new Uint8Array(width);\n (global.crypto || global.msCrypto).getRandomValues(out);\n }\n return tostring(out);\n } catch (e) {\n var browser = global.navigator,\n plugins = browser && browser.plugins;\n return [+new Date, global, plugins, global.screen, tostring(pool)];\n }\n}\n\n//\n// tostring()\n// Converts an array of charcodes to a string\n//\nfunction tostring(a) {\n return String.fromCharCode.apply(0, a);\n}\n\n//\n// When seedrandom.js is loaded, we immediately mix a few bits\n// from the built-in RNG into the entropy pool. Because we do\n// not want to interfere with deterministic PRNG state later,\n// seedrandom will not call math.random on its own again after\n// initialization.\n//\nmixkey(math.random(), pool);\n\n//\n// Nodejs and AMD support: export the implementation as a module using\n// either convention.\n//\nif ((typeof module) == 'object' && module.exports) {\n module.exports = seedrandom;\n // When in node.js, try using crypto package for autoseeding.\n try {\n nodecrypto = require('crypto');\n } catch (ex) {}\n} else if ((typeof define) == 'function' && define.amd) {\n define(function() { return seedrandom; });\n} else {\n // When included as a plain script, set up Math.seedrandom global.\n math['seed' + rngname] = seedrandom;\n}\n\n\n// End anonymous scope, and pass initial values.\n})(\n // global: `self` in browsers (including strict mode and web workers),\n // otherwise `this` in Node and other environments\n (typeof self !== 'undefined') ? self : this,\n [], // pool: entropy pool starts empty\n Math // math: package containing random, pow, and seedrandom\n);\n"],"names":["_scriptDir","exportCppDbscanLib","document","currentScript","src","undefined","readyPromiseResolve","readyPromiseReject","Module","Promise","resolve","reject","readBinary","moduleOverrides","Object","assign","ENVIRONMENT_IS_WEB","window","ENVIRONMENT_IS_WORKER","importScripts","scriptDirectory","process","versions","node","self","location","href","indexOf","substr","replace","lastIndexOf","url","xhr","XMLHttpRequest","open","responseType","send","Uint8Array","console","log","bind","wasmBinary","wasmMemory","err","warn","WebAssembly","abort","HEAP8","HEAPU8","HEAPU32","ABORT","updateMemoryViews","b","buffer","Int8Array","Int16Array","Int32Array","Uint16Array","Uint32Array","Float32Array","Float64Array","__ATPRERUN__","__ATINIT__","__ATPOSTRUN__","runDependencies","runDependencyWatcher","dependenciesFulfilled","what","e","RuntimeError","wasmBinaryFile","path","isDataURI","filename","startsWith","getBinary","file","instantiateArrayBuffer","binaryFile","imports","receiver","fetch","then","credentials","response","catch","getBinaryPromise","binary","instantiate","instance","reason","callRuntimeCallbacks","callbacks","length","shift","ExceptionInfo","excPtr","this","ptr","set_type","type","get_type","set_destructor","destructor","get_destructor","set_caught","caught","get_caught","set_rethrown","rethrown","get_rethrown","init","set_adjusted_ptr","adjustedPtr","get_adjusted_ptr","get_exception_ptr","___cxa_is_pointer_type","adjusted","emscripten_realloc_buffer","size","grow","byteLength","getCFunc","ident","UTF8Decoder","TextDecoder","ccall","returnType","argTypes","args","opts","toC","str","ret","len","i","c","charCodeAt","lengthBytesUTF8","stackAlloc","outPtr","maxBytesToWrite","heap","outIdx","endIdx","u","stringToUTF8Array","stringToUTF8","stringToUTF8OnStack","arr","array","set","func","cArgs","stack","converter","stackSave","apply","stackRestore","heapOrArray","idx","maxBytesToRead","endPtr","decode","subarray","u0","u1","u2","String","fromCharCode","ch","UTF8ArrayToString","Boolean","convertReturnValue","onDone","calledRun","wasmImports","dest","num","copyWithin","requestedSize","x","oldSize","maxHeapSize","cutDown","overGrownHeapSize","Math","min","max","callback","info","receiveInstance","module","cb","exports","unshift","clearInterval","removeRunDependency","result","instantiateStreaming","createWasm","arguments","run","doRun","postRun","preRun","setTimeout","numericArgs","every","runCaller","pop","ready","define","isNil","insertSmaller","distancesAr","indexes","index","newPosition","findIndex","v","splice","assert","condition","message","Error","vectorDistanceMetricsMethods","Euclidean","p","q","pow","sqrt","stringDistanceMetricsMethods","Levenshtein","JaroWinkler","Manhattan","s1","s2","dist","Onehot","bitArrayDistanceMetricsMethods","Tanimoto","Dice","Asymmetric","BraunBlanquet","Cosine","Kulczynski","McConnaughey","RogotGoldberg","Russel","Sokal","Hamming","intArrayDistanceMetricsMethods","TanimotoIntArray","numberDistanceMetricsMethods","Difference","numberArrayDistanceMetrics","CommonItems","AvailableMetrics","Vector","BitArray","MacroMolecule","HAMMING","LEVENSHTEIN","NEEDLEMANN_WUNSCH","MONOMER_CHEMICAL_DISTANCE","Number","IntArray","NumberArray","MetricToDataType","keys","reduce","key","val","Measure","constructor","method","dataType","metricNeedsArgs","toString","name","isNumberArrayMetric","getMeasure","dict","hasOwnProperty","getMetricByDataType","availableMeasures","DistanceMatrixService","useConcurrentWorkers","terminateOnComplete","threadCount","navigator","hardwareConcurrency","_workerCount","_workers","Array","fill","map","Worker","URL","_terminateOnComplete","calc","values","fnName","normalize","calcMulti","MANHATTAN","fnNames","weights","aggregationMethod","async","promises","totalLength","chunkSize","distanceMatrix","endRow","endCol","lmin","lmax","MIN_VALUE","start","floor","end","startRow","startCol","postMessage","chunckSize","resolveWorker","rejectWorker","onmessage","data","error","distanceMatrixData","terminate","all","forEach","value","worker","tauRandInt","n","random","tauRand","empty","output","push","range","_","filled","zeros","mean","input","sum","rejectionSample","nSamples","poolSize","rejectSample","j","broken","k","reshape2d","a","rows","col","makeHeap","nPoints","makeArrays","fillValue","Infinity","heapPush","row","weight","flag","indices","uncheckedHeapPush","isNew","iSwap","ic1","ic2","heapShape2","buildCandidates","currentGraph","nVertices","nNeighbors","maxCandidates","candidateNeighbors","isn","d","deheapSort","indHeap","distHeap","indHeapIndex","distHeapIndex","temp1","temp2","siftDown","heap1","heap2","ceiling","elt","leftChild","rightChild","swap","smallestFlagged","ind","minDist","resultIndex","SparseMatrix","cols","dims","entries","Map","nRows","nCols","checkDims","makeKey","has","get","defaultValue","getAll","ordered","rowColValues","sort","getDims","getRows","from","_key","getCols","getValues","fn","vals","toArray","matrix","oldRows","oldCols","oldVals","matlen","pairwiseMultiply","elementWise","y","add","subtract","multiplyScalar","scalar","eliminateZeros","m","zeroIndices","Set","removeByZeroIndex","nextValues","filter","nextRows","nextCols","normType","normFn","normFns","colsByRow","nextMatrix","norm","xs","op","visited","operate","nextValue","valuesA","rowsA","colsA","valuesB","rowsB","colsB","getCSR","indptr","currentRow","FlatTree","hyperplanes","offsets","children","makeForest","nTrees","leafSize","trees","makeEuclideanTree","makeTree","forest","tree","nNodes","numNodes","nLeaves","numLeaves","hyperplane","recursiveFlatten","flattenTree","splitResults","leftIndex","rightIndex","left","right","hyperplaneOffset","hyperplaneVector","nLeft","nRight","side","margin","indicesLeft","indicesRight","offset","euclideanRandomProjectionSplit","isLeaf","nodeNum","leafNum","oldNodeNum","res","selectSide","point","searchFlatTree","prototype","isAnyArray","object","call","endsWith","errorCalculation","parameters","parameterizedFunction","abs","step","params","damping","gradientDifference","identity","eye","evaluatedData","gradientFunc","paramFunction","ans","param","auxParams","slice","funcParam","gradientFunction","matrixFunc","matrixFunction","inverseMatrix","mmul","transpose","sub","mul","to1DArray","SMOOTH_K_TOLERANCE","MIN_K_DIST_SCALE","UMAP","neighbors","learningRate","localConnectivity","nComponents","nEpochs","negativeSampleRate","repulsionStrength","setOpMixRatio","spread","transformQueueSize","targetMetric","targetWeight","targetNNeighbors","distanceFn","numeric","isInitialized","rpForest","embedding","optimizationState","OptimizationState","setParam","fit","X","initializeFit","optimizeLayout","fitAsync","optimizeLayoutAsync","setSupervisedProjection","Y","setPrecomputedKNN","knnIndices","knnDistances","getNEpochs","knnResults","nearestNeighbors","graph","fuzzySimplicialSet","makeSearchFns","searchGraph","makeSearchGraph","processGraphForSupervisedProjection","head","tail","epochsPerSample","initializeSimplicialSetEmbedding","initializeOptimization","prepareForOptimizationLoop","initFromTree","initFromRandom","queryPoints","_heap","_tree","search","initialization","tried","vertex","candidates","candidate","knn","distances","neighbor","distance","transform","toTransform","rawData","results","adjustedLocalConnectivity","sigmas","rhos","smoothKNNDistance","computeMembershipStrengths","csrMatrix","_z","initTransform","graphMax","makeEpochsPerSample","assignOptimizationStateParameters","headEmbedding","tailEmbedding","currentEpoch","farDist","categoricalSimplicialSetIntersection","optimizeLayoutStep","getEmbedding","metricNNDescent","leafArray","nIters","delta","rho","rpTreeInit","cj","ck","round","log2","sparseMatrix","prodMatrix","simplicialSet","target","unknownDist","intersection","exp","fastIntersection","resetLocalConnectivity","nIter","bandwidth","lo","hi","mid","ithDistances","nonZeroDists","interpolation","psum","meanIthDistances","meanDistances","graphValues","entry","w","state","dim","moveOther","epochsPerNegativeSample","epochOfNextNegativeSample","epochOfNextSample","initialAlpha","alpha","gamma","xv","yv","parameterValues","options","maxIterations","errorTolerance","minValues","maxValues","initialValues","parLen","MAX_SAFE_INTEGER","MIN_SAFE_INTEGER","iteration","converged","isNaN","parameterError","iterations","findABParams","current","other","distSquared","rDist","gradCoeff","gradD","clip","nNegSamples","epochCallback","epochCompleted","shouldStop","isFinished","clipValue","TSNE","getopt","opt","field","defaultval","gaussRandom","returnV","vValue","r","randn","mu","std","ArrayBuffer","randn2d","s","uses","l2","x1","x2","D","x1i","x2i","xtod","N","getIterSize","rowSize","d2p","perplexity","tol","indexer","hTarget","P","prow","betamin","betamax","beta","done","maxtries","pj","nHere","pOut","N2","sign","iter","epsilon","initDataRaw","dists","initSolution","initDataDist","time","timeEnd","gains","ystep","getSolution","cg","costGrad","cost","grad","ymean","gid","sid","gainid","newgain","newsid","debugGrad","yold","cg0","cg1","analytic","numerical","pmul","quArr","qsum","qu","prev","Q","premult","thisArg","_arguments","generator","fulfilled","next","rejected","gpuAdapter","gpuDevice","gpu","requestAdapter","powerPreference","isLost","lost","requiredBufferSize","adapterLimits","limits","buffferSizeLimit","maxBufferSize","storageBufferSizeLimit","maxStorageBufferBindingSize","requestDevice","requiredLimits","WEBGSLAGGREGATION","EUCLIDEAN","arraySize","WEBGPUDISTANCE","_maxArraySize","entryIndex","maxArraySize","_entryIndex","TANIMOTO","LEVENSTEIN","NEEDLEMAN_WUNSCH","SOKAL","COSINE","ASYMMETRIC","OneHot","distanceFunctionComplexity","maxEntrySize","ceil","_maxEntrySize","TypeSupportedDistances","MatrixMatrixOpType","MatrixOpType","MatrixScalarOpType","multiColWebGPUKNN","entryList","knnSize","distanceMetrics","aggregationFunction","some","list","availableDistanceMetrics","metric","includes","join","numOfColumns","device","deviceLost","listSize","processInfo","distanceMetric","gapOpenPenalty","gapExtensionPenalty","_a","_b","entryType","encodedList","split","_data","encodedListType","arraySizes","maxEntryLen","complexity","EncodedArrayConstructor","flatSourceArray","seq","suppInfoStructWgsl","suppInfoSize","suppInfoType","suppInfoBuffer","maxMonomerIndex","scoringMatrix","alphabetIndexes","similarityMatrixSize","transferedSimilarityMatrix","key2","dataTypeWGSL","dataStructWgsl","sourceArraySize","suppInfoWgsl","wgsl","needsDummy","trim","combinedComplexity","dataWgsl","computationsPerPass","pairComparisonsPerPass","workgroupsDim","globalThreadDimSize","resultIndexes","resultDistances","createShaderModule","label","code","getCombinedDistanceScript","pipeline","createComputePipeline","layout","compute","entryPoint","computeInfo32Size","suppInfo32Size","computeInfoBufferSize","BYTES_PER_ELEMENT","paddedComputeInfoBufferSize","remainder","computeInfoBuffer","createBuffer","usage","GPUBufferUsage","STORAGE","COPY_SRC","COPY_DST","mappedAtCreation","mappedComputeInfoArrayBuffer","getMappedRange","startAt","endAt","pairComparisonStartAt","pairComparisonEndAt","computeInfoOffSet","ArrayConstructor","unmap","suppInfoBufferSize","paddedSuppInfoBufferSize","suppInfoRemainder","mappedSuppInfoArrayBuffer","suppInfoOffSet","outKnnArraySize","bufferDistances","bufferIndexes","bytesPerOutArrayRow","bindGroup","createBindGroup","getBindGroupLayout","binding","resource","resultBufferDistances","MAP_READ","resultBufferIndexes","pairComparisonPasses","pairIter","queue","writeBuffer","encoder","createCommandEncoder","pass","beginComputePass","setPipeline","setBindGroup","dispatchWorkgroups","workGroupDivision","copyBufferToBuffer","commandBuffer","finish","submit","onSubmittedWorkDone","mapAsync","GPUMapMode","READ","destroy","knnIndexes","maxEntryLens","aggregation","pairwiseOpSparse","indexes1","distances1","offsets1","indexes2","distances2","offsets2","numOfEntries","unionMatrixOffsets","requiredWorkgroups","threadsPerWorkgroupDim","numOfWorkgroupsPerDim","threadsPerYDimension","sparseSize1","sparseSize2","unionMatrixSize","processWgsl","paddedStorage1ByteSize","remainder1","paddedStorage2ByteSize","remainder2","paddedResStorageByteSize","remainder3","source1Buffer","mappedSource1Buffer","source2Buffer","mappedSource2Buffer","resBuffer","unionMatrixOffsetsBuffer","mappedUnionMatrixOffsetsBuffer","resultBuffer","resultArrayBuffer","resultKnnIndexes","resultKnnDistances","weightSquare","centralDifference","nbParams","nbPoints","rowIndex","funcParam2","residualError","scale","jacobianWeightResidualError","perturbations","checkTimeout","dampingStepUp","dampingStepDown","improvementThreshold","timeout","filler","endTime","Date","now","checkOptions","optimalError","optimalParameters","previousError","toOffsetForm","ar","performMatrixOps","flatKnnIndexes","flatKnnDistances","unionInfo","entryLen","knnMatrixOpInfoWGSL","indexesBuffer32Size","indexBuffer","mappedIndexesBuffer","mappedIndexesArray","sizesBuffer","unionSizesBuffer","mappedUnionSizesBuffer","resultTransposeSizesBuffer","resultUnionSizesBuffer","resultTransposeSizesArrayBuffer","resultUnionSizesArrayBuffer","resultTransposeSizesArray","resultUnionSizesArray","old","getKnnSparseOpInfo","transposed","knnSparseInfo","fullKnnEntrySize","transposeOffsets","offsetsCopy","transposeKNNIndexes","transposeKNNDistances","otherIndex","otherIndexOffset","transposeKNN","sourceOffsets","transposeMultRes","addRes","subtRes","unionSizes","meanDistancesSum","currentMean","smoothKNNDistanceWGSL","distanceBuffer32Size","resultSigmas","resultRhos","distancesBuffer","mappedDistanceBuffer","mappedDistanceArray","bufferSigmas","bufferRhos","resultBufferRhos","resultBufferSigmas","UmapParams","nNeighbours","WebGPUUMAP","membershipStrengths","calcSmoothKNNDistances","calcMembershipStrengths","umapParams","resEmbeddings","embeddingSize","divisionFactor","headSize","processWGSL","embedSize","workgroupDim","threadsPerRow","optimizeLayoutWGSL","paddedMatrixStorageSize","paddedepochStorageSize","paddedembedStorageSize","paddedComputeInfoSize","remainder4","matrixStorageBuffer","matrixStorageArrayBuffer","epochStorageBuffer","epochStorageArrayBuffer","epochStorageArrayView","headEmbeddings","embeddingStorageBuffer","mappedEmbeddingStorageBuffer","mappedEmbeddingStorageArray","randomNumbers","computeInfoArrayBuffer","outEmbedViewBuffer","resArrayBuffer","headEmbeddingsView","optimizationLoop","sigmasLength","rhosLength","computeMembershipStrengthsWGSL","paddedCombinedMembershipStructByteSize","membershipStrengthsInfoBuffer","mappedInfoBuffer","mappedInfoArray","knnDistancesBuffer","resultKnnDistancesArrayBuffer","bytesPerKnnRow","resKnnDistances","dataView","out","fuzzySimplicialSetRes","eRes","maxVal","cur","minGraphVal","unionSizesCopy","offsetAccum","nonZeroGraphOffsets","nonZeroGraphSize","MultiColumnReducer","TSNEReducer","super","randomSeed","randomFn","reducer","distanceFnames","distanceFns","distanceFnArgs","progressFunc","matrixService","UMAPReducer","useWebGPU","vectors","_parallelDistanceWorkers","knnGraph","multiColumnKNN","webGPUReducer","epoc","AvailableReducers","MultiColDimReducer","metrics","distanceAggregation","measures","measure","bitArrayLength","_length","transposeMatrix","availableMetricsByType","typeName","availableMethods","availableMetrics","obj","epochNum","epochsLength","columnsData","onMessage","alea","xor128","xorwow","xorshift7","xor4096","tychei","sr","global","Alea","seed","me","mash","h","t","s0","copy","f","impl","xg","prng","int32","double","quick","XorGen","strseed","z","limit","pool","math","nodecrypto","width","startdenom","significance","overflow","mask","seedrandom","shortseed","mixkey","flatten","entropy","tostring","randomBytes","crypto","msCrypto","getRandomValues","browser","plugins","screen","autoseed","arc4","ARC4","g","S","is_math_call","keylen","count","depth","prop","typ","smear","stringseed","ex"],"sourceRoot":""}